lt-script 1.0.1 → 1.0.5

package/dist/compiler/parser/Parser.js

@@ -19,6 +19,18 @@ export class Parser {
     }
     // ============ Statement Parsing ============
     parseStatement() {
+        // Ambiguity Check: 'type' Identifier = ... VS type(x)
+        if (this.at().type === TokenType.IDENTIFIER && this.at().value === 'type') {
+            // Lookahead to see if it's a declaration
+            const next = this.tokens[this.pos + 1];
+            if (next && next.type === TokenType.IDENTIFIER) {
+                const nextNext = this.tokens[this.pos + 2];
+                if (nextNext && nextNext.type === TokenType.EQUALS) {
+                    this.eat(); // consume 'type' pseudo-keyword
+                    return this.parseTypeAlias();
+                }
+            }
+        }
         switch (this.at().type) {
             case TokenType.VAR:
             case TokenType.LET:
@@ -69,12 +81,73 @@ export class Parser {
                 return this.parseSwitchStmt();
             case TokenType.EXPORT:
                 return this.parseExportDecl();
-            case TokenType.COMMAND:
+            case TokenType.ADDCMD:
                 return this.parseCommandStmt();
+            case TokenType.INTERFACE:
+                return this.parseTypeDecl();
             default:
                 return this.parseExpressionStatement();
         }
     }
+    // ============ Type Parsing ============
+    parseType() {
+        // If we're parsing a type and hit a '{', it's an object type literal: value: { a: number }
+        if (this.at().type === TokenType.LBRACE) {
+            this.eat(); // {
+            let typeBody = "{ ";
+            while (!this.check(TokenType.RBRACE) && !this.isEOF()) {
+                const key = this.parseIdentifier().name;
+                let val = "any";
+                // Check for optional property
+                if (this.match(TokenType.QUESTION)) {
+                    key + "?";
+                }
+                if (this.match(TokenType.COLON)) {
+                    val = this.parseType();
+                }
+                typeBody += `${key}: ${val}`;
+                if (!this.check(TokenType.RBRACE)) {
+                    this.match(TokenType.COMMA) || this.match(TokenType.SEMICOLON);
+                    typeBody += ", ";
+                }
+            }
+            this.expect(TokenType.RBRACE);
+            typeBody += " }";
+            // Handle array of objects: { ... }[]
+            while (this.match(TokenType.LBRACKET)) {
+                this.expect(TokenType.RBRACKET);
+                typeBody += "[]";
+            }
+            return typeBody;
+        }
+        const typeToken = this.eat();
+        let typeName = typeToken.value;
+        // Handle generic types: List<string> (Basic support)
+        if (this.match(TokenType.LT_ANGLE)) { // <
+            typeName += "<";
+            typeName += this.parseType();
+            while (this.match(TokenType.COMMA)) {
+                typeName += ", ";
+                typeName += this.parseType();
+            }
+            this.expect(TokenType.GT_ANGLE); // >
+            typeName += ">";
+        }
+        // Handle array types: string[] or string[][]
+        while (this.match(TokenType.LBRACKET)) {
+            this.expect(TokenType.RBRACKET);
+            typeName += "[]";
+        }
+        return typeName;
+    }
+    parseTypeAlias() {
+        // 'type' is already consumed or handled by caller
+        const name = this.parseIdentifier();
+        this.expect(TokenType.EQUALS);
+        const typeStr = this.parseType();
+        return { kind: AST.NodeType.TypeAliasDecl, name, type: typeStr };
+    }
+    // ============ Statement Parsing ============
     parseVariableDecl() {
         const scopeToken = this.eat();
         const scope = scopeToken.value;
@@ -91,7 +164,7 @@ export class Parser {
                 return this.parseObjectDestructure();
             if (this.at().type === TokenType.LBRACKET)
                 return this.parseArrayDestructure();
-            const id = this.parseIdentifier();
+            const id = this.parseIdentifierName();
             // Lua 5.4 Attributes: <const>, <close>
             if (this.match(TokenType.LT)) {
                 // Consume the attribute name (usually 'const' or 'close')
@@ -103,12 +176,12 @@ export class Parser {
         };
         names.push(parseName());
         if (this.match(TokenType.COLON)) {
-            typeAnnotations[0] = this.eat().value;
+            typeAnnotations[0] = this.parseType();
         }
         while (this.match(TokenType.COMMA)) {
             names.push(parseName());
             if (this.match(TokenType.COLON)) {
-                typeAnnotations[names.length - 1] = this.eat().value;
+                typeAnnotations[names.length - 1] = this.parseType();
             }
         }
         let values;
@@ -119,7 +192,7 @@ export class Parser {
                 values.push(this.parseExpression(true));
             }
         }
-        return { kind: AST.NodeType.VariableDecl, scope, names, typeAnnotations, values };
+        return { kind: AST.NodeType.VariableDecl, scope, names, typeAnnotations, values, line: scopeToken.line, column: scopeToken.column };
     }
     parseIfStmt() {
         this.eat(); // if
@@ -224,6 +297,7 @@ export class Parser {
         this.eat(); // guard
         const condition = this.parseExpression();
         let elseBody;
+        let returnValue;
         if (this.match(TokenType.ELSE)) {
             elseBody = [];
             while (!this.check(TokenType.RETURN) && !this.isEOF()) {
@@ -233,9 +307,29 @@ export class Parser {
             this.match(TokenType.END); // Consume optional END
         }
         else {
-            this.expect(TokenType.RETURN);
+            const returnToken = this.expect(TokenType.RETURN);
+            const nextToken = this.at();
+            // Check if there's a return value on the same line
+            if (nextToken.line === returnToken.line && !this.isStatementEnd()) {
+                // Check if this is a simple expression (nil, number, string, identifier, etc.)
+                // rather than a statement that starts with these tokens
+                if (this.check(TokenType.NIL) ||
+                    this.check(TokenType.NUMBER) ||
+                    this.check(TokenType.STRING) ||
+                    this.check(TokenType.BOOLEAN) ||
+                    this.check(TokenType.IDENTIFIER) ||
+                    this.check(TokenType.LBRACE) ||
+                    this.check(TokenType.LBRACKET)) {
+                    // Try to parse as expression first for simple return values
+                    returnValue = this.parseExpression();
+                }
+                else {
+                    // For function calls like print("Fail"), parse as statement
+                    elseBody = [this.parseStatement()];
+                }
+            }
         }
-        return { kind: AST.NodeType.GuardStmt, condition, elseBody };
+        return { kind: AST.NodeType.GuardStmt, condition, elseBody, returnValue };
     }
     parseSafeCall() {
         this.eat(); // safe
@@ -353,7 +447,7 @@ export class Parser {
         this.expect(TokenType.RPAREN);
         let returnType;
         if (this.match(TokenType.COLON)) {
-            returnType = this.eat().value;
+            returnType = this.parseType();
         }
         const body = this.parseBlockUntil(TokenType.END);
         this.expect(TokenType.END);
@@ -376,7 +470,7 @@ export class Parser {
         this.expect(TokenType.RPAREN);
         let returnType;
         if (this.match(TokenType.COLON)) {
-            returnType = this.eat().value;
+            returnType = this.parseType();
         }
         const body = this.parseBlockUntil(TokenType.END);
         this.expect(TokenType.END);
@@ -405,7 +499,7 @@ export class Parser {
         return { kind: AST.NodeType.SwitchStmt, discriminant, cases, defaultCase };
     }
     parseCommandStmt() {
-        this.eat(); // command
+        this.eat(); // addcmd
         let nameVal;
         if (this.at().type === TokenType.STRING) {
             nameVal = this.eat().value;
@@ -434,32 +528,78 @@ export class Parser {
         }
         throw new Error(`Expected function declaration after export at ${this.at().line}:${this.at().column}`);
     }
+    parseTypeDecl() {
+        this.eat(); // interface
+        const name = this.parseIdentifier();
+        this.expect(TokenType.LBRACE);
+        const fields = [];
+        while (!this.check(TokenType.RBRACE) && !this.isEOF()) {
+            const fieldName = this.parseIdentifier().name;
+            this.expect(TokenType.COLON);
+            const fieldType = this.parseType(); // Get the type as string
+            fields.push({ name: fieldName, type: fieldType });
+            // Allow trailing comma
+            if (!this.check(TokenType.RBRACE)) {
+                this.match(TokenType.COMMA);
+            }
+        }
+        this.expect(TokenType.RBRACE);
+        return { kind: AST.NodeType.TypeDecl, name, fields };
+    }
     parseExpressionStatement() {
-        const expr = this.parseExpression();
+        // Parse expression but don't allow colon for type annotation detection
+        let expr = this.parseExpression(false);
+        // Type annotation for table field assignment: Config.Field: type = value
+        // When we have an expression followed by COLON + IDENTIFIER + EQUALS
+        if (this.check(TokenType.COLON) && expr.kind === AST.NodeType.MemberExpr) {
+            const colonPos = this.pos;
+            this.eat(); // consume :
+            if (this.check(TokenType.IDENTIFIER)) {
+                const typeToken = this.eat(); // consume type
+                if (this.check(TokenType.EQUALS)) {
+                    // This is a typed assignment: Config.Field: type = value
+                    const typeAnnotation = typeToken.value;
+                    this.eat(); // consume =
+                    const value = this.parseExpression();
+                    return { kind: AST.NodeType.AssignmentStmt, targets: [expr], values: [value], typeAnnotation, line: expr.line, column: expr.column };
+                }
+                else {
+                    // Not a typed assignment, backtrack
+                    this.pos = colonPos;
+                }
+            }
+            else {
+                // Not a type annotation, backtrack
+                this.pos = colonPos;
+            }
+        }
+        // Continue parsing member expression (method calls were disabled in initial parse)
+        // This allows: Entity(vehicle).state:set(...)
+        expr = this.parseMemberSuffix(expr, true);
         // Compound assignment
         if (this.match(TokenType.PLUS_EQ)) {
             const value = this.parseExpression();
-            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "+=", value };
+            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "+=", value, line: expr.line, column: expr.column };
         }
         if (this.match(TokenType.MINUS_EQ)) {
             const value = this.parseExpression();
-            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "-=", value };
+            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "-=", value, line: expr.line, column: expr.column };
         }
         if (this.match(TokenType.STAR_EQ)) {
             const value = this.parseExpression();
-            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "*=", value };
+            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "*=", value, line: expr.line, column: expr.column };
         }
         if (this.match(TokenType.SLASH_EQ)) {
             const value = this.parseExpression();
-            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "/=", value };
+            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "/=", value, line: expr.line, column: expr.column };
         }
         if (this.match(TokenType.PERCENT_EQ)) {
             const value = this.parseExpression();
-            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "%=", value };
+            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "%=", value, line: expr.line, column: expr.column };
         }
         if (this.match(TokenType.CONCAT_EQ)) {
             const value = this.parseExpression();
-            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "..=", value };
+            return { kind: AST.NodeType.CompoundAssignment, target: expr, operator: "..=", value, line: expr.line, column: expr.column };
         }
         // Multiple targets: a, b = 1, 2
         if (this.at().type === TokenType.COMMA) {
@@ -473,12 +613,12 @@ export class Parser {
             while (this.match(TokenType.COMMA)) {
                 values.push(this.parseExpression());
             }
-            return { kind: AST.NodeType.AssignmentStmt, targets, values };
+            return { kind: AST.NodeType.AssignmentStmt, targets, values, line: expr.line, column: expr.column };
         }
         // Regular assignment
         if (this.match(TokenType.EQUALS)) {
             const value = this.parseExpression();
-            return { kind: AST.NodeType.AssignmentStmt, targets: [expr], values: [value] };
+            return { kind: AST.NodeType.AssignmentStmt, targets: [expr], values: [value], line: expr.line, column: expr.column };
         }
         return expr;
     }
@@ -585,9 +725,12 @@ export class Parser {
     }
     parseCallMember(allowColon = true) {
         let expr = this.parsePrimary();
+        return this.parseMemberSuffix(expr, allowColon);
+    }
+    parseMemberSuffix(expr, allowColon) {
         while (true) {
             if (this.match(TokenType.OPT_DOT)) {
-                const property = this.parseIdentifier();
+                const property = this.parseIdentifierName();
                 expr = { kind: AST.NodeType.OptionalChainExpr, object: expr, property, computed: false };
             }
             else if (this.match(TokenType.OPT_BRACKET)) {
@@ -596,11 +739,11 @@ export class Parser {
                 expr = { kind: AST.NodeType.OptionalChainExpr, object: expr, property, computed: true };
             }
             else if (this.match(TokenType.DOT)) {
-                const property = this.parseIdentifier();
-                expr = { kind: AST.NodeType.MemberExpr, object: expr, property, computed: false };
+                const property = this.parseIdentifierName();
+                expr = { kind: AST.NodeType.MemberExpr, object: expr, property, computed: false, line: expr.line, column: expr.column };
             }
             else if (allowColon && this.match(TokenType.COLON)) {
-                const property = this.parseIdentifier();
+                const property = this.parseIdentifierName();
                 expr = { kind: AST.NodeType.MemberExpr, object: expr, property, computed: false, isMethod: true };
             }
             else if (this.match(TokenType.LBRACKET)) {
@@ -669,9 +812,8 @@ export class Parser {
         const value = tk.value;
         const isLong = tk.type === TokenType.LONG_STRING;
         const quote = tk.quote || '"'; // Default to double quote for long strings
-        // Check for interpolation only if $ is followed by a valid identifier start (letter or _)
-        // This prevents SQL JSON paths like "$.bank" from being treated as interpolation
-        const hasInterpolation = /\$[a-zA-Z_]/.test(value);
+        // Check for interpolation: ${...} syntax
+        const hasInterpolation = /\$\{[^}]+\}/.test(value);
         if (hasInterpolation) {
             return this.parseInterpolatedString(value, quote);
         }
@@ -679,21 +821,48 @@ export class Parser {
     }
     parseInterpolatedString(str, quote = '"') {
         const parts = [];
-        const regex = /\$([a-zA-Z_][a-zA-Z0-9_]*)/g;
+        // Match ${expression} pattern - captures everything between ${ and }
+        const regex = /\$\{([^}]+)\}/g;
         let lastIndex = 0;
         let match;
         while ((match = regex.exec(str)) !== null) {
+            // Add text before the interpolation
             if (match.index > lastIndex) {
                 parts.push(str.slice(lastIndex, match.index));
             }
-            parts.push({ kind: AST.NodeType.Identifier, name: match[1] });
+            // Parse the expression inside ${...}
+            const exprStr = match[1].trim();
+            const exprAst = this.parseEmbeddedExpression(exprStr);
+            parts.push(exprAst);
             lastIndex = regex.lastIndex;
         }
+        // Add remaining text after last interpolation
         if (lastIndex < str.length) {
             parts.push(str.slice(lastIndex));
         }
         return { kind: AST.NodeType.InterpolatedString, parts, quote };
     }
+    // Parse an embedded expression string (for ${...} interpolation)
+    parseEmbeddedExpression(exprStr) {
+        // Import Lexer dynamically to avoid circular deps - use simple parsing
+        // For member expressions like Config.ServerName, parse manually
+        const parts = exprStr.split('.');
+        if (parts.length === 1) {
+            // Simple identifier
+            return { kind: AST.NodeType.Identifier, name: parts[0] };
+        }
+        // Build member expression chain: Config.ServerName.foo
+        let expr = { kind: AST.NodeType.Identifier, name: parts[0] };
+        for (let i = 1; i < parts.length; i++) {
+            expr = {
+                kind: AST.NodeType.MemberExpr,
+                object: expr,
+                property: { kind: AST.NodeType.Identifier, name: parts[i] },
+                computed: false
+            };
+        }
+        return expr;
+    }
     parseParenOrArrow() {
         const checkpoint = this.pos;
         this.eat(); // (
@@ -792,13 +961,29 @@ export class Parser {
     }
     parseIdentifier() {
         const token = this.expect(TokenType.IDENTIFIER);
-        return { kind: AST.NodeType.Identifier, name: token.value };
+        return { kind: AST.NodeType.Identifier, name: token.value, line: token.line, column: token.column };
+    }
+    parseIdentifierName() {
+        const token = this.at();
+        // Allow identifier or any token that looks like an identifier (including keywords)
+        // Exclude literals that definitely aren't identifiers
+        if (token.type === TokenType.STRING || token.type === TokenType.LONG_STRING ||
+            token.type === TokenType.NUMBER || token.type === TokenType.EOF) {
+            throw new Error(`Expected identifier name but got ${token.type} at ${token.line}:${token.column}`);
+        }
+        // Check regex to ensure it's alphanumeric (handles keywords like 'default', 'if', etc.)
+        if (/^[a-zA-Z_]\w*$/.test(token.value)) {
+            this.eat();
+            return { kind: AST.NodeType.Identifier, name: token.value, line: token.line, column: token.column };
+        }
+        // Fallback to standard expect for clear error message
+        return this.parseIdentifier();
     }
     parseParameter() {
-        const name = this.parseIdentifier();
+        const name = this.parseIdentifierName();
         let typeAnnotation;
         if (this.match(TokenType.COLON)) {
-            typeAnnotation = this.eat().value;
+            typeAnnotation = this.parseType();
         }
         let defaultValue;
         if (this.match(TokenType.EQUALS)) {

package/dist/compiler/semantics/SemanticAnalyzer.d.ts

@@ -0,0 +1,28 @@
+import * as AST from '../parser/AST.js';
+export declare class SemanticAnalyzer {
+    private globalScope;
+    private currentScope;
+    private typeRegistry;
+    private typeAliasRegistry;
+    private memberTypes;
+    private functionRegistry;
+    analyze(program: AST.Program): void;
+    private enterScope;
+    private exitScope;
+    private visitStatement;
+    private visitChildren;
+    private visitVariableDecl;
+    private visitAssignmentStmt;
+    private getMemberExprKey;
+    private visitCompoundAssignment;
+    private visitFunctionDecl;
+    private visitBlock;
+    private visitExpression;
+    private inferType;
+    private stringToType;
+    private visitTypeAliasDecl;
+    private visitTypeDecl;
+    private validateTypeExists;
+    private validateTableAgainstType;
+    private parseObjectLiteralType;
+}