tova 0.1.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tova",
-  "version": "0.1.1",
+  "version": "0.2.2",
   "description": "Tova — a modern programming language that transpiles to JavaScript, unifying frontend and backend",
   "type": "module",
   "main": "src/index.js",
@@ -33,6 +33,12 @@
   "bugs": {
     "url": "https://github.com/tova-lang/tova-lang/issues"
   },
-  "keywords": ["language", "transpiler", "fullstack", "javascript"],
+  "author": "Enoch Kujem Abassey",
+  "keywords": [
+    "language",
+    "transpiler",
+    "fullstack",
+    "javascript"
+  ],
   "license": "MIT"
 }

package/src/analyzer/analyzer.js

@@ -1,5 +1,38 @@
 import { Scope, Symbol } from './scope.js';
 import { PIPE_TARGET } from '../parser/ast.js';
+import { BUILTIN_NAMES } from '../stdlib/inline.js';
+import {
+  Type, PrimitiveType, NilType, AnyType, UnknownType,
+  ArrayType, TupleType, FunctionType, RecordType, ADTType,
+  GenericType, TypeVariable, UnionType,
+  typeAnnotationToType, typeFromString, typesCompatible,
+  isNumericType, isFloatNarrowing,
+} from './types.js';
+
+const _JS_GLOBALS = new Set([
+  'console', 'document', 'window', 'globalThis', 'self',
+  'JSON', 'Math', 'Date', 'RegExp', 'Error', 'TypeError', 'RangeError',
+  'Promise', 'Set', 'Map', 'WeakSet', 'WeakMap', 'Symbol',
+  'Array', 'Object', 'String', 'Number', 'Boolean', 'Function',
+  'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'NaN', 'Infinity',
+  'undefined', 'null', 'true', 'false',
+  'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
+  'queueMicrotask', 'structuredClone',
+  'URL', 'URLSearchParams', 'Headers', 'Request', 'Response',
+  'FormData', 'Blob', 'File', 'FileReader',
+  'AbortController', 'AbortSignal',
+  'TextEncoder', 'TextDecoder',
+  'crypto', 'performance', 'navigator', 'location', 'history',
+  'localStorage', 'sessionStorage',
+  'fetch', 'alert', 'confirm', 'prompt',
+  'Bun', 'Deno', 'process', 'require', 'module', 'exports', '__dirname', '__filename',
+  'Buffer', 'atob', 'btoa',
+]);
+
+const _TOVA_RUNTIME = new Set([
+  'Ok', 'Err', 'Some', 'None', 'Result', 'Option',
+  'db', 'server', 'client', 'shared',
+]);
 
 export class Analyzer {
   constructor(ast, filename = '<stdin>', options = {}) {
@@ -8,12 +41,20 @@ export class Analyzer {
     this.errors = [];
     this.warnings = [];
     this.tolerant = options.tolerant || false;
+    this.strict = options.strict || false;
     this.globalScope = new Scope(null, 'module');
     this.currentScope = this.globalScope;
     this._allScopes = []; // Track all scopes for unused variable checking
     this._functionReturnTypeStack = []; // Stack of expected return types for type checking
     this._asyncDepth = 0; // Track nesting inside async functions for await validation
 
+    // Type registry for LSP
+    this.typeRegistry = {
+      types: new Map(),   // type name → ADTType | RecordType
+      impls: new Map(),   // type name → [{ name, params, returnType }]
+      traits: new Map(),  // trait name → [{ name, paramTypes, returnType }]
+    };
+
     // Register built-in types
     this.registerBuiltins();
   }
@@ -43,6 +84,47 @@ export class Analyzer {
       'snake_case', 'camel_case',
       // Math extras
       'min', 'max',
+      // Table operations
+      'Table', 'table_where', 'table_select', 'table_derive',
+      'table_group_by', 'table_agg', 'table_sort_by', 'table_limit',
+      'table_join', 'table_pivot', 'table_unpivot', 'table_explode',
+      'table_union', 'table_drop_duplicates', 'table_rename',
+      // Table aggregation helpers
+      'agg_sum', 'agg_count', 'agg_mean', 'agg_median', 'agg_min', 'agg_max',
+      // Data exploration
+      'peek', 'describe', 'schema_of',
+      // Data cleaning
+      'cast', 'drop_nil', 'fill_nil', 'filter_ok', 'filter_err',
+      // I/O
+      'read', 'write', 'stream',
+      // CSV/JSONL helpers
+      '__parseCSV', '__parseJSONL',
+      // Table operation aliases (short names)
+      'where', 'select', 'derive', 'agg', 'sort_by', 'limit',
+      'pivot', 'unpivot', 'explode', 'union', 'drop_duplicates', 'rename',
+      'mean', 'median',
+      // Strings (new)
+      'index_of', 'last_index_of', 'count_of', 'reverse_str', 'substr',
+      'is_empty', 'kebab_case', 'center',
+      // Collections (new)
+      'zip_with', 'frequencies', 'scan', 'min_by', 'max_by', 'sum_by',
+      'product', 'from_entries', 'has_key', 'get', 'pick', 'omit',
+      'map_values', 'sliding_window',
+      // JSON
+      'json_parse', 'json_stringify', 'json_pretty',
+      // Functional
+      'compose', 'pipe_fn', 'identity', 'memoize', 'debounce', 'throttle',
+      'once', 'negate',
+      // Error handling
+      'try_fn', 'try_async',
+      // Async
+      'parallel', 'timeout', 'retry',
+      // Encoding
+      'base64_encode', 'base64_decode', 'url_encode', 'url_decode',
+      // Math (new)
+      'hypot', 'lerp', 'divmod', 'avg',
+      // Date/Time
+      'now', 'now_iso',
     ];
     for (const name of builtins) {
       this.globalScope.define(name, new Symbol(name, 'builtin', null, false, { line: 0, column: 0, file: '<builtin>' }));
@@ -69,6 +151,14 @@ export class Analyzer {
     });
   }
 
+  strictError(message, loc) {
+    if (this.strict) {
+      this.error(message, loc);
+    } else {
+      this.warn(message, loc);
+    }
+  }
+
   analyze() {
     // Pre-pass: collect named server block functions for inter-server RPC validation
     this.serverBlockFunctions = new Map(); // blockName -> [functionName, ...]
@@ -102,7 +192,7 @@ export class Analyzer {
 
     if (this.errors.length > 0) {
       if (this.tolerant) {
-        return { warnings: this.warnings, errors: this.errors, scope: this.globalScope };
+        return { warnings: this.warnings, errors: this.errors, scope: this.globalScope, typeRegistry: this.typeRegistry };
       }
       const msgs = this.errors.map(e => `  ${e.file}:${e.line}:${e.column} — ${e.message}`);
       const err = new Error(`Analysis errors:\n${msgs.join('\n')}`);
@@ -111,7 +201,7 @@ export class Analyzer {
       throw err;
     }
 
-    return { warnings: this.warnings, scope: this.globalScope };
+    return { warnings: this.warnings, scope: this.globalScope, typeRegistry: this.typeRegistry };
   }
 
   _checkUnusedSymbols() {
@@ -377,6 +467,13 @@ export class Analyzer {
       case 'CacheDeclaration': return this.visitCacheDeclaration(node);
       case 'SseDeclaration': return this.visitSseDeclaration(node);
       case 'ModelDeclaration': return this.visitModelDeclaration(node);
+      case 'AiConfigDeclaration': return; // handled at block level
+      case 'DataBlock': return this.visitDataBlock(node);
+      case 'SourceDeclaration': return;
+      case 'PipelineDeclaration': return;
+      case 'ValidateBlock': return;
+      case 'RefreshPolicy': return;
+      case 'RefinementType': return;
       case 'TestBlock': return this.visitTestBlock(node);
       case 'ComponentStyleBlock': return; // raw CSS — no analysis needed
       case 'ImplDeclaration': return this.visitImplDeclaration(node);
@@ -517,6 +614,14 @@ export class Analyzer {
         return;
       case 'JSXElement':
         return this.visitJSXElement(node);
+      // Column expressions (for table operations) — no semantic analysis needed
+      case 'ColumnExpression':
+        return;
+      case 'ColumnAssignment':
+        this.visitExpression(node.expression);
+        return;
+      case 'NegatedColumnExpression':
+        return;
     }
   }
 
@@ -543,6 +648,19 @@ export class Analyzer {
         }
       }
 
+      // Register AI provider names as variables (named: claude, gpt, etc.; default: ai)
+      for (const stmt of node.body) {
+        if (stmt.type === 'AiConfigDeclaration') {
+          const aiName = stmt.name || 'ai';
+          try {
+            this.currentScope.define(aiName,
+              new Symbol(aiName, 'builtin', null, false, stmt.loc));
+          } catch (e) {
+            // Ignore if already defined
+          }
+        }
+      }
+
       for (const stmt of node.body) {
         this.visitNode(stmt);
       }
@@ -552,6 +670,25 @@ export class Analyzer {
     }
   }
 
+  visitDataBlock(node) {
+    // Register source and pipeline names in global scope
+    for (const stmt of node.body) {
+      if (stmt.type === 'SourceDeclaration') {
+        try {
+          this.currentScope.define(stmt.name,
+            new Symbol(stmt.name, 'variable', null, false, stmt.loc));
+        } catch (e) { /* already defined */ }
+        if (stmt.expression) this.visitExpression(stmt.expression);
+      } else if (stmt.type === 'PipelineDeclaration') {
+        try {
+          this.currentScope.define(stmt.name,
+            new Symbol(stmt.name, 'variable', null, false, stmt.loc));
+        } catch (e) { /* already defined */ }
+        if (stmt.expression) this.visitExpression(stmt.expression);
+      }
+    }
+  }
+
   visitClientBlock(node) {
     const prevScope = this.currentScope;
     this.currentScope = this.currentScope.child('client');
@@ -596,7 +733,11 @@ export class Analyzer {
         if (existing.inferredType && i < node.values.length) {
           const newType = this._inferType(node.values[i]);
           if (!this._typesCompatible(existing.inferredType, newType)) {
-            this.warn(`Type mismatch: '${target}' is ${existing.inferredType}, but assigned ${newType}`, node.loc);
+            this.strictError(`Type mismatch: '${target}' is ${existing.inferredType}, but assigned ${newType}`, node.loc);
+          }
+          // Float narrowing warning in strict mode
+          if (this.strict && newType === 'Float' && existing.inferredType === 'Int') {
+            this.warn(`Potential data loss: assigning Float to Int variable '${target}'`, node.loc);
           }
         }
         existing.used = true;
@@ -676,6 +817,9 @@ export class Analyzer {
 
     const prevScope = this.currentScope;
     this.currentScope = this.currentScope.child('function');
+    if (node.loc) {
+      this.currentScope.startLoc = { line: node.loc.line, column: node.loc.column };
+    }
 
     // Push expected return type for return-statement checking
     const expectedReturn = node.returnType ? this._typeAnnotationToString(node.returnType) : null;
@@ -761,10 +905,28 @@ export class Analyzer {
   }
 
   visitTypeDeclaration(node) {
+    // Build ADT type structure
+    const variants = new Map();
+    for (const variant of node.variants) {
+      if (variant.type === 'TypeVariant') {
+        const fields = new Map();
+        for (const f of variant.fields) {
+          const fieldType = f.typeAnnotation ? typeAnnotationToType(f.typeAnnotation) : Type.ANY;
+          fields.set(f.name, fieldType || Type.ANY);
+        }
+        variants.set(variant.name, fields);
+      }
+    }
+    const adtType = new ADTType(node.name, node.typeParams || [], variants);
+
     try {
       const typeSym = new Symbol(node.name, 'type', null, false, node.loc);
       typeSym._typeParams = node.typeParams || [];
+      typeSym._typeStructure = adtType;
       this.currentScope.define(node.name, typeSym);
+
+      // Register in type registry for LSP
+      this.typeRegistry.types.set(node.name, adtType);
     } catch (e) {
       this.error(e.message);
     }
@@ -821,11 +983,17 @@ export class Analyzer {
   visitBlock(node) {
     const prevScope = this.currentScope;
     this.currentScope = this.currentScope.child('block');
+    if (node.loc) {
+      this.currentScope.startLoc = { line: node.loc.line, column: node.loc.column };
+    }
     try {
       for (const stmt of node.body) {
         this.visitNode(stmt);
       }
     } finally {
+      if (node.loc) {
+        this.currentScope.endLoc = { line: node.endLoc?.line || node.loc.line + 100, column: node.endLoc?.column || 0 };
+      }
       this.currentScope = prevScope;
     }
   }
@@ -949,23 +1117,23 @@ export class Analyzer {
         const numerics = new Set(['Int', 'Float']);
         if (['-=', '*=', '/='].includes(op)) {
           if (!numerics.has(sym.inferredType) && sym.inferredType !== 'Any') {
-            this.warn(`Type mismatch: '${op}' requires numeric type, but '${node.target.name}' is ${sym.inferredType}`, node.loc);
+            this.strictError(`Type mismatch: '${op}' requires numeric type, but '${node.target.name}' is ${sym.inferredType}`, node.loc);
           }
           const valType = this._inferType(node.value);
           if (valType && !numerics.has(valType) && valType !== 'Any') {
-            this.warn(`Type mismatch: '${op}' requires numeric value, but got ${valType}`, node.loc);
+            this.strictError(`Type mismatch: '${op}' requires numeric value, but got ${valType}`, node.loc);
           }
         } else if (op === '+=') {
           // += on numerics requires numeric value, on strings requires string
           if (numerics.has(sym.inferredType)) {
             const valType = this._inferType(node.value);
             if (valType && !numerics.has(valType) && valType !== 'Any') {
-              this.warn(`Type mismatch: '${op}' on numeric variable requires numeric value, but got ${valType}`, node.loc);
+              this.strictError(`Type mismatch: '${op}' on numeric variable requires numeric value, but got ${valType}`, node.loc);
             }
           } else if (sym.inferredType === 'String') {
             const valType = this._inferType(node.value);
             if (valType && valType !== 'String' && valType !== 'Any') {
-              this.warn(`Type mismatch: '${op}' on String variable requires String value, but got ${valType}`, node.loc);
+              this.strictError(`Type mismatch: '${op}' on String variable requires String value, but got ${valType}`, node.loc);
             }
           }
         }
@@ -1447,44 +1615,14 @@ export class Analyzer {
   }
 
   _isKnownGlobal(name) {
-    const jsGlobals = new Set([
-      // JS built-ins
-      'console', 'document', 'window', 'globalThis', 'self',
-      'JSON', 'Math', 'Date', 'RegExp', 'Error', 'TypeError', 'RangeError',
-      'Promise', 'Set', 'Map', 'WeakSet', 'WeakMap', 'Symbol',
-      'Array', 'Object', 'String', 'Number', 'Boolean', 'Function',
-      'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'NaN', 'Infinity',
-      'undefined', 'null', 'true', 'false',
-      'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
-      'queueMicrotask', 'structuredClone',
-      'URL', 'URLSearchParams', 'Headers', 'Request', 'Response',
-      'FormData', 'Blob', 'File', 'FileReader',
-      'AbortController', 'AbortSignal',
-      'TextEncoder', 'TextDecoder',
-      'crypto', 'performance', 'navigator', 'location', 'history',
-      'localStorage', 'sessionStorage',
-      'fetch', 'alert', 'confirm', 'prompt',
-      'Bun', 'Deno', 'process', 'require', 'module', 'exports', '__dirname', '__filename',
-      'Buffer', 'atob', 'btoa',
-      // Tova runtime
-      'print', 'range', 'len', 'type_of', 'enumerate', 'zip',
-      'map', 'filter', 'reduce', 'sum', 'sorted', 'reversed',
-      'Ok', 'Err', 'Some', 'None', 'Result', 'Option',
-      'db', 'server', 'client', 'shared',
-      // Tova stdlib — collections
-      'find', 'any', 'all', 'flat_map', 'unique', 'group_by',
-      'chunk', 'flatten', 'take', 'drop', 'first', 'last',
-      'count', 'partition',
-      // Tova stdlib — math
-      'abs', 'floor', 'ceil', 'round', 'clamp', 'sqrt', 'pow', 'random',
-      // Tova stdlib — strings
-      'trim', 'split', 'join', 'replace', 'repeat',
-      // Tova stdlib — utility
-      'keys', 'values', 'entries', 'merge', 'freeze', 'clone',
-      // Tova stdlib — async
-      'sleep',
-    ]);
-    return jsGlobals.has(name);
+    // Tova stdlib (auto-synced from BUILTIN_FUNCTIONS in inline.js)
+    if (BUILTIN_NAMES.has(name)) return true;
+
+    // Tova runtime names
+    if (_TOVA_RUNTIME.has(name)) return true;
+
+    // JS globals / platform APIs
+    return _JS_GLOBALS.has(name);
   }
 
   visitLambda(node) {
@@ -1554,7 +1692,29 @@ export class Analyzer {
     );
     if (hasWildcard) return; // Catch-all exists, always exhaustive
 
-    // If subject is an identifier, try to find its type for variant checking
+    // Try to resolve the subject type for better checking
+    let subjectType = null;
+    if (node.subject) {
+      const subjectTypeStr = this._inferType(node.subject);
+      if (subjectTypeStr) {
+        // Look up type structure from type registry
+        const typeStructure = this.typeRegistry.types.get(subjectTypeStr);
+        if (typeStructure instanceof ADTType) {
+          subjectType = typeStructure;
+        }
+      }
+      // Also try to find type from identifier
+      if (!subjectType && node.subject.type === 'Identifier') {
+        const sym = this.currentScope.lookup(node.subject.name);
+        if (sym && sym.inferredType) {
+          const typeStructure = this.typeRegistry.types.get(sym.inferredType);
+          if (typeStructure instanceof ADTType) {
+            subjectType = typeStructure;
+          }
+        }
+      }
+    }
+
     const variantNames = new Set();
     const coveredVariants = new Set();
 
@@ -1567,6 +1727,17 @@ export class Analyzer {
 
     // If we have variant patterns, check if all known variants are covered
     if (coveredVariants.size > 0) {
+      // If we have the ADT type structure, use it for precise checking
+      if (subjectType) {
+        const allVariants = subjectType.getVariantNames();
+        for (const v of allVariants) {
+          if (!coveredVariants.has(v)) {
+            this.warn(`Non-exhaustive match: missing '${v}' variant from type '${subjectType.name}'`, node.loc);
+          }
+        }
+        return; // Done — used precise ADT checking
+      }
+
       // Check built-in Result/Option types
       if (coveredVariants.has('Ok') || coveredVariants.has('Err')) {
         if (!coveredVariants.has('Ok')) {
@@ -1829,9 +2000,9 @@ export class Analyzer {
     const name = node.callee.name;
 
     if (actualCount > fnSym._totalParamCount) {
-      this.warn(`'${name}' expects ${fnSym._totalParamCount} argument${fnSym._totalParamCount !== 1 ? 's' : ''}, but got ${actualCount}`, node.loc);
+      this.strictError(`'${name}' expects ${fnSym._totalParamCount} argument${fnSym._totalParamCount !== 1 ? 's' : ''}, but got ${actualCount}`, node.loc);
     } else if (actualCount < fnSym._requiredParamCount) {
-      this.warn(`'${name}' expects at least ${fnSym._requiredParamCount} argument${fnSym._requiredParamCount !== 1 ? 's' : ''}, but got ${actualCount}`, node.loc);
+      this.strictError(`'${name}' expects at least ${fnSym._requiredParamCount} argument${fnSym._requiredParamCount !== 1 ? 's' : ''}, but got ${actualCount}`, node.loc);
     }
   }
 
@@ -1865,28 +2036,28 @@ export class Analyzer {
     if (op === '++') {
       // String concatenation: both sides should be String
       if (leftType && leftType !== 'String' && leftType !== 'Any') {
-        this.warn(`Type mismatch: '++' expects String on left side, but got ${leftType}`, node.loc);
+        this.strictError(`Type mismatch: '++' expects String on left side, but got ${leftType}`, node.loc);
       }
       if (rightType && rightType !== 'String' && rightType !== 'Any') {
-        this.warn(`Type mismatch: '++' expects String on right side, but got ${rightType}`, node.loc);
+        this.strictError(`Type mismatch: '++' expects String on right side, but got ${rightType}`, node.loc);
       }
     } else if (['-', '*', '/', '%', '**'].includes(op)) {
       // Arithmetic: both sides must be numeric
       const numerics = new Set(['Int', 'Float']);
       if (leftType && !numerics.has(leftType) && leftType !== 'Any') {
-        this.warn(`Type mismatch: '${op}' expects numeric type, but got ${leftType}`, node.loc);
+        this.strictError(`Type mismatch: '${op}' expects numeric type, but got ${leftType}`, node.loc);
       }
       if (rightType && !numerics.has(rightType) && rightType !== 'Any') {
-        this.warn(`Type mismatch: '${op}' expects numeric type, but got ${rightType}`, node.loc);
+        this.strictError(`Type mismatch: '${op}' expects numeric type, but got ${rightType}`, node.loc);
       }
     } else if (op === '+') {
       // Addition: both sides must be numeric (Tova uses ++ for strings)
       const numerics = new Set(['Int', 'Float']);
       if (leftType && !numerics.has(leftType) && leftType !== 'Any') {
-        this.warn(`Type mismatch: '+' expects numeric type, but got ${leftType}`, node.loc);
+        this.strictError(`Type mismatch: '+' expects numeric type, but got ${leftType}`, node.loc);
       }
       if (rightType && !numerics.has(rightType) && rightType !== 'Any') {
-        this.warn(`Type mismatch: '+' expects numeric type, but got ${rightType}`, node.loc);
+        this.strictError(`Type mismatch: '+' expects numeric type, but got ${rightType}`, node.loc);
       }
     }
   }
@@ -1957,14 +2128,72 @@ export class Analyzer {
 
   visitInterfaceDeclaration(node) {
     try {
-      this.currentScope.define(node.name,
-        new Symbol(node.name, 'type', null, false, node.loc));
+      const sym = new Symbol(node.name, 'type', null, false, node.loc);
+      // Store method signatures for conformance checking
+      sym._interfaceMethods = (node.methods || []).map(m => ({
+        name: m.name,
+        paramTypes: (m.params || []).map(p => typeAnnotationToType(p.typeAnnotation)),
+        returnType: typeAnnotationToType(m.returnType),
+        paramCount: (m.params || []).length,
+      }));
+      this.currentScope.define(node.name, sym);
+
+      // Register in type registry for LSP
+      this.typeRegistry.traits.set(node.name, sym._interfaceMethods);
     } catch (e) {
       this.error(e.message);
     }
   }
 
   visitImplDeclaration(node) {
+    // Collect provided method names for conformance checking
+    const providedMethods = new Map();
+    for (const method of node.methods) {
+      providedMethods.set(method.name, {
+        paramCount: (method.params || []).filter(p => p.name !== 'self').length,
+        returnType: method.returnType ? typeAnnotationToType(method.returnType) : null,
+      });
+    }
+
+    // Register impl methods in type registry for LSP
+    const typeName = node.typeName || node.target;
+    if (typeName) {
+      const existingImpls = this.typeRegistry.impls.get(typeName) || [];
+      for (const method of node.methods) {
+        existingImpls.push({
+          name: method.name,
+          params: (method.params || []).map(p => p.name),
+          paramTypes: (method.params || []).map(p => typeAnnotationToType(p.typeAnnotation)),
+          returnType: typeAnnotationToType(method.returnType),
+        });
+      }
+      this.typeRegistry.impls.set(typeName, existingImpls);
+    }
+
+    // Trait/interface conformance checking
+    if (node.traitName) {
+      const traitSym = this.currentScope.lookup(node.traitName);
+      if (traitSym && traitSym._interfaceMethods) {
+        for (const required of traitSym._interfaceMethods) {
+          const provided = providedMethods.get(required.name);
+          if (!provided) {
+            this.warn(`Impl for '${typeName || 'type'}' missing required method '${required.name}' from trait '${node.traitName}'`, node.loc);
+          } else {
+            // Check parameter count matches (excluding self)
+            if (required.paramCount > 0 && provided.paramCount !== required.paramCount) {
+              this.warn(`Method '${required.name}' in impl for '${typeName}' has ${provided.paramCount} parameters, but trait '${node.traitName}' expects ${required.paramCount}`, node.loc);
+            }
+            // Check return type matches if both are annotated
+            if (required.returnType && provided.returnType) {
+              if (!provided.returnType.isAssignableTo(required.returnType)) {
+                this.warn(`Method '${required.name}' return type mismatch in impl for '${typeName}': expected ${required.returnType}, got ${provided.returnType}`, node.loc);
+              }
+            }
+          }
+        }
+      }
+    }
+
     // Validate that methods reference the type
     for (const method of node.methods) {
       this.pushScope('function');
@@ -1993,8 +2222,18 @@ export class Analyzer {
 
   visitTraitDeclaration(node) {
     try {
-      this.currentScope.define(node.name,
-        new Symbol(node.name, 'type', null, false, node.loc));
+      const sym = new Symbol(node.name, 'type', null, false, node.loc);
+      // Store method signatures for conformance checking
+      sym._interfaceMethods = (node.methods || []).map(m => ({
+        name: m.name,
+        paramTypes: (m.params || []).map(p => typeAnnotationToType(p.typeAnnotation)),
+        returnType: typeAnnotationToType(m.returnType),
+        paramCount: (m.params || []).filter(p => p.name !== 'self').length,
+      }));
+      this.currentScope.define(node.name, sym);
+
+      // Register in type registry for LSP
+      this.typeRegistry.traits.set(node.name, sym._interfaceMethods);
     } catch (e) {
       this.error(e.message);
     }

package/src/analyzer/scope.js

@@ -4,10 +4,11 @@ export class Symbol {
   constructor(name, kind, type, mutable, loc) {
     this.name = name;
     this.kind = kind;       // 'variable', 'function', 'type', 'parameter', 'state', 'computed', 'component'
-    this.type = type;       // type annotation (optional)
+    this.type = type;       // Type object or raw type annotation (optional)
     this.mutable = mutable; // true for 'var' declarations
     this.loc = loc;
     this.used = false;
+    this.declaredType = null; // raw annotation for display purposes
   }
 }
 
@@ -17,10 +18,18 @@ export class Scope {
     this.context = context; // 'module', 'server', 'client', 'shared', 'function', 'block'
     this.symbols = new Map();
     this.children = [];
+    this.startLoc = null; // { line, column } for positional scope lookup
+    this.endLoc = null;
   }
 
   define(name, symbol) {
     if (this.symbols.has(name)) {
+      const existing = this.symbols.get(name);
+      // Allow user code to shadow builtins
+      if (existing.kind === 'builtin') {
+        this.symbols.set(name, symbol);
+        return;
+      }
       throw new Error(
         `${symbol.loc.file}:${symbol.loc.line}:${symbol.loc.column} — '${name}' is already defined in this scope`
       );
@@ -57,4 +66,32 @@ export class Scope {
     this.children.push(c);
     return c;
   }
+
+  /**
+   * Find the narrowest scope containing a given position.
+   */
+  findScopeAtPosition(line, column) {
+    // Check children first (narrower scopes)
+    for (const child of this.children) {
+      if (child.startLoc && child.endLoc) {
+        if ((line > child.startLoc.line || (line === child.startLoc.line && column >= child.startLoc.column)) &&
+            (line < child.endLoc.line || (line === child.endLoc.line && column <= child.endLoc.column))) {
+          const nested = child.findScopeAtPosition(line, column);
+          return nested || child;
+        }
+      } else {
+        // No position info — recurse anyway
+        const nested = child.findScopeAtPosition(line, column);
+        if (nested) return nested;
+      }
+    }
+    // If this scope contains the position, return this
+    if (this.startLoc && this.endLoc) {
+      if ((line > this.startLoc.line || (line === this.startLoc.line && column >= this.startLoc.column)) &&
+          (line < this.endLoc.line || (line === this.endLoc.line && column <= this.endLoc.column))) {
+        return this;
+      }
+    }
+    return null;
+  }
 }