Merge pull request #3 from EmberLang/feature/ast-type-side-table

refactor: integrate ExprTypes side table into context for persistent …

Author: itsfuad

COMPILER_GUIDELINES.md

@@ -13,7 +13,7 @@ The goal is not to copy Rust or any other compiler blindly. The goal is to build
 
 Do not cargo-cult architecture.
 
-When reusing ideas from Rust or any other compiler:
+When reusing ideas from Rust, Zig or any other compiler:
 
 - copy the idea only if it fits this language
 - simplify when the full design is not needed yet
@@ -58,10 +58,9 @@ These decisions are already part of the language design and should not drift acc
 - Zig-style literals are used: `.{ ... }`
 - methods are declared outside types using attached-method syntax with receivers.
 - `defer` and `panic` are part of the core control-flow model
-- builtin functions are declared in `ember_libs_dev/global.em`
-- stdlib source modules are declared in `ember_libs_dev/std/*.em`
-- builtin declarations use `#[builtin]` and may omit a body
-- external declarations use `#[extern(\"...\")]` and may omit a body
+- builtin functions are declared in `_builtin_library/global.em`
+- stdlib source modules are declared in `_builtin_library/std/*.em`
+- external declarations use `#[extern(\"...\")]` and may omit a body. extern can contain the external linking function name as parameter or keep empty for default behavior.
 - error unions are explicit value-level control flow and are not exceptions
 
 If implementation changes conflict with this, update the language spec first.
@@ -77,10 +76,6 @@ The compiler should be split into clear layers.
 - `hir`: all HIR data structures and HIR-local transforms
 - `mir`: MIR and MIR-local transforms
 - `semantics`: name resolution, type checking, ownership checks
-- `layout`: physical type layout, alignment, size, and field-slot mapping
-- `cfg`: CFG data model only
-- `cfganalysis`: CFG construction and CFG-based analyses
-- `codegen`: lowering and backend work
 
 No package should mix all of these concerns.
 
@@ -90,27 +85,7 @@ HIR-specific rule:
 - keep HIR-related code under `hir`
 - if HIR grows, prefer subpackages under `hir/...` over creating parallel top-level `hir*` packages again
 
-## 5. Lexer Rules
-
-The lexer is not a parser.
-
-- tokenize only
-- no semantic decisions
-- no type inference
-- no ownership analysis
-- no parser-level hacks
-
-Use regex/token-pattern driven tokenization when it improves clarity.
-Do not use regex just because another compiler did. Use it only when the token class is naturally pattern-based, such as numeric literals.
-
-When adding token support:
-
-- keep token names general enough for later phases
-- prefer `NUMBER` over fake subcategories unless syntax requires the split
-- keep literals normalized only when that is clearly beneficial
-- do not silently erase information needed by later phases
-
-## 6. Parser Rules
+## 5. Parser Rules
 
 The parser should build syntax, not interpretation.
 
@@ -127,7 +102,7 @@ Parser code should answer:
 
 If a function makes that hard to see, rewrite it.
 
-## 7. AST Rules
+## 6. AST Rules
 
 AST nodes represent source structure, not semantic conclusions.
 
@@ -140,7 +115,7 @@ Examples:
 - `NumberLit` is better than `IntLit` if the lexer accepts non-integer numerics
 - `ImportDecl` should exist if imports are part of module syntax
 
-## 8. Context And Pipeline Rules
+## 7. Context And Pipeline Rules
 
 Use a central compiler context for shared state.
 
@@ -175,7 +150,7 @@ The pipeline owns:
 
 Do not hide pipeline behavior inside parser or lexer code.
 
-## 8.1 Phase Responsibilities
+## 7.1 Phase Responsibilities
 
 Phase ownership must stay explicit.
 
@@ -255,7 +230,7 @@ Reason:
 - it interacts with control flow, reinitialization, and escapes
 - keeping it separate makes the typechecker simpler and keeps ownership logic aligned with later CFG/data-flow work
 
-## 8.2 Unwind And Error Model
+## 7.2 Unwind And Error Model
 
 Do not conflate `panic` with `E!T`.
 
@@ -273,7 +248,7 @@ This implies:
 
 Do not fake panic semantics by lowering it to an ordinary call and hoping codegen reconstructs unwind behavior later.
 
-## 8.3 Semantic Order vs Physical Layout
+## 7.3 Semantic Order vs Physical Layout
 
 Semantic field order and physical field layout are different concepts.
 

internal/analysis/semantics/collector/collector.go

@@ -20,7 +20,7 @@ func (c *collector) collectModule(mod *ast.Module) {
 		return
 	}
 	c.module.ModuleScope = table.New(c.ctx.GlobalScope)
-	c.module.ResetSemantics()
+	c.module.ResetSemanticData()
 	for alias := range c.module.Imports {
 		if alias == "" {
 			continue

internal/analysis/semantics/ownership/checker.go

@@ -252,6 +252,11 @@ func (c *checker) exprType(scope *table.Scope, expr ast.Expr) symbols.Type {
 	if c == nil || scope == nil || expr == nil {
 		return nil
 	}
+	if c.module != nil && c.module.ExprTypes != nil {
+		if t, ok := c.module.ExprTypes[expr]; ok && t != nil {
+			return t
+		}
+	}
 	switch node := expr.(type) {
 	case *ast.Ident:
 		sym, ok := scope.Lookup(node.Name)

internal/analysis/semantics/typechecker/typechecker.go

@@ -274,13 +274,20 @@ func (c *checker) checkFunctionShape(decl *ast.FnDecl) {
 	}
 }
 
-// typeExpr computes the type of an expression using scope lookup and returns it.
-// The typechecker no longer builds a parallel typeinfo.Expr tree — types are
-// stored directly on symbols. HIR-lower will re-derive types during lowering.
-func (c *checker) typeExpr(scope *table.Scope, expr ast.Expr, expected typeinfo.Type) typeinfo.Type {
+// typeExpr computes the type of an expression using scope lookup, records it in the
+// module's ExprTypes side table for downstream phases, and returns it.
+func (c *checker) typeExpr(scope *table.Scope, expr ast.Expr, expected typeinfo.Type) (resolved typeinfo.Type) {
 	if expr == nil {
 		return nil
 	}
+	defer func() {
+		if resolved != nil && c.module != nil {
+			if c.module.ExprTypes == nil {
+				c.module.ExprTypes = make(map[ast.Expr]typeinfo.Type)
+			}
+			c.module.ExprTypes[expr] = resolved
+		}
+	}()
 	switch node := expr.(type) {
 	case *ast.NumberLit:
 		return c.typeNumber(node, expected)

internal/context/context.go

@@ -72,6 +72,8 @@ type Module struct {
 	ModuleScope *table.Scope
 	// Mappings from block statements to resolved block scopes.
 	BlockScopes map[*ast.BlockStmt]*table.Scope
+	// Mappings from expressions to resolved types.
+	ExprTypes map[ast.Expr]typeinfo.Type
 	// Import alias -> resolved module import.
 	Imports map[string]ResolvedImport
 
@@ -221,9 +223,10 @@ func declarePredeclaredConst(scope *table.Scope, name string) {
 	}
 }
 
-func (m *Module) ResetSemantics() {
+func (m *Module) ResetSemanticData() {
 	if m == nil {
 		return
 	}
 	m.BlockScopes = make(map[*ast.BlockStmt]*table.Scope)
+	m.ExprTypes = make(map[ast.Expr]typeinfo.Type)
 }

internal/ir/hir_lower/lower.go

@@ -213,79 +213,114 @@ func lowerElse(module *context.Module, scope *table.Scope, stmt ast.Stmt, return
 }
 
 // lowerASTExpr directly lowers an AST expression to an IR expression using
-// scope lookup for symbol resolution and expectedType for literal coercion.
+// the module context's resolved expression types side-table.
 func lowerASTExpr(ctx *context.CompilerContext, module *context.Module, scope *table.Scope, expr ast.Expr, expectedType string) ir.Expr {
 	if expr == nil {
 		return &ir.InvalidExpr{Message: "nil expression", Type: "<invalid>"}
 	}
+
+	// Fetch canonical type from the typechecker side-table when available.
+	resolvedTypeStr := ""
+	if module != nil && module.ExprTypes != nil {
+		if t, ok := module.ExprTypes[expr]; ok && t != nil {
+			resolvedTypeStr = typeinfo.TypeText(t)
+		}
+	}
+
 	switch node := expr.(type) {
 	case *ast.NumberLit:
-		return lowerNumberLit(node, expectedType)
+		t := resolvedTypeStr
+		if t == "" {
+			t = expectedType
+		}
+		return lowerNumberLit(node, t)
 
 	case *ast.StringLit:
-		return &ir.StringLit{Value: node.Value, Type: "cstr"}
+		t := resolvedTypeStr
+		if t == "" || t == "<invalid>" {
+			t = "cstr"
+		}
+		return &ir.StringLit{Value: node.Value, Type: t}
 
 	case *ast.Ident:
 		sym, ok := scope.Lookup(node.Name)
 		if !ok || sym == nil {
 			return &ir.InvalidExpr{Message: "unresolved identifier: " + node.Name, Type: "<invalid>"}
 		}
-		return &ir.Ident{Name: symbolName(sym), Type: symTypeText(sym)}
+		t := resolvedTypeStr
+		if t == "" || t == "<invalid>" || t == "<unknown>" {
+			t = symTypeText(sym)
+		}
+		return &ir.Ident{Name: symbolName(sym), Type: t}
 
 	case *ast.ScopeResolution:
 		if sym := lookupScopeResolutionSymbol(ctx, module, scope, node); sym != nil {
-			return &ir.Ident{Name: symbolName(sym), Type: symTypeText(sym)}
+			t := resolvedTypeStr
+			if t == "" || t == "<invalid>" || t == "<unknown>" {
+				t = symTypeText(sym)
+			}
+			return &ir.Ident{Name: symbolName(sym), Type: t}
 		}
 		return &ir.InvalidExpr{Message: "unresolved qualified identifier: " + node.Module.Name + "::" + node.Name.Name, Type: "<invalid>"}
 
 	case *ast.UnaryExpr:
 		arg := lowerASTExpr(ctx, module, scope, node.Expr, expectedType)
-		exprType := arg.TypeText()
-		if node.Op == "!" {
-			exprType = "bool"
+		t := resolvedTypeStr
+		if t == "" || t == "<invalid>" {
+			t = arg.TypeText()
+			if node.Op == "!" {
+				t = "bool"
+			}
 		}
-		return &ir.Unary{Op: node.Op, Arg: arg, Type: exprType}
+		return &ir.Unary{Op: node.Op, Arg: arg, Type: t}
 
 	case *ast.BinaryExpr:
 		left := lowerASTExpr(ctx, module, scope, node.Left, expectedType)
 		right := lowerASTExpr(ctx, module, scope, node.Right, expectedType)
-		exprType := left.TypeText()
-		switch node.Op {
-		case "==", "!=", "<", "<=", ">", ">=", "&&", "||":
-			exprType = "bool"
+		t := resolvedTypeStr
+		if t == "" || t == "<invalid>" {
+			t = left.TypeText()
+			switch node.Op {
+			case "==", "!=", "<", "<=", ">", ">=", "&&", "||":
+				t = "bool"
+			}
 		}
-		return &ir.Binary{Op: node.Op, Left: left, Right: right, Type: exprType}
+		return &ir.Binary{Op: node.Op, Left: left, Right: right, Type: t}
 
 	case *ast.CallExpr:
 		calleeExpr := lowerASTExpr(ctx, module, scope, node.Callee, "")
 		args := make([]ir.Expr, 0, len(node.Args))
 		for _, arg := range node.Args {
 			args = append(args, lowerASTExpr(ctx, module, scope, arg, ""))
 		}
-		// Get the return type from the callee symbol (handles qualified callees too).
-		retType := "<invalid>"
-		var sym *symbols.Symbol
-		switch callee := node.Callee.(type) {
-		case *ast.Ident:
-			if s, ok := scope.Lookup(callee.Name); ok {
-				sym = s
-			}
-		case *ast.ScopeResolution:
-			if s := lookupScopeResolutionSymbol(ctx, module, scope, callee); s != nil {
-				sym = s
+		t := resolvedTypeStr
+		if t == "" || t == "<invalid>" {
+			var sym *symbols.Symbol
+			switch callee := node.Callee.(type) {
+			case *ast.Ident:
+				if s, ok := scope.Lookup(callee.Name); ok {
+					sym = s
+				}
+			case *ast.ScopeResolution:
+				if s := lookupScopeResolutionSymbol(ctx, module, scope, callee); s != nil {
+					sym = s
+				}
 			}
-		}
-		if sym != nil {
-			if fnType, ok := sym.Type.(*typeinfo.FuncType); ok && fnType != nil && fnType.Return != nil {
-				retType = typeinfo.TypeText(fnType.Return)
+			if sym != nil {
+				if fnType, ok := sym.Type.(*typeinfo.FuncType); ok && fnType != nil && fnType.Return != nil {
+					t = typeinfo.TypeText(fnType.Return)
+				}
 			}
 		}
-		return &ir.Call{Callee: calleeExpr, Args: args, Type: retType}
+		return &ir.Call{Callee: calleeExpr, Args: args, Type: t}
 
 	case *ast.AsExpr:
-		targetTypeStr := typeinfo.TypeText(typeinfo.TypeFromSyntax(node.TypeExpr))
-		subExpr := lowerASTExpr(ctx, module, scope, node.Expr, targetTypeStr)
-		return &ir.Cast{Expr: subExpr, Type: targetTypeStr}
+		t := resolvedTypeStr
+		if t == "" || t == "<invalid>" {
+			t = typeinfo.TypeText(typeinfo.TypeFromSyntax(node.TypeExpr))
+		}
+		subExpr := lowerASTExpr(ctx, module, scope, node.Expr, t)
+		return &ir.Cast{Expr: subExpr, Type: t}
 
 	default:
 		return &ir.InvalidExpr{Message: "unsupported expression", Type: "<invalid>"}