Code Model

A set of models that represent code, such as structs and functions. The motivation behind this module is to provide a more generic, and lighter alternative to v.ast code models, that can be used for code parsing and code generation across multiple languages.

Using Codemodel

While the models in this module can be used in any domain, the models here are used extensively in the modules codeparser and codegen (under development). Below are examples on how codemodel can be used for parsing and generating code.## Code parsing with codemodel

As shown in the example below, the codemodels returned by the parser can be used to infer information about the code written

code := codeparser.parse('somedir') // code is a list of code models

num_functions := code.filter(it is Function).len
structs := code.filter(it is Struct)
println('This directory has ${num_functions} functions')
println('The directory has the structs: ${structs.map(it.name)}')

or can be used as intermediate structures to serialize code into some other format:

code_md := ''

// describes the struct in markdown format
for struct in structs {
    code_md +='# ${struct.name}'
    code_md +='Type: ${struct.typ.symbol}'
    code_md += '## Fields:'
    for field in struct.fields {
        code_md +='- ${field.name}'
    }
}

The openrpc/docgen module demonstrates a good use case, where codemodels are serialized into JSON schema's, to generate an OpenRPC description document from a client in v.

fn get_struct(params GetStruct) ?Struct

fn inflate_struct_fields(code []CodeItem, mut struct_ CodeItem)

fn inflate_types(mut code []CodeItem)

fn new_file(config CodeFile) CodeFile

fn parse_const(code_ string) !Const

fn parse_consts(code_ string) ![]Const

fn parse_function(code_ string) !Function

fn parse_import(code_ string) Import

fn parse_param(code_ string) !Param

fn parse_result(code_ string) !Result

fn vgen(code []CodeItem) string

fn vgen_generics(generics map[string]string) string

type CodeItem = Alias | Comment | CustomCode | Function | Import | Struct | Sumtype

type Value = string

struct Alias {
pub:
	name        string
	description string
	typ         Type
}

struct Attribute {
pub:
	name    string // [name]
	has_arg bool
	arg     string // [name: arg]
}

struct CodeFile {
pub mut:
	name    string
	mod     string
	imports []Import
	consts  []Const
	items   []CodeItem
	content string
}

fn (mut file CodeFile) add_import(import_ Import) !

fn (code CodeFile) write_v(path string, options WriteOptions) !

fn (file CodeFile) get_function(name string) ?Function

fn (mut file CodeFile) set_function(function Function) !

struct Comment {
pub:
	text     string
	is_multi bool
}

struct Const {
	name  string
	value string
}

struct CustomCode {
pub:
	text string
}

item for adding custom code in

fn (custom CustomCode) vgen() string

struct Example {
	function Function
	values   map[string]Value
	result   Value
}

struct File {
pub mut:
	name      string
	extension string
	content   string
}

fn (f File) write(path string) !

struct Function {
pub:
	name     string
	receiver Param
	is_pub   bool
	mod      string
pub mut:
	description string
	params      []Param
	body        string
	result      Result
	has_return  bool
}

fn (func Function) generate_call(params GenerateCallParams) !string

fn (function Function) vgen() string

vgen_function generates a function statement for a function

struct GenerateCallParams {
pub:
	receiver string
}

struct GenerateValueParams {
}

struct GetStruct {
pub:
	code []CodeItem
	mod  string
	name string
}

struct Import {
pub mut:
	mod   string
	types []string
}

fn (mut i Import) add_types(types []string)

fn (import_ Import) vgen() string

vgen_import generates an import statement for a given type

struct Module {
pub mut:
	name       string
	files      []CodeFile
	misc_files []File
	// model   CodeFile
	// methods CodeFile
}

fn (mod Module) write_v(path string, options WriteOptions) !

struct Param {
pub:
	required    bool
	mutable     bool
	is_shared   bool
	is_optional bool
	description string
	name        string
	typ         Type
	struct_     Struct
}

fn (param Param) generate_value() !string

fn (param Param) vgen() string

struct Result {
pub mut:
	typ         Type
	description string
	name        string
	result      bool // whether is result type
	optional    bool // whether is result type
	structure   Struct
}

fn (result Result) vgen() string

vgen_function generates a function statement for a function

struct Struct {
pub mut:
	name        string
	description string
	mod         string
	is_pub      bool
	embeds      []Struct          @[str: skip]
	generics    map[string]string @[str: skip]
	attrs       []Attribute
	fields      []StructField
}

fn (structure Struct) get_type_symbol() string

fn (struct_ Struct) vgen() string

vgen_function generates a function statement for a function

struct StructField {
pub mut:
	comments    []Comment
	attrs       []Attribute
	name        string
	description string
	default     string
	is_pub      bool
	is_mut      bool
	is_ref      bool
	anon_struct Struct @[str: skip] // sometimes fields may hold anonymous structs
	typ         Type
	structure   Struct @[str: skip]
}

fn (field StructField) get_type_symbol() string

fn (field StructField) vgen() string

struct Sumtype {
pub:
	name        string
	description string
	types       []Type
}

struct Type {
pub mut:
	is_reference bool @[str: skip]
	is_map       bool @[str: skip]
	is_array     bool
	is_mutable   bool @[str: skip]
	is_shared    bool @[str: skip]
	is_optional  bool @[str: skip]
	is_result    bool @[str: skip]
	symbol       string
	mod          string @[str: skip]
}

Todo: maybe make 'is_' fields methods?

fn (type_ Type) vgen() string

Todo: enfore that cant be both mutable and shared

struct VGenerator {
	format bool
}

fn (gen VGenerator) generate_struct(struct_ Struct) !string

fn (gen VGenerator) generate_struct_field(field StructField) string

struct WriteCode {
	destination string
}

struct WriteOptions {
pub:
	format    bool
	overwrite bool
	document  bool
	prefix    string
}