lt-script 1.0.0 → 1.0.3

package/dist/compiler/parser/AST.js

@@ -33,6 +33,8 @@ export var NodeType;
     NodeType["EmitStmt"] = "EmitStmt";
     NodeType["EventHandler"] = "EventHandler";
     NodeType["ExportDecl"] = "ExportDecl";
+    // Type System
+    NodeType["TypeDecl"] = "TypeDecl";
     // Expressions
     NodeType["BinaryExpr"] = "BinaryExpr";
     NodeType["UnaryExpr"] = "UnaryExpr";

package/dist/compiler/parser/Parser.d.ts

@@ -30,6 +30,7 @@ export declare class Parser {
     private parseSwitchStmt;
     private parseCommandStmt;
     private parseExportDecl;
+    private parseTypeDecl;
     private parseExpressionStatement;
     private parseExpression;
     private parseAssignment;
@@ -44,15 +45,18 @@ export declare class Parser {
     private parseMultiplicative;
     private parseUnary;
     private parseCallMember;
+    private parseMemberSuffix;
     private parseCallExpr;
     private parsePrimary;
     private parseStringLiteral;
     private parseInterpolatedString;
+    private parseEmbeddedExpression;
     private parseParenOrArrow;
     private parseArrayLiteral;
     private parseTableLiteral;
     private parseVectorLiteral;
     private parseIdentifier;
+    private parseIdentifierName;
     private parseParameter;
     private parseObjectDestructure;
     private parseArrayDestructure;

package/dist/compiler/parser/Parser.js

@@ -69,8 +69,10 @@ 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();
         }
@@ -91,7 +93,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')
@@ -119,7 +121,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 +226,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 +236,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
@@ -405,7 +428,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 +457,79 @@ 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.EQUALS);
+        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.eat().value; // 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 +543,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 +655,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 +669,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 +742,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 +751,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,10 +891,26 @@ 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;

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

@@ -0,0 +1,23 @@
+import * as AST from '../parser/AST.js';
+export declare class SemanticAnalyzer {
+    private globalScope;
+    private currentScope;
+    private typeRegistry;
+    private memberTypes;
+    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 visitTypeDecl;
+    private validateTableAgainstType;
+}