Semantic Analysis v5

hard · compilers, semantics, modules

Semantic Analysis v5

Validate v5 programs with modules, imports/exports, and member access.

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.

Rules

Modules

Module names must be unique: duplicate module: <name>.
A module can only import modules defined earlier in the program.
- Unknown module: unknown module: <name>
- Importing a later module: import of future module: <name>
The main module must exist and must be last: main module must be last.

Imports and exports

Import aliases live in the module scope and must be unique.
export only applies to fn or let/var/const declarations.
Exported names must exist and be unique per module.

Member access

m.name requires m to be an imported module alias.
- Unknown module alias: unknown module: <name>
The member must be exported by that module:
- unknown export: <module>.<name>

Existing v4 rules still apply

Undefined name: undefined name: <name>.
Redeclare in same scope: redeclare in same scope: <name>.
Const requires initializer: const requires initializer: <name>.
Cannot assign to const: cannot assign to const: <name>.
return outside function: return outside function.
break/continue outside loop.
Function call arity checks for identifier callees.

Notes

Treat function declarations as const bindings.
Keep the analyzer readable and straightforward.

Function and loop boundaries

A loop body is a block nested inside the for initializer scope. Body locals may shadow initializer bindings and are not visible in the post clause. Entering a nested function resets loop context for that function; restore the outer context afterward. Break/continue cannot target a loop in a different function, even when the function declaration appears inside that loop.

Before implementation

Use the module’s worked reconstruction and independent debugging lab to predict an intermediate artifact first. Preserve one failing counterexample while implementing the stated API. The lesson’s transfer task uses a fresh case after the guided trace.

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
	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 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
}