lt-script 1.0.1 → 1.0.3

package/dist/compiler/semantics/SemanticAnalyzer.js

@@ -0,0 +1,411 @@
+import * as AST from '../parser/AST.js';
+class Scope {
+    symbols = new Map();
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    define(name, kind, type, line) {
+        // In strict mode we might check for redeclaration here
+        this.symbols.set(name, { name, kind, type, definedAtLine: line });
+    }
+    lookup(name) {
+        let current = this;
+        while (current) {
+            if (current.symbols.has(name)) {
+                return current.symbols.get(name);
+            }
+            current = current.parent;
+        }
+        return undefined;
+    }
+}
+export class SemanticAnalyzer {
+    globalScope = new Scope();
+    currentScope = this.globalScope;
+    typeRegistry = new Map();
+    memberTypes = new Map(); // Tracks Table.Field -> type mapping
+    analyze(program) {
+        // Reset scope for fresh analysis (though typically instance is fresh)
+        this.currentScope = this.globalScope;
+        // Visit all statements
+        for (const stmt of program.body) {
+            this.visitStatement(stmt);
+        }
+    }
+    enterScope() {
+        this.currentScope = new Scope(this.currentScope);
+    }
+    exitScope() {
+        if (this.currentScope.parent) {
+            this.currentScope = this.currentScope.parent;
+        }
+    }
+    visitStatement(stmt) {
+        switch (stmt.kind) {
+            case AST.NodeType.VariableDecl:
+                this.visitVariableDecl(stmt);
+                break;
+            case AST.NodeType.TypeDecl:
+                this.visitTypeDecl(stmt);
+                break;
+            case AST.NodeType.AssignmentStmt:
+                this.visitAssignmentStmt(stmt);
+                break;
+            case AST.NodeType.CompoundAssignment:
+                this.visitCompoundAssignment(stmt);
+                break;
+            case AST.NodeType.FunctionDecl:
+                this.visitFunctionDecl(stmt);
+                break;
+            case AST.NodeType.Block:
+                this.visitBlock(stmt);
+                break;
+            case AST.NodeType.IfStmt:
+                {
+                    const s = stmt;
+                    this.visitExpression(s.condition);
+                    this.visitBlock(s.thenBody);
+                    s.elseIfClauses?.forEach(c => {
+                        this.visitExpression(c.condition);
+                        this.visitBlock(c.body);
+                    });
+                    if (s.elseBody)
+                        this.visitBlock(s.elseBody);
+                }
+                break;
+            case AST.NodeType.WhileStmt:
+                {
+                    const s = stmt;
+                    this.visitExpression(s.condition);
+                    this.visitBlock(s.body);
+                }
+                break;
+            case AST.NodeType.ForStmt:
+                {
+                    const s = stmt;
+                    this.enterScope(); // For loop creates scope for iterators
+                    s.iterators.forEach(i => this.currentScope.define(i.name, 'let', 'any', s.line || 0)); // Iterators can be anything in generic for
+                    this.visitExpression(s.iterable);
+                    // We can treat the body as part of this scope or nested. 
+                    // AST.Block usually suggests its own scope, but let's reuse this one or just visit statements.
+                    // Since AST.Block logic below creates a NEW scope, we have: Scope(Iterators) -> Scope(Body). This is correct.
+                    this.visitBlock(s.body);
+                    this.exitScope();
+                }
+                break;
+            case AST.NodeType.RangeForStmt:
+                {
+                    const s = stmt;
+                    this.enterScope();
+                    this.currentScope.define(s.counter.name, 'let', 'number', s.line || 0); // Range for is always number
+                    this.visitExpression(s.start);
+                    this.visitExpression(s.end);
+                    if (s.step)
+                        this.visitExpression(s.step);
+                    this.visitBlock(s.body);
+                    this.exitScope();
+                }
+                break;
+            // ... Handle other control flows that have blocks ...
+            case AST.NodeType.CommandStmt:
+                {
+                    const s = stmt;
+                    this.enterScope();
+                    s.params.forEach(p => this.currentScope.define(p.name.name, 'param', 'string', s.line || 0)); // Command params are strings (usually)
+                    this.visitBlock(s.body);
+                    this.exitScope();
+                }
+                break;
+            // Basic fallback recursive visiting
+            default:
+                // Identify other nodes that contain blocks/expressions to visit
+                this.visitChildren(stmt);
+        }
+    }
+    visitChildren(node) {
+        if (!node || typeof node !== 'object')
+            return;
+        for (const key in node) {
+            if (key === 'kind')
+                continue;
+            const val = node[key];
+            if (Array.isArray(val)) {
+                val.forEach(v => {
+                    if (v && typeof v === 'object' && 'kind' in v) {
+                        if (v.kind.endsWith('Stmt') || v.kind === 'VariableDecl' || v.kind === 'Block') {
+                            this.visitStatement(v);
+                        }
+                        else {
+                            this.visitExpression(v);
+                        }
+                    }
+                });
+            }
+            else if (val && typeof val === 'object' && 'kind' in val) {
+                if (val.kind.endsWith('Stmt') || val.kind === 'VariableDecl' || val.kind === 'Block') {
+                    this.visitStatement(val);
+                }
+                else {
+                    this.visitExpression(val);
+                }
+            }
+        }
+    }
+    visitVariableDecl(decl) {
+        // Visit values first
+        if (decl.values) {
+            decl.values.forEach(v => this.visitExpression(v));
+        }
+        const kind = decl.scope === 'const' ? 'const' : 'let';
+        decl.names.forEach((n, index) => {
+            let type = 'any';
+            let customTypeName;
+            // 1. Try to get type from annotation
+            if (decl.typeAnnotations && decl.typeAnnotations[index]) {
+                const annotation = decl.typeAnnotations[index];
+                customTypeName = this.typeRegistry.has(annotation) ? annotation : undefined;
+                type = this.stringToType(annotation);
+            }
+            // 2. Try to infer from value if available
+            if (decl.values && decl.values[index]) {
+                const value = decl.values[index];
+                const inferred = this.inferType(value);
+                // If we have a custom type annotation and the value is a table, validate it
+                if (customTypeName && value.kind === AST.NodeType.TableLiteral) {
+                    this.validateTableAgainstType(value, customTypeName, decl.line || 0);
+                }
+                // If we have an annotation, check compatibility
+                if (type !== 'any' && inferred !== 'any' && type !== inferred) {
+                    throw new Error(`Type mismatch at line ${decl.line}: Expected '${type}', but got '${inferred}'`);
+                }
+                // If no annotation, keep type as 'any' (default)
+                // if (type === 'any' && (!decl.typeAnnotations || !decl.typeAnnotations[index])) {
+                //     type = inferred;
+                // }
+            }
+            if (n.kind === AST.NodeType.Identifier) {
+                this.currentScope.define(n.name, kind, type, decl.line || 0);
+            }
+            else if (n.kind === AST.NodeType.ObjectDestructure) {
+                n.properties.forEach(p => {
+                    this.currentScope.define(p.name, kind, 'any', decl.line || 0);
+                });
+            }
+            else if (n.kind === AST.NodeType.ArrayDestructure) {
+                n.elements.forEach(el => {
+                    this.currentScope.define(el.name, kind, 'any', decl.line || 0);
+                });
+            }
+        });
+    }
+    visitAssignmentStmt(stmt) {
+        // Check RHS
+        stmt.values.forEach(v => this.visitExpression(v));
+        // Check LHS
+        stmt.targets.forEach((t, index) => {
+            // If it's a simple identifier, check const and TYPE
+            if (t.kind === AST.NodeType.Identifier) {
+                const name = t.name;
+                const sym = this.currentScope.lookup(name);
+                if (sym) {
+                    if (sym.kind === 'const') {
+                        throw new Error(`Assignment to constant variable '${name}' at line ${stmt.line}`);
+                    }
+                    // Type Checking
+                    if (stmt.values[index]) {
+                        const valueType = this.inferType(stmt.values[index]);
+                        if (sym.type !== 'any' && valueType !== 'any' && sym.type !== valueType) {
+                            throw new Error(`Type mismatch at line ${stmt.line}: Variable '${name}' is type '${sym.type}', but assigned '${valueType}'`);
+                        }
+                    }
+                }
+            }
+            // Handle member expression type checking (Config.Field: type = value)
+            if (t.kind === AST.NodeType.MemberExpr) {
+                const memberKey = this.getMemberExprKey(t);
+                // If this assignment has a type annotation, register it
+                if (stmt.typeAnnotation && index === 0) {
+                    const type = this.stringToType(stmt.typeAnnotation);
+                    this.memberTypes.set(memberKey, type);
+                    // Also check that the value matches the declared type
+                    if (stmt.values[index]) {
+                        const valueType = this.inferType(stmt.values[index]);
+                        if (type !== 'any' && valueType !== 'any' && type !== valueType) {
+                            throw new Error(`Type mismatch at line ${stmt.line}: '${memberKey}' is declared as '${stmt.typeAnnotation}', but assigned '${valueType}'`);
+                        }
+                    }
+                }
+                else {
+                    // Check if this member has a registered type
+                    const registeredType = this.memberTypes.get(memberKey);
+                    if (registeredType && stmt.values[index]) {
+                        const valueType = this.inferType(stmt.values[index]);
+                        if (registeredType !== 'any' && valueType !== 'any' && registeredType !== valueType) {
+                            throw new Error(`Type mismatch at line ${stmt.line}: '${memberKey}' is type '${registeredType}', but assigned '${valueType}'`);
+                        }
+                    }
+                }
+            }
+            this.visitExpression(t);
+        });
+    }
+    // Helper to get a string key for a member expression (e.g., "Config.Locale")
+    getMemberExprKey(expr) {
+        let parts = [];
+        let current = expr;
+        while (current.kind === AST.NodeType.MemberExpr) {
+            const memberExpr = current;
+            if (memberExpr.property.kind === AST.NodeType.Identifier) {
+                parts.unshift(memberExpr.property.name);
+            }
+            current = memberExpr.object;
+        }
+        if (current.kind === AST.NodeType.Identifier) {
+            parts.unshift(current.name);
+        }
+        return parts.join('.');
+    }
+    visitCompoundAssignment(stmt) {
+        this.visitExpression(stmt.value);
+        if (stmt.target.kind === AST.NodeType.Identifier) {
+            const name = stmt.target.name;
+            const sym = this.currentScope.lookup(name);
+            if (sym && sym.kind === 'const') {
+                throw new Error(`Assignment to constant variable '${name}' at line ${stmt.line}`);
+            }
+        }
+        this.visitExpression(stmt.target);
+    }
+    visitFunctionDecl(decl) {
+        // Name is defined in CURRENT scope
+        if (decl.name && decl.name.kind === AST.NodeType.Identifier) {
+            this.currentScope.define(decl.name.name, 'const', 'function', decl.line || 0);
+        }
+        this.enterScope();
+        decl.params.forEach(p => {
+            // Parse param type annotation
+            let type = 'any';
+            if (p.typeAnnotation) {
+                type = this.stringToType(p.typeAnnotation);
+            }
+            this.currentScope.define(p.name.name, 'param', type, decl.line || 0);
+            if (p.defaultValue) {
+                const defType = this.inferType(p.defaultValue);
+                if (type !== 'any' && defType !== 'any' && type !== defType) {
+                    throw new Error(`Type mismatch in parameter default value at line ${decl.line}`);
+                }
+                this.visitExpression(p.defaultValue);
+            }
+        });
+        this.visitBlock(decl.body);
+        this.exitScope();
+    }
+    visitBlock(block) {
+        this.enterScope();
+        block.statements.forEach(s => this.visitStatement(s));
+        this.exitScope();
+    }
+    visitExpression(expr) {
+        // Mostly just traversing to find nested scopes in functions/arrows
+        if (!expr)
+            return;
+        if (expr.kind === AST.NodeType.ArrowFunc) {
+            const arrow = expr;
+            this.enterScope();
+            arrow.params.forEach(p => {
+                let type = 'any';
+                if (p.typeAnnotation) {
+                    type = this.stringToType(p.typeAnnotation);
+                }
+                this.currentScope.define(p.name.name, 'param', type, expr.line || 0);
+                if (p.defaultValue)
+                    this.visitExpression(p.defaultValue);
+            });
+            if ('kind' in arrow.body && arrow.body.kind === AST.NodeType.Block) {
+                this.visitBlock(arrow.body);
+            }
+            else {
+                this.visitExpression(arrow.body);
+            }
+            this.exitScope();
+            return;
+        }
+        if (expr.kind === AST.NodeType.FunctionDecl) {
+            this.visitFunctionDecl(expr);
+            return;
+        }
+        // Recurse
+        this.visitChildren(expr);
+    }
+    inferType(expr) {
+        if (!expr)
+            return 'any';
+        switch (expr.kind) {
+            case AST.NodeType.NumberLiteral: return 'number';
+            case AST.NodeType.StringLiteral: return 'string';
+            case AST.NodeType.InterpolatedString: return 'string';
+            case AST.NodeType.BooleanLiteral: return 'boolean';
+            case AST.NodeType.NilLiteral: return 'nil';
+            case AST.NodeType.VectorLiteral: return 'vector';
+            case AST.NodeType.TableLiteral: return 'table';
+            case AST.NodeType.FunctionDecl: return 'function';
+            case AST.NodeType.ArrowFunc: return 'function';
+            case AST.NodeType.Identifier:
+                const sym = this.currentScope.lookup(expr.name);
+                return sym ? sym.type : 'any';
+            // TODO: Improve binary expr inference (e.g. number + number = number)
+            case AST.NodeType.BinaryExpr: return 'any';
+            default:
+                return 'any';
+        }
+    }
+    stringToType(str) {
+        switch (str) {
+            case 'string': return 'string';
+            case 'number': return 'number';
+            case 'boolean': return 'boolean';
+            case 'vector': return 'vector';
+            case 'table': return 'table';
+            case 'function': return 'function';
+            case 'any': return 'any';
+            default:
+                // Check if it's a custom type
+                if (this.typeRegistry.has(str)) {
+                    return 'table'; // Custom types are tables internally
+                }
+                return 'any';
+        }
+    }
+    visitTypeDecl(decl) {
+        const typeName = decl.name.name;
+        // Register the type
+        this.typeRegistry.set(typeName, decl.fields);
+    }
+    validateTableAgainstType(table, typeName, line) {
+        const fields = this.typeRegistry.get(typeName);
+        if (!fields)
+            return; // Unknown type, skip validation
+        const providedFields = new Map();
+        for (const field of table.fields) {
+            if (field.key && field.key.kind === AST.NodeType.Identifier) {
+                providedFields.set(field.key.name, field.value);
+            }
+            else if (field.key && field.key.kind === AST.NodeType.StringLiteral) {
+                providedFields.set(field.key.value, field.value);
+            }
+        }
+        // Check each expected field
+        for (const expected of fields) {
+            const provided = providedFields.get(expected.name);
+            if (!provided) {
+                throw new Error(`Type '${typeName}' requires field '${expected.name}' at line ${line}`);
+            }
+            const providedType = this.inferType(provided);
+            const expectedType = this.stringToType(expected.type);
+            if (expectedType !== 'any' && providedType !== 'any' && expectedType !== providedType) {
+                throw new Error(`Type mismatch: field '${expected.name}' should be '${expected.type}', got '${providedType}' at line ${line}`);
+            }
+        }
+    }
+}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { Lexer } from './compiler/lexer/Lexer.js';
 import { Parser } from './compiler/parser/Parser.js';
 import { LuaEmitter } from './compiler/codegen/LuaEmitter.js';
+import { SemanticAnalyzer } from './compiler/semantics/SemanticAnalyzer.js';
 export declare function compile(source: string): string;
-export { Lexer, Parser, LuaEmitter };
+export { Lexer, Parser, LuaEmitter, SemanticAnalyzer };

package/dist/index.js

@@ -1,12 +1,20 @@
 import { Lexer } from './compiler/lexer/Lexer.js';
 import { Parser } from './compiler/parser/Parser.js';
 import { LuaEmitter } from './compiler/codegen/LuaEmitter.js';
+import { SemanticAnalyzer } from './compiler/semantics/SemanticAnalyzer.js';
 export function compile(source) {
     const lexer = new Lexer(source);
     const tokens = lexer.tokenize();
+    // DEBUG: Check first token to see if it has line info
+    // if (tokens.length > 0) {
+    //   console.log('[DEBUG] First Token:', JSON.stringify(tokens[0]));
+    //   console.log('[DEBUG] Token count:', tokens.length);
+    // }
     const parser = new Parser(tokens);
     const ast = parser.parse();
+    const analyzer = new SemanticAnalyzer();
+    analyzer.analyze(ast);
     const emitter = new LuaEmitter();
     return emitter.emit(ast);
 }
-export { Lexer, Parser, LuaEmitter };
+export { Lexer, Parser, LuaEmitter, SemanticAnalyzer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lt-script",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "type": "module",
   "description": "LT Language Compiler for FiveM",
   "main": "dist/index.js",
@@ -18,16 +18,25 @@
     "laot",
     "lt"
   ],
-  "author": "https://github.com/laot7490",
+  "author": "laot",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/laot7490/lt-script.git"
+  },
   "license": "MIT",
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
     "test": "node dist/tests/run.js",
-    "prepublishOnly": "npm run build"
+    "build:lt": "npm run build",
+    "build:vscode": "cd vscode-extension && npx vsce package",
+    "watch:playground": "tsx src/cli/ltc.ts watch playground",
+    "watch:testing": "tsx src/cli/ltc.ts watch .testing",
+    "github:push": "node tools/push.js"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",
+    "tsx": "^4.21.0",
     "typescript": "^5.3.0"
   }
 }