Semantic Analysis v6

hard · compilers, semantics, types

Semantic Analysis v6

Validate v6 programs with modules and static types.

Function signature

func Analyze(prog *Program) []string

Return a slice of error strings (in the order discovered). If there are no errors, return nil or an empty slice.

New type rules

Variable declarations

If a type annotation is present, the initializer (if any) must be assignable.
If no annotation is present, the initializer must exist and be inferable.
Empty arrays/maps require an annotation.

Function declarations

Parameter types are required.
Return type is required.
return expressions must be assignable to the declared return type.

Expressions

+ works on numbers or strings only.
- * / work on numbers only.
&& || ! work on bools only.
< <= > >= work on numbers only.
== != require compatible types.
Arrays and maps must be homogeneous.
Map keys must be number/bool/string.

Assignability

Types must match structurally.
nil is assignable to any type.

Module rules (from v5)

Unique module names.
main exists and is last.
Imports refer to earlier modules.
Member access requires exported names.

Notes

Keep error messages simple and consistent.

package solution

type VarKind int

const (
	VarLet VarKind = iota
	VarVar
	VarConst
)

type StmtKind int

const (
	StmtVar StmtKind = iota
	StmtAssign
	StmtExpr
	StmtIf
	StmtWhile
	StmtFor
	StmtBreak
	StmtContinue
	StmtReturn
	StmtBlock
	StmtFn
)

type Stmt struct {
	Kind       StmtKind
	Exported   bool
	VarKind    VarKind
	Name       string
	Expr       *Expr
	Target     *Expr
	Body       []*Stmt
	Else       []*Stmt
	Params     []string
	ParamTypes []*Type
	ReturnType *Type
	TypeAnn    *Type
	Init       *Stmt
	Post       *Stmt
	Cond       *Expr
}

type Program struct {
	Modules []*Module
}

type Module struct {
	Name    string
	Imports []Import
	Stmts   []*Stmt
}

type Import struct {
	Name  string
	Alias string
}

type ExprKind int

const (
	ExprNumber ExprKind = iota
	ExprString
	ExprBool
	ExprNil
	ExprIdent
	ExprUnary
	ExprBinary
	ExprCall
	ExprArray
	ExprMap
	ExprIndex
	ExprMember
)

type TypeKind int

const (
	TypeNumber TypeKind = iota
	TypeBool
	TypeString
	TypeNil
	TypeArray
	TypeMap
	TypeFunc
	TypeUnknown
)

type Type struct {
	Kind   TypeKind
	Elem   *Type
	Key    *Type
	Value  *Type
	Params []*Type
	Return *Type
}

type MapPair struct {
	Key   *Expr
	Value *Expr
}

type Expr struct {
	Kind  ExprKind
	Value string
	Left  *Expr
	Right *Expr
	Args  []*Expr
	Elems []*Expr
	Pairs []MapPair
}

// Analyze checks semantic rules and returns error messages.
func Analyze(prog *Program) []string {
	// TODO: implement semantic analysis.
	return nil
}