lt-script 1.0.0

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

@@ -0,0 +1,314 @@
+/**
+ * LT Language AST Node Definitions
+ * All AST node types for the parser
+ */
+export declare enum NodeType {
+    Program = "Program",
+    VariableDecl = "VariableDecl",
+    AssignmentStmt = "AssignmentStmt",
+    CompoundAssignment = "CompoundAssignment",
+    IfStmt = "IfStmt",
+    ForStmt = "ForStmt",
+    RangeForStmt = "RangeForStmt",
+    WhileStmt = "WhileStmt",
+    ReturnStmt = "ReturnStmt",
+    BreakStmt = "BreakStmt",
+    ContinueStmt = "ContinueStmt",
+    SwitchStmt = "SwitchStmt",
+    Block = "Block",
+    GuardStmt = "GuardStmt",
+    SafeCallStmt = "SafeCallStmt",
+    ThreadStmt = "ThreadStmt",
+    LoopStmt = "LoopStmt",
+    WaitStmt = "WaitStmt",
+    TimeoutStmt = "TimeoutStmt",
+    IntervalStmt = "IntervalStmt",
+    TryCatchStmt = "TryCatchStmt",
+    CommandStmt = "CommandStmt",
+    EmitStmt = "EmitStmt",
+    EventHandler = "EventHandler",
+    ExportDecl = "ExportDecl",
+    BinaryExpr = "BinaryExpr",
+    UnaryExpr = "UnaryExpr",
+    UpdateExpr = "UpdateExpr",// ++, --
+    ConditionalExpr = "ConditionalExpr",// Ternary ? :
+    CallExpr = "CallExpr",
+    MemberExpr = "MemberExpr",
+    OptionalChainExpr = "OptionalChainExpr",
+    NullCoalesceExpr = "NullCoalesceExpr",
+    ArrowFunc = "ArrowFunc",
+    FunctionDecl = "FunctionDecl",
+    Identifier = "Identifier",
+    NumberLiteral = "NumberLiteral",
+    StringLiteral = "StringLiteral",
+    InterpolatedString = "InterpolatedString",
+    BooleanLiteral = "BooleanLiteral",
+    NilLiteral = "NilLiteral",
+    TableLiteral = "TableLiteral",
+    VectorLiteral = "VectorLiteral",
+    SpreadExpr = "SpreadExpr",
+    ObjectDestructure = "ObjectDestructure",
+    ArrayDestructure = "ArrayDestructure"
+}
+export interface Node {
+    kind: NodeType;
+    line?: number;
+    column?: number;
+}
+export interface Statement extends Node {
+}
+export interface Expression extends Node {
+}
+export interface Program extends Node {
+    kind: NodeType.Program;
+    body: Statement[];
+}
+export interface VariableDecl extends Statement {
+    kind: NodeType.VariableDecl;
+    scope: "var" | "let" | "const" | "local";
+    names: (Identifier | ObjectDestructure | ArrayDestructure)[];
+    typeAnnotations?: (string | undefined)[];
+    values?: Expression[];
+}
+export interface FunctionDecl extends Statement {
+    kind: NodeType.FunctionDecl;
+    name?: Identifier | MemberExpr;
+    params: Parameter[];
+    returnType?: string;
+    body: Block;
+    isLocal?: boolean;
+}
+export interface Parameter {
+    name: Identifier;
+    typeAnnotation?: string;
+    defaultValue?: Expression;
+}
+export interface AssignmentStmt extends Statement {
+    kind: NodeType.AssignmentStmt;
+    targets: Expression[];
+    values: Expression[];
+}
+export interface CompoundAssignment extends Statement {
+    kind: NodeType.CompoundAssignment;
+    target: Expression;
+    operator: "+=" | "-=" | "*=" | "/=" | "%=" | "..=";
+    value: Expression;
+}
+export interface IfStmt extends Statement {
+    kind: NodeType.IfStmt;
+    condition: Expression;
+    thenBody: Block;
+    elseIfClauses?: {
+        condition: Expression;
+        body: Block;
+    }[];
+    elseBody?: Block;
+}
+export interface ForStmt extends Statement {
+    kind: NodeType.ForStmt;
+    iterators: Identifier[];
+    iterable: Expression;
+    body: Block;
+}
+export interface RangeForStmt extends Statement {
+    kind: NodeType.RangeForStmt;
+    counter: Identifier;
+    start: Expression;
+    end: Expression;
+    step?: Expression;
+    body: Block;
+}
+export interface WhileStmt extends Statement {
+    kind: NodeType.WhileStmt;
+    condition: Expression;
+    body: Block;
+}
+export interface ReturnStmt extends Statement {
+    kind: NodeType.ReturnStmt;
+    values?: Expression[];
+}
+export interface BreakStmt extends Statement {
+    kind: NodeType.BreakStmt;
+}
+export interface ContinueStmt extends Statement {
+    kind: NodeType.ContinueStmt;
+}
+export interface SwitchStmt extends Statement {
+    kind: NodeType.SwitchStmt;
+    discriminant: Expression;
+    cases: SwitchCase[];
+    defaultCase?: Block;
+}
+export interface SwitchCase {
+    values: Expression[];
+    body: Block;
+}
+export interface Block extends Node {
+    kind: NodeType.Block;
+    statements: Statement[];
+}
+export interface GuardStmt extends Statement {
+    kind: NodeType.GuardStmt;
+    condition: Expression;
+    elseBody?: Statement[];
+}
+export interface SafeCallStmt extends Statement {
+    kind: NodeType.SafeCallStmt;
+    call: CallExpr;
+}
+export interface ThreadStmt extends Statement {
+    kind: NodeType.ThreadStmt;
+    body: Block;
+}
+export interface LoopStmt extends Statement {
+    kind: NodeType.LoopStmt;
+    conditions: Expression[];
+    body: Block;
+}
+export interface WaitStmt extends Statement {
+    kind: NodeType.WaitStmt;
+    time: Expression;
+}
+export interface TimeoutStmt extends Statement {
+    kind: NodeType.TimeoutStmt;
+    delay: Expression;
+    body: Block;
+}
+export interface IntervalStmt extends Statement {
+    kind: NodeType.IntervalStmt;
+    interval: Expression;
+    body: Block;
+}
+export interface TryCatchStmt extends Statement {
+    kind: NodeType.TryCatchStmt;
+    tryBody: Block;
+    catchParam: Identifier;
+    catchBody: Block;
+}
+export interface EmitStmt extends Statement {
+    kind: NodeType.EmitStmt;
+    emitType: "emit" | "emitClient" | "emitServer";
+    eventName: Expression;
+    args: Expression[];
+}
+export interface EventHandler extends Statement {
+    kind: NodeType.EventHandler;
+    isNet: boolean;
+    eventName: Expression;
+    params: Parameter[];
+    body: Block;
+}
+export interface ExportDecl extends Statement {
+    kind: NodeType.ExportDecl;
+    declaration: FunctionDecl;
+}
+export interface CommandStmt extends Statement {
+    kind: NodeType.CommandStmt;
+    commandName: string;
+    params: Parameter[];
+    body: Block;
+}
+export interface BinaryExpr extends Expression {
+    kind: NodeType.BinaryExpr;
+    left: Expression;
+    operator: string;
+    right: Expression;
+}
+export interface UnaryExpr extends Expression {
+    kind: NodeType.UnaryExpr;
+    operator: string;
+    operand: Expression;
+}
+export interface UpdateExpr extends Expression {
+    kind: NodeType.UpdateExpr;
+    operator: "++" | "--";
+    argument: Expression;
+    prefix: boolean;
+}
+export interface ConditionalExpr extends Expression {
+    kind: NodeType.ConditionalExpr;
+    test: Expression;
+    consequent: Expression;
+    alternate: Expression;
+}
+export interface SpreadExpr extends Expression {
+    kind: NodeType.SpreadExpr;
+    argument: Expression;
+}
+export interface CallExpr extends Expression {
+    kind: NodeType.CallExpr;
+    callee: Expression;
+    args: Expression[];
+}
+export interface MemberExpr extends Expression {
+    kind: NodeType.MemberExpr;
+    object: Expression;
+    property: Expression;
+    computed: boolean;
+    isMethod?: boolean;
+}
+export interface OptionalChainExpr extends Expression {
+    kind: NodeType.OptionalChainExpr;
+    object: Expression;
+    property: Expression;
+    computed: boolean;
+    isMethod?: boolean;
+}
+export interface NullCoalesceExpr extends Expression {
+    kind: NodeType.NullCoalesceExpr;
+    left: Expression;
+    right: Expression;
+}
+export interface ArrowFunc extends Expression {
+    kind: NodeType.ArrowFunc;
+    params: Parameter[];
+    body: Block | Expression;
+}
+export interface Identifier extends Expression {
+    kind: NodeType.Identifier;
+    name: string;
+    attribute?: string;
+}
+export interface NumberLiteral extends Expression {
+    kind: NodeType.NumberLiteral;
+    value: number;
+}
+export interface StringLiteral extends Expression {
+    kind: NodeType.StringLiteral;
+    value: string;
+    isLong?: boolean;
+    quote?: "'" | '"';
+}
+export interface InterpolatedString extends Expression {
+    kind: NodeType.InterpolatedString;
+    parts: (string | Expression)[];
+    quote?: "'" | '"';
+}
+export interface BooleanLiteral extends Expression {
+    kind: NodeType.BooleanLiteral;
+    value: boolean;
+}
+export interface NilLiteral extends Expression {
+    kind: NodeType.NilLiteral;
+}
+export interface TableLiteral extends Expression {
+    kind: NodeType.TableLiteral;
+    fields: TableField[];
+}
+export interface TableField {
+    key?: Expression;
+    value: Expression;
+    shorthand?: boolean;
+}
+export interface VectorLiteral extends Expression {
+    kind: NodeType.VectorLiteral;
+    components: Expression[];
+}
+export interface ObjectDestructure extends Node {
+    kind: NodeType.ObjectDestructure;
+    properties: Identifier[];
+}
+export interface ArrayDestructure extends Node {
+    kind: NodeType.ArrayDestructure;
+    elements: Identifier[];
+}

package/dist/compiler/parser/AST.js

@@ -0,0 +1,60 @@
+/**
+ * LT Language AST Node Definitions
+ * All AST node types for the parser
+ */
+export var NodeType;
+(function (NodeType) {
+    // Program
+    NodeType["Program"] = "Program";
+    // Statements
+    NodeType["VariableDecl"] = "VariableDecl";
+    NodeType["AssignmentStmt"] = "AssignmentStmt";
+    NodeType["CompoundAssignment"] = "CompoundAssignment";
+    NodeType["IfStmt"] = "IfStmt";
+    NodeType["ForStmt"] = "ForStmt";
+    NodeType["RangeForStmt"] = "RangeForStmt";
+    NodeType["WhileStmt"] = "WhileStmt";
+    NodeType["ReturnStmt"] = "ReturnStmt";
+    NodeType["BreakStmt"] = "BreakStmt";
+    NodeType["ContinueStmt"] = "ContinueStmt";
+    NodeType["SwitchStmt"] = "SwitchStmt";
+    NodeType["Block"] = "Block";
+    // LT Sugar Statements
+    NodeType["GuardStmt"] = "GuardStmt";
+    NodeType["SafeCallStmt"] = "SafeCallStmt";
+    NodeType["ThreadStmt"] = "ThreadStmt";
+    NodeType["LoopStmt"] = "LoopStmt";
+    NodeType["WaitStmt"] = "WaitStmt";
+    NodeType["TimeoutStmt"] = "TimeoutStmt";
+    NodeType["IntervalStmt"] = "IntervalStmt";
+    NodeType["TryCatchStmt"] = "TryCatchStmt";
+    NodeType["CommandStmt"] = "CommandStmt";
+    // FiveM Events
+    NodeType["EmitStmt"] = "EmitStmt";
+    NodeType["EventHandler"] = "EventHandler";
+    NodeType["ExportDecl"] = "ExportDecl";
+    // Expressions
+    NodeType["BinaryExpr"] = "BinaryExpr";
+    NodeType["UnaryExpr"] = "UnaryExpr";
+    NodeType["UpdateExpr"] = "UpdateExpr";
+    NodeType["ConditionalExpr"] = "ConditionalExpr";
+    NodeType["CallExpr"] = "CallExpr";
+    NodeType["MemberExpr"] = "MemberExpr";
+    NodeType["OptionalChainExpr"] = "OptionalChainExpr";
+    NodeType["NullCoalesceExpr"] = "NullCoalesceExpr";
+    NodeType["ArrowFunc"] = "ArrowFunc";
+    NodeType["FunctionDecl"] = "FunctionDecl";
+    // Literals
+    NodeType["Identifier"] = "Identifier";
+    NodeType["NumberLiteral"] = "NumberLiteral";
+    NodeType["StringLiteral"] = "StringLiteral";
+    NodeType["InterpolatedString"] = "InterpolatedString";
+    NodeType["BooleanLiteral"] = "BooleanLiteral";
+    NodeType["NilLiteral"] = "NilLiteral";
+    NodeType["TableLiteral"] = "TableLiteral";
+    NodeType["VectorLiteral"] = "VectorLiteral";
+    NodeType["SpreadExpr"] = "SpreadExpr";
+    // Patterns
+    NodeType["ObjectDestructure"] = "ObjectDestructure";
+    NodeType["ArrayDestructure"] = "ArrayDestructure";
+})(NodeType || (NodeType = {}));

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

@@ -0,0 +1,68 @@
+import { Token } from '../lexer/Token.js';
+import * as AST from './AST.js';
+/**
+ * LT Language Parser
+ * Recursive descent parser for LT → AST
+ */
+export declare class Parser {
+    private tokens;
+    private pos;
+    constructor(tokens: Token[]);
+    parse(): AST.Program;
+    private parseStatement;
+    private parseVariableDecl;
+    private parseIfStmt;
+    private parseForStmt;
+    private parseWhileStmt;
+    private parseReturnStmt;
+    private parseGuardStmt;
+    private parseSafeCall;
+    private parseThreadStmt;
+    private parseLoopStmt;
+    private parseWaitStmt;
+    private parseTimeoutStmt;
+    private parseIntervalStmt;
+    private parseTryCatch;
+    private parseEmitStmt;
+    private parseEventHandler;
+    private parseFunctionDecl;
+    private parseFunctionExpr;
+    private parseSwitchStmt;
+    private parseCommandStmt;
+    private parseExportDecl;
+    private parseExpressionStatement;
+    private parseExpression;
+    private parseAssignment;
+    private parseTernaryExpr;
+    private parseNullCoalesce;
+    private parseOr;
+    private parseAnd;
+    private parseEquality;
+    private parseComparison;
+    private parseConcat;
+    private parseAdditive;
+    private parseMultiplicative;
+    private parseUnary;
+    private parseCallMember;
+    private parseCallExpr;
+    private parsePrimary;
+    private parseStringLiteral;
+    private parseInterpolatedString;
+    private parseParenOrArrow;
+    private parseArrayLiteral;
+    private parseTableLiteral;
+    private parseVectorLiteral;
+    private parseIdentifier;
+    private parseParameter;
+    private parseObjectDestructure;
+    private parseArrayDestructure;
+    private parseBlockUntil;
+    private at;
+    private peek;
+    private eat;
+    private match;
+    private check;
+    private expect;
+    private isEOF;
+    private isStatementEnd;
+}