[{"_1":2,"_172":-5,"_173":-5},"loaderData",{"_3":4,"_92":93},"root",{"_5":6,"_35":36,"_65":66},"ctx",{"_7":8,"_23":-5,"_24":25,"_26":27,"_28":20,"_29":20,"_30":20,"_31":32,"_33":20,"_34":20},"auth",{"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20,"_21":22},"sessionClaims","sessionId","sessionStatus","userId","actor","orgId","orgRole","orgSlug","orgPermissions","factorVerificationAge","isAuthenticated",false,"tokenType","session_token","user","preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","notificationCount",0,"flagDenols","isTeamOrgMember","ENV",{"_37":38,"_39":40,"_41":42,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":54,"_55":56,"_57":58,"_59":60,"_61":62,"_63":64},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","VAL_RUNTIME_NAME","prod","RENDER_GIT_COMMIT","4207e8ad4ddbe7f6e8b804339ca1b2ec4ab76c50","RENDER_GIT_BRANCH","main","CLERK_PUBLISHABLE_KEY","pk_live_Y2xlcmsudmFsLnRvd24k","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","API_URL","https://api.val.town","clerkState",{"_67":68},"__internal_clerk_state",{"_69":70,"_71":46,"_72":73,"_74":73,"_75":20,"_76":73,"_77":73,"_78":73,"_79":73,"_80":81,"_90":20,"_91":20},"__clerk_ssr_state",{"_21":22,"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20},"__publishableKey","__proxyUrl","","__domain","__isSatellite","__signInUrl","__signUpUrl","__afterSignInUrl","__afterSignUpUrl","__clerk_debug",{"_82":20,"_19":20,"_83":73,"_84":85,"_86":73,"_87":46,"_88":20,"_89":73},"isSignedIn","proxyUrl","reason","session-token-and-uat-missing","message","publishableKey","isSatellite","domain","__telemetryDisabled","__telemetryDebug","routes/embed.x.$handle.$name.$",{"_94":95,"_96":97,"_98":99,"_100":101,"_150":151,"_169":170,"_171":-5},"handle","ypiy","name","untitled-2689","path","compiler_semantic.ts","project",{"_102":103,"_96":97,"_104":105,"_106":-5,"_107":20,"_108":109,"_110":-5,"_111":-5,"_12":112,"_113":114,"_115":116,"_117":116,"_118":-5,"_119":32,"_14":120,"_121":122,"_123":122,"_124":125,"_126":125,"_127":125,"_128":122,"_129":122,"_23":130,"_133":134,"_136":137,"_149":20},"id","dce08a82-d1e4-11f0-96d5-42dde27851f2","createdAt",["D",1764944133689],"deletedAt","legacyEnvVars","privacy","public","description","imageUrl","019aeede-0a12-7249-8faa-7c9a717f911f","pinnedFileId","dce2f25e-d1e4-11f0-96d5-42dde27851f2","pinPreview",true,"pinMigrated","screenshotVersion","likeCount","019aeede-0a12-7249-8faa-8053cc7f3832","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm",{"_94":95,"_131":132},"profileImageUrl","https://img.clerk.com/eyJ0eXBlIjoicHJveHkiLCJzcmMiOiJodHRwczovL2ltYWdlcy5jbGVyay5kZXYvb2F1dGhfZ2l0aHViL2ltZ18zNlFnR29yNzIwa1NObGl3OUZ0TWtla2xiNmYifQ","org",{"_94":95,"_135":132,"_12":112},"avatar","branch",{"_138":139,"_96":44,"_102":140,"_141":103,"_142":-5,"_143":-5,"_144":-5,"_145":-5,"_146":-5,"_147":97,"_148":95},"version",40,"dce0e2fc-d1e4-11f0-96d5-42dde27851f2","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","isOwned","file",{"_102":152,"_96":99,"_153":154,"_155":-5,"_156":140,"_157":158,"_159":116,"_104":160,"_138":161,"_162":163,"_164":165,"_166":20,"_167":-5,"_98":168},"721c216e-d1fa-11f0-95bc-42dde27851f2","fileId","78b37972-d1f6-11f0-80ac-42dde27851f2","parentId","branchId","branchVersion",37,"latest",["D",1764953403478],3,"fileType","script","content","import wabtInit from \"https://esm.sh/wabt@1.0.36\";\nimport {\n alternate,\n argument,\n AssignmentExpression,\n BinaryExpression,\n BlockStatement,\n body,\n BooleanLiteral,\n BreakStatement,\n c,\n CallExpression,\n cases,\n condition,\n ConditionalExpression,\n consequent,\n ContinueStatement,\n decl,\n declarationType,\n ExportDeclaration,\n exported,\n expr,\n Expression,\n expression,\n ExpressionStatement,\n fields,\n FloatLiteral,\n ForStatement,\n FunctionDeclaration,\n GlobalDeclaration,\n GroupExpression,\n Identifier,\n IfStatement,\n init,\n initial,\n IntegerLiteral,\n label,\n left,\n let,\n Lexer,\n lit,\n maximum,\n MemoryDeclaration,\n operand,\n operator,\n parameter,\n paramType,\n Parser,\n PointerType,\n PrimitiveType,\n Program,\n prop,\n ReferenceType,\n ReturnStatement,\n right,\n size,\n source,\n SourceLocation,\n start,\n Statement,\n StructDeclaration,\n TypeAnnotation,\n TypeInfo,\n UnaryExpression,\n uni,\n update,\n variable,\n VariableDeclaration,\n WasmType,\n WhileStatement,\n} from \"https://esm.town/v/ypiy/untitled-2689/compiler_types.ts\";\nimport {\n add,\n binary,\n compile,\n data,\n div,\n execute,\n func,\n handle,\n i,\n l,\n lang,\n log,\n max,\n min,\n module,\n num,\n res,\n result,\n sign,\n t,\n type,\n x,\n y,\n} from \"https://esm.town/v/ypiy/untitled-2689/compiler_server.ts\";\n\n// SECTION 5: SEMANTIC ANALYZER / TYPE CHECKER\n// ============================================================================\n\nexport interface SymbolInfo {\n name: string;\n type: TypeInfo;\n mutable: boolean;\n exported: boolean;\n wasmType?: WasmType;\n localIndex?: number;\n globalIndex?: number;\n}\n\nexport interface Scope {\n symbols: Map;\n parent: Scope | null;\n kind: \"global\" | \"function\" | \"block\" | \"loop\";\n breakLabel?: string;\n continueLabel?: string;\n}\n\nexport interface SemanticError {\n message: string;\n loc?: SourceLocation;\n}\n\nexport class SemanticAnalyzer {\n private globalScope: Scope;\n private currentScope: Scope;\n private errors: SemanticError[] = [];\n private warnings: SemanticError[] = [];\n private currentFunction: FunctionDeclaration | null = null;\n\n constructor() {\n this.globalScope = {\n symbols: new Map(),\n parent: null,\n kind: \"global\",\n };\n this.currentScope = this.globalScope;\n }\n\n analyze(\n program: Program,\n ): { errors: SemanticError[]; warnings: SemanticError[] } {\n // First pass: collect all function and type declarations\n for (const stmt of program.body) {\n this.collectDeclaration(stmt);\n }\n\n // Second pass: analyze function bodies\n for (const stmt of program.body) {\n this.analyzeStatement(stmt);\n }\n\n return { errors: this.errors, warnings: this.warnings };\n }\n\n private enterScope(kind: Scope[\"kind\"]): void {\n this.currentScope = {\n symbols: new Map(),\n parent: this.currentScope,\n kind,\n };\n }\n\n private exitScope(): void {\n if (this.currentScope.parent) {\n this.currentScope = this.currentScope.parent;\n }\n }\n\n private declare(name: string, info: SymbolInfo): void {\n if (this.currentScope.symbols.has(name)) {\n this.errors.push({ message: `Duplicate declaration: ${name}` });\n return;\n }\n this.currentScope.symbols.set(name, info);\n }\n\n private resolve(name: string): SymbolInfo | null {\n let scope: Scope | null = this.currentScope;\n while (scope) {\n if (scope.symbols.has(name)) {\n return scope.symbols.get(name)!;\n }\n scope = scope.parent;\n }\n return null;\n }\n\n private collectDeclaration(stmt: Statement): void {\n if (stmt.kind === \"FunctionDeclaration\") {\n const func = stmt as FunctionDeclaration;\n const paramTypes = func.params.map((p) => this.resolveType(p.type));\n const returnType = this.resolveType(func.returnType);\n\n this.declare(func.name, {\n name: func.name,\n type: {\n kind: \"function\",\n type: {\n params: paramTypes,\n results: returnType === \"void\" ? [] : [returnType],\n },\n },\n mutable: false,\n exported: func.exported,\n wasmType: undefined,\n });\n } else if (stmt.kind === \"ExportDeclaration\") {\n const exp = stmt as ExportDeclaration;\n if (exp.declaration) {\n // Mark as exported\n this.collectDeclaration(exp.declaration);\n }\n } else if (stmt.kind === \"GlobalDeclaration\") {\n const global = stmt as GlobalDeclaration;\n const wasmType = this.resolveType(global.type);\n this.declare(global.name, {\n name: global.name,\n type: { kind: \"primitive\", type: wasmType },\n mutable: global.mutable,\n exported: global.exported,\n wasmType,\n });\n } else if (stmt.kind === \"StructDeclaration\") {\n const struct = stmt as StructDeclaration;\n this.declare(struct.name, {\n name: struct.name,\n type: {\n kind: \"struct\",\n type: {\n name: struct.name,\n fields: struct.fields.map((f) => ({\n name: f.name,\n type: this.resolveType(f.type),\n mutable: f.mutable,\n })),\n },\n },\n mutable: false,\n exported: struct.exported,\n });\n }\n }\n\n private resolveType(type?: TypeAnnotation): WasmType {\n if (!type) return \"i32\"; // Default type\n\n if (type.kind === \"PrimitiveType\") {\n const name = type.name.toLowerCase();\n const typeMap: Record = {\n \"i8\": \"i32\",\n \"i16\": \"i32\",\n \"i32\": \"i32\",\n \"i64\": \"i64\",\n \"u8\": \"i32\",\n \"u16\": \"i32\",\n \"u32\": \"i32\",\n \"u64\": \"i64\",\n \"int\": \"i32\",\n \"uint\": \"i32\",\n \"byte\": \"i32\",\n \"f32\": \"f32\",\n \"f64\": \"f64\",\n \"float\": \"f32\",\n \"double\": \"f64\",\n \"bool\": \"i32\",\n \"boolean\": \"i32\",\n \"void\": \"void\",\n \"number\": \"f64\",\n };\n return typeMap[name] || \"i32\";\n }\n\n if (type.kind === \"PointerType\" || type.kind === \"ReferenceType\") {\n return \"i32\"; // Pointers are i32 in wasm32\n }\n\n return \"i32\";\n }\n\n private analyzeStatement(stmt: Statement): void {\n switch (stmt.kind) {\n case \"FunctionDeclaration\":\n this.analyzeFunction(stmt);\n break;\n case \"VariableDeclaration\":\n this.analyzeVariable(stmt);\n break;\n case \"ExpressionStatement\":\n this.analyzeExpression(stmt.expression);\n break;\n case \"IfStatement\":\n this.analyzeIf(stmt);\n break;\n case \"WhileStatement\":\n this.analyzeWhile(stmt);\n break;\n case \"ForStatement\":\n this.analyzeFor(stmt);\n break;\n case \"ReturnStatement\":\n this.analyzeReturn(stmt);\n break;\n case \"BlockStatement\":\n this.enterScope(\"block\");\n for (const s of stmt.body) {\n this.analyzeStatement(s);\n }\n this.exitScope();\n break;\n case \"ExportDeclaration\":\n if (stmt.declaration) {\n this.analyzeStatement(stmt.declaration);\n }\n break;\n }\n }\n\n private analyzeFunction(func: FunctionDeclaration): void {\n this.currentFunction = func;\n this.enterScope(\"function\");\n\n // Add parameters to scope\n for (const param of func.params) {\n const wasmType = this.resolveType(param.type);\n this.declare(param.name, {\n name: param.name,\n type: { kind: \"primitive\", type: wasmType },\n mutable: param.mutable,\n exported: false,\n wasmType,\n });\n }\n\n // Analyze body\n for (const stmt of func.body.body) {\n this.analyzeStatement(stmt);\n }\n\n this.exitScope();\n this.currentFunction = null;\n }\n\n private analyzeVariable(decl: VariableDeclaration): void {\n const wasmType = this.resolveType(decl.type);\n\n if (decl.init) {\n this.analyzeExpression(decl.init);\n }\n\n this.declare(decl.name, {\n name: decl.name,\n type: { kind: \"primitive\", type: wasmType },\n mutable: decl.declarationType !== \"const\",\n exported: false,\n wasmType,\n });\n }\n\n private analyzeIf(stmt: IfStatement): void {\n this.analyzeExpression(stmt.condition);\n this.analyzeStatement(stmt.consequent);\n if (stmt.alternate) {\n this.analyzeStatement(stmt.alternate);\n }\n }\n\n private analyzeWhile(stmt: WhileStatement): void {\n this.analyzeExpression(stmt.condition);\n this.enterScope(\"loop\");\n this.analyzeStatement(stmt.body);\n this.exitScope();\n }\n\n private analyzeFor(stmt: ForStatement): void {\n this.enterScope(\"loop\");\n if (stmt.init) {\n this.analyzeStatement(stmt.init);\n }\n if (stmt.condition) {\n this.analyzeExpression(stmt.condition);\n }\n if (stmt.update) {\n this.analyzeExpression(stmt.update);\n }\n this.analyzeStatement(stmt.body);\n this.exitScope();\n }\n\n private analyzeReturn(stmt: ReturnStatement): void {\n if (stmt.value) {\n this.analyzeExpression(stmt.value);\n }\n }\n\n private analyzeExpression(expr: Expression): WasmType {\n switch (expr.kind) {\n case \"IntegerLiteral\":\n return \"i32\";\n case \"FloatLiteral\":\n return expr.type || \"f64\";\n case \"BooleanLiteral\":\n return \"i32\";\n case \"Identifier\": {\n const symbol = this.resolve(expr.name);\n if (!symbol) {\n this.errors.push({\n message: `Undefined variable: ${expr.name}`,\n loc: expr.loc,\n });\n return \"i32\";\n }\n return symbol.wasmType || \"i32\";\n }\n case \"BinaryExpression\":\n return this.analyzeBinaryExpression(expr);\n case \"UnaryExpression\":\n return this.analyzeUnaryExpression(expr);\n case \"CallExpression\":\n return this.analyzeCallExpression(expr);\n case \"AssignmentExpression\":\n return this.analyzeExpression(expr.right);\n case \"ConditionalExpression\":\n this.analyzeExpression(expr.condition);\n const thenType = this.analyzeExpression(expr.consequent);\n this.analyzeExpression(expr.alternate);\n return thenType;\n case \"GroupExpression\":\n return this.analyzeExpression(expr.expression);\n default:\n return \"i32\";\n }\n }\n\n private analyzeBinaryExpression(expr: BinaryExpression): WasmType {\n const leftType = this.analyzeExpression(expr.left);\n const rightType = this.analyzeExpression(expr.right);\n\n // Comparison operators return i32 (boolean)\n if (\n [\"==\", \"!=\", \"<\", \">\", \"<=\", \">=\", \"&&\", \"||\"].includes(expr.operator)\n ) {\n return \"i32\";\n }\n\n // If either operand is float, result is float\n if (leftType === \"f64\" || rightType === \"f64\") return \"f64\";\n if (leftType === \"f32\" || rightType === \"f32\") return \"f32\";\n if (leftType === \"i64\" || rightType === \"i64\") return \"i64\";\n\n return \"i32\";\n }\n\n private analyzeUnaryExpression(expr: UnaryExpression): WasmType {\n const operandType = this.analyzeExpression(expr.operand);\n if (expr.operator === \"!\") return \"i32\";\n return operandType;\n }\n\n private analyzeCallExpression(expr: CallExpression): WasmType {\n if (expr.callee.kind === \"Identifier\") {\n const symbol = this.resolve(expr.callee.name);\n if (!symbol) {\n this.errors.push({\n message: `Undefined function: ${expr.callee.name}`,\n loc: expr.loc,\n });\n return \"i32\";\n }\n if (symbol.type.kind === \"function\") {\n return symbol.type.type.results[0] || \"void\";\n }\n }\n\n // Analyze arguments\n for (const arg of expr.arguments) {\n this.analyzeExpression(arg);\n }\n\n return \"i32\";\n }\n}\n\n// ============================================================================\n// SECTION 6: INTERMEDIATE REPRESENTATION (IR)\n// ============================================================================\n\nexport enum IROpcode {\n // Constants\n CONST_I32,\n CONST_I64,\n CONST_F32,\n CONST_F64,\n // Local/Global variables\n LOCAL_GET,\n LOCAL_SET,\n LOCAL_TEE,\n GLOBAL_GET,\n GLOBAL_SET,\n // Arithmetic (i32)\n I32_ADD,\n I32_SUB,\n I32_MUL,\n I32_DIV_S,\n I32_DIV_U,\n I32_REM_S,\n I32_REM_U,\n I32_AND,\n I32_OR,\n I32_XOR,\n I32_SHL,\n I32_SHR_S,\n I32_SHR_U,\n I32_ROTL,\n I32_ROTR,\n I32_CLZ,\n I32_CTZ,\n I32_POPCNT,\n I32_EQZ,\n I32_EQ,\n I32_NE,\n I32_LT_S,\n I32_LT_U,\n I32_GT_S,\n I32_GT_U,\n I32_LE_S,\n I32_LE_U,\n I32_GE_S,\n I32_GE_U,\n // Arithmetic (i64)\n I64_ADD,\n I64_SUB,\n I64_MUL,\n I64_DIV_S,\n I64_DIV_U,\n I64_REM_S,\n I64_REM_U,\n I64_AND,\n I64_OR,\n I64_XOR,\n I64_SHL,\n I64_SHR_S,\n I64_SHR_U,\n I64_ROTL,\n I64_ROTR,\n I64_CLZ,\n I64_CTZ,\n I64_POPCNT,\n I64_EQZ,\n I64_EQ,\n I64_NE,\n I64_LT_S,\n I64_LT_U,\n I64_GT_S,\n I64_GT_U,\n I64_LE_S,\n I64_LE_U,\n I64_GE_S,\n I64_GE_U,\n // Arithmetic (f32)\n F32_ADD,\n F32_SUB,\n F32_MUL,\n F32_DIV,\n F32_MIN,\n F32_MAX,\n F32_ABS,\n F32_NEG,\n F32_CEIL,\n F32_FLOOR,\n F32_TRUNC,\n F32_NEAREST,\n F32_SQRT,\n F32_EQ,\n F32_NE,\n F32_LT,\n F32_GT,\n F32_LE,\n F32_GE,\n F32_COPYSIGN,\n // Arithmetic (f64)\n F64_ADD,\n F64_SUB,\n F64_MUL,\n F64_DIV,\n F64_MIN,\n F64_MAX,\n F64_ABS,\n F64_NEG,\n F64_CEIL,\n F64_FLOOR,\n F64_TRUNC,\n F64_NEAREST,\n F64_SQRT,\n F64_EQ,\n F64_NE,\n F64_LT,\n F64_GT,\n F64_LE,\n F64_GE,\n F64_COPYSIGN,\n // Conversions\n I32_WRAP_I64,\n I64_EXTEND_I32_S,\n I64_EXTEND_I32_U,\n I32_TRUNC_F32_S,\n I32_TRUNC_F32_U,\n I32_TRUNC_F64_S,\n I32_TRUNC_F64_U,\n I64_TRUNC_F32_S,\n I64_TRUNC_F32_U,\n I64_TRUNC_F64_S,\n I64_TRUNC_F64_U,\n F32_CONVERT_I32_S,\n F32_CONVERT_I32_U,\n F32_CONVERT_I64_S,\n F32_CONVERT_I64_U,\n F64_CONVERT_I32_S,\n F64_CONVERT_I32_U,\n F64_CONVERT_I64_S,\n F64_CONVERT_I64_U,\n F32_DEMOTE_F64,\n F64_PROMOTE_F32,\n I32_REINTERPRET_F32,\n I64_REINTERPRET_F64,\n F32_REINTERPRET_I32,\n F64_REINTERPRET_I64,\n // Memory\n I32_LOAD,\n I64_LOAD,\n F32_LOAD,\n F64_LOAD,\n I32_LOAD8_S,\n I32_LOAD8_U,\n I32_LOAD16_S,\n I32_LOAD16_U,\n I64_LOAD8_S,\n I64_LOAD8_U,\n I64_LOAD16_S,\n I64_LOAD16_U,\n I64_LOAD32_S,\n I64_LOAD32_U,\n I32_STORE,\n I64_STORE,\n F32_STORE,\n F64_STORE,\n I32_STORE8,\n I32_STORE16,\n I64_STORE8,\n I64_STORE16,\n I64_STORE32,\n MEMORY_SIZE,\n MEMORY_GROW,\n // Control flow\n BLOCK,\n LOOP,\n IF,\n ELSE,\n END,\n BR,\n BR_IF,\n BR_TABLE,\n RETURN,\n CALL,\n CALL_INDIRECT,\n // Stack\n DROP,\n SELECT,\n // Special\n UNREACHABLE,\n NOP,\n}\n\nexport interface IRInstruction {\n opcode: IROpcode;\n operands: (number | bigint | string)[];\n type?: WasmType;\n blockType?: WasmType;\n label?: string;\n}\n\nexport interface IRFunction {\n name: string;\n params: { name: string; type: WasmType }[];\n results: WasmType[];\n locals: { name: string; type: WasmType }[];\n body: IRInstruction[];\n exported: boolean;\n}\n\nexport interface IRGlobal {\n name: string;\n type: WasmType;\n mutable: boolean;\n init: IRInstruction[];\n exported: boolean;\n}\n\nexport interface IRMemory {\n name: string;\n initial: number;\n maximum?: number;\n exported: boolean;\n}\n\nexport interface IRModule {\n functions: IRFunction[];\n globals: IRGlobal[];\n memories: IRMemory[];\n dataSegments: { offset: number; data: Uint8Array }[];\n tables: { initial: number; maximum?: number }[];\n startFunction?: string;\n}\n\n// ============================================================================\n// SECTION 7: IR CODE GENERATOR\n// ============================================================================\n\nexport class IRGenerator {\n private module: IRModule;\n private currentFunction: IRFunction | null = null;\n private localMap: Map = new Map();\n private localCounter = 0;\n private labelCounter = 0;\n private loopStack: { breakLabel: string; continueLabel: string }[] = [];\n private globalScope: Map =\n new Map();\n private functionIndex: Map = new Map();\n\n constructor() {\n this.module = {\n functions: [],\n globals: [],\n memories: [],\n dataSegments: [],\n tables: [],\n };\n }\n\n generate(program: Program): IRModule {\n // First pass: register all functions\n let funcIndex = 0;\n for (const stmt of program.body) {\n if (stmt.kind === \"FunctionDeclaration\") {\n this.functionIndex.set(stmt.name, funcIndex++);\n } else if (\n stmt.kind === \"ExportDeclaration\" &&\n stmt.declaration?.kind === \"FunctionDeclaration\"\n ) {\n this.functionIndex.set(\n (stmt.declaration as FunctionDeclaration).name,\n funcIndex++,\n );\n }\n }\n\n // Second pass: generate IR\n for (const stmt of program.body) {\n this.generateStatement(stmt);\n }\n\n return this.module;\n }\n\n private generateStatement(stmt: Statement): void {\n switch (stmt.kind) {\n case \"FunctionDeclaration\":\n this.generateFunction(stmt);\n break;\n case \"ExportDeclaration\":\n if (stmt.declaration) {\n if (stmt.declaration.kind === \"FunctionDeclaration\") {\n stmt.declaration.exported = true;\n }\n this.generateStatement(stmt.declaration);\n }\n break;\n case \"GlobalDeclaration\":\n this.generateGlobal(stmt);\n break;\n case \"MemoryDeclaration\":\n this.module.memories.push({\n name: stmt.name,\n initial: stmt.initial,\n maximum: stmt.maximum,\n exported: stmt.exported,\n });\n break;\n }\n }\n\n private generateFunction(func: FunctionDeclaration): void {\n this.localMap.clear();\n this.localCounter = 0;\n\n const params: { name: string; type: WasmType }[] = [];\n for (const param of func.params) {\n const wasmType = this.resolveType(param.type);\n params.push({ name: param.name, type: wasmType });\n this.localMap.set(param.name, this.localCounter++);\n }\n\n const results: WasmType[] = [];\n const returnType = this.resolveType(func.returnType);\n if (returnType !== \"void\") {\n results.push(returnType);\n }\n\n this.currentFunction = {\n name: func.name,\n params,\n results,\n locals: [],\n body: [],\n exported: func.exported,\n };\n\n // Generate body\n for (const stmt of func.body.body) {\n this.generateFunctionStatement(stmt);\n }\n\n this.module.functions.push(this.currentFunction);\n this.currentFunction = null;\n }\n\n private generateGlobal(global: GlobalDeclaration): void {\n const wasmType = this.resolveType(global.type);\n const initInstructions: IRInstruction[] = [];\n\n // Generate init expression\n if (global.init.kind === \"IntegerLiteral\") {\n const value = Number((global.init as IntegerLiteral).value);\n if (wasmType === \"i64\") {\n initInstructions.push({\n opcode: IROpcode.CONST_I64,\n operands: [BigInt(value)],\n });\n } else {\n initInstructions.push({\n opcode: IROpcode.CONST_I32,\n operands: [value],\n });\n }\n } else if (global.init.kind === \"FloatLiteral\") {\n const value = (global.init as FloatLiteral).value;\n if (wasmType === \"f32\") {\n initInstructions.push({\n opcode: IROpcode.CONST_F32,\n operands: [value],\n });\n } else {\n initInstructions.push({\n opcode: IROpcode.CONST_F64,\n operands: [value],\n });\n }\n }\n\n this.globalScope.set(global.name, {\n type: wasmType,\n index: this.module.globals.length,\n });\n\n this.module.globals.push({\n name: global.name,\n type: wasmType,\n mutable: global.mutable,\n init: initInstructions,\n exported: global.exported,\n });\n }\n\n private generateFunctionStatement(stmt: Statement): void {\n switch (stmt.kind) {\n case \"VariableDeclaration\":\n this.generateVariableDeclaration(stmt);\n break;\n case \"ExpressionStatement\":\n this.generateExpression(stmt.expression);\n // If expression leaves a value on stack and we're not using it, drop it\n if (this.expressionProducesValue(stmt.expression)) {\n this.emit({ opcode: IROpcode.DROP, operands: [] });\n }\n break;\n case \"ReturnStatement\":\n if (stmt.value) {\n this.generateExpression(stmt.value);\n }\n this.emit({ opcode: IROpcode.RETURN, operands: [] });\n break;\n case \"IfStatement\":\n this.generateIf(stmt);\n break;\n case \"WhileStatement\":\n this.generateWhile(stmt);\n break;\n case \"ForStatement\":\n this.generateFor(stmt);\n break;\n case \"BlockStatement\":\n for (const s of stmt.body) {\n this.generateFunctionStatement(s);\n }\n break;\n case \"BreakStatement\":\n if (this.loopStack.length > 0) {\n const depth = 0; // Could calculate proper depth for nested loops\n this.emit({\n opcode: IROpcode.BR,\n operands: [depth],\n label: this.loopStack[this.loopStack.length - 1].breakLabel,\n });\n }\n break;\n case \"ContinueStatement\":\n if (this.loopStack.length > 0) {\n const depth = 1; // Jump to loop header\n this.emit({\n opcode: IROpcode.BR,\n operands: [depth],\n label: this.loopStack[this.loopStack.length - 1].continueLabel,\n });\n }\n break;\n }\n }\n\n private generateVariableDeclaration(decl: VariableDeclaration): void {\n const wasmType = this.resolveType(decl.type);\n const localIndex = this.localCounter++;\n this.localMap.set(decl.name, localIndex);\n this.currentFunction!.locals.push({ name: decl.name, type: wasmType });\n\n if (decl.init) {\n this.generateExpression(decl.init);\n this.emit({ opcode: IROpcode.LOCAL_SET, operands: [localIndex] });\n }\n }\n\n private generateIf(stmt: IfStatement): void {\n this.generateExpression(stmt.condition);\n\n const resultType = this.getBlockResultType(stmt);\n\n this.emit({ opcode: IROpcode.IF, operands: [], blockType: resultType });\n\n if (stmt.consequent.kind === \"BlockStatement\") {\n for (const s of stmt.consequent.body) {\n this.generateFunctionStatement(s);\n }\n } else {\n this.generateFunctionStatement(stmt.consequent);\n }\n\n if (stmt.alternate) {\n this.emit({ opcode: IROpcode.ELSE, operands: [] });\n if (stmt.alternate.kind === \"BlockStatement\") {\n for (const s of stmt.alternate.body) {\n this.generateFunctionStatement(s);\n }\n } else {\n this.generateFunctionStatement(stmt.alternate);\n }\n }\n\n this.emit({ opcode: IROpcode.END, operands: [] });\n }\n\n private generateWhile(stmt: WhileStatement): void {\n const breakLabel = `break_${this.labelCounter++}`;\n const continueLabel = `continue_${this.labelCounter++}`;\n\n this.loopStack.push({ breakLabel, continueLabel });\n\n if (stmt.doWhile) {\n // do-while: execute body first, then check condition\n this.emit({ opcode: IROpcode.BLOCK, operands: [], label: breakLabel });\n this.emit({ opcode: IROpcode.LOOP, operands: [], label: continueLabel });\n\n if (stmt.body.kind === \"BlockStatement\") {\n for (const s of stmt.body.body) {\n this.generateFunctionStatement(s);\n }\n } else {\n this.generateFunctionStatement(stmt.body);\n }\n\n this.generateExpression(stmt.condition);\n this.emit({ opcode: IROpcode.BR_IF, operands: [0] }); // Continue if true\n\n this.emit({ opcode: IROpcode.END, operands: [] }); // End loop\n this.emit({ opcode: IROpcode.END, operands: [] }); // End block\n } else {\n // while: check condition first\n this.emit({ opcode: IROpcode.BLOCK, operands: [], label: breakLabel });\n this.emit({ opcode: IROpcode.LOOP, operands: [], label: continueLabel });\n\n // Check condition, break if false\n this.generateExpression(stmt.condition);\n this.emit({ opcode: IROpcode.I32_EQZ, operands: [] });\n this.emit({ opcode: IROpcode.BR_IF, operands: [1] }); // Break to outer block\n\n if (stmt.body.kind === \"BlockStatement\") {\n for (const s of stmt.body.body) {\n this.generateFunctionStatement(s);\n }\n } else {\n this.generateFunctionStatement(stmt.body);\n }\n\n this.emit({ opcode: IROpcode.BR, operands: [0] }); // Continue loop\n\n this.emit({ opcode: IROpcode.END, operands: [] }); // End loop\n this.emit({ opcode: IROpcode.END, operands: [] }); // End block\n }\n\n this.loopStack.pop();\n }\n\n private generateFor(stmt: ForStatement): void {\n // Initialize\n if (stmt.init) {\n this.generateFunctionStatement(stmt.init);\n }\n\n const breakLabel = `break_${this.labelCounter++}`;\n const continueLabel = `continue_${this.labelCounter++}`;\n\n this.loopStack.push({ breakLabel, continueLabel });\n\n this.emit({ opcode: IROpcode.BLOCK, operands: [], label: breakLabel });\n this.emit({ opcode: IROpcode.LOOP, operands: [], label: continueLabel });\n\n // Check condition\n if (stmt.condition) {\n this.generateExpression(stmt.condition);\n this.emit({ opcode: IROpcode.I32_EQZ, operands: [] });\n this.emit({ opcode: IROpcode.BR_IF, operands: [1] }); // Break if false\n }\n\n // Body\n if (stmt.body.kind === \"BlockStatement\") {\n for (const s of stmt.body.body) {\n this.generateFunctionStatement(s);\n }\n } else {\n this.generateFunctionStatement(stmt.body);\n }\n\n // Update\n if (stmt.update) {\n this.generateExpression(stmt.update);\n if (this.expressionProducesValue(stmt.update)) {\n this.emit({ opcode: IROpcode.DROP, operands: [] });\n }\n }\n\n this.emit({ opcode: IROpcode.BR, operands: [0] }); // Continue loop\n\n this.emit({ opcode: IROpcode.END, operands: [] }); // End loop\n this.emit({ opcode: IROpcode.END, operands: [] }); // End block\n\n this.loopStack.pop();\n }\n\n private generateExpression(expr: Expression): void {\n switch (expr.kind) {\n case \"IntegerLiteral\":\n this.generateIntegerLiteral(expr);\n break;\n case \"FloatLiteral\":\n this.generateFloatLiteral(expr);\n break;\n case \"BooleanLiteral\":\n this.emit({\n opcode: IROpcode.CONST_I32,\n operands: [expr.value ? 1 : 0],\n });\n break;\n case \"Identifier\":\n this.generateIdentifier(expr);\n break;\n case \"BinaryExpression\":\n this.generateBinaryExpression(expr);\n break;\n case \"UnaryExpression\":\n this.generateUnaryExpression(expr);\n break;\n case \"CallExpression\":\n this.generateCallExpression(expr);\n break;\n case \"AssignmentExpression\":\n this.generateAssignmentExpression(expr);\n break;\n case \"ConditionalExpression\":\n this.generateConditionalExpression(expr);\n break;\n case \"GroupExpression\":\n this.generateExpression(expr.expression);\n break;\n }\n }\n\n private generateIntegerLiteral(lit: IntegerLiteral): void {\n const value = Number(lit.value);\n if (lit.type === \"i64\") {\n this.emit({ opcode: IROpcode.CONST_I64, operands: [lit.value] });\n } else {\n this.emit({ opcode: IROpcode.CONST_I32, operands: [value] });\n }\n }\n\n private generateFloatLiteral(lit: FloatLiteral): void {\n if (lit.type === \"f32\") {\n this.emit({ opcode: IROpcode.CONST_F32, operands: [lit.value] });\n } else {\n this.emit({ opcode: IROpcode.CONST_F64, operands: [lit.value] });\n }\n }\n\n private generateIdentifier(id: Identifier): void {\n // Check local first\n const localIndex = this.localMap.get(id.name);\n if (localIndex !== undefined) {\n this.emit({ opcode: IROpcode.LOCAL_GET, operands: [localIndex] });\n return;\n }\n\n // Check global\n const globalInfo = this.globalScope.get(id.name);\n if (globalInfo) {\n this.emit({ opcode: IROpcode.GLOBAL_GET, operands: [globalInfo.index] });\n return;\n }\n\n // Could be a function reference - emit as const 0 for now (would be handled by function ref in full impl)\n this.emit({ opcode: IROpcode.CONST_I32, operands: [0] });\n }\n\n private generateBinaryExpression(expr: BinaryExpression): void {\n // Generate both operands\n this.generateExpression(expr.left);\n this.generateExpression(expr.right);\n\n // Emit operation based on operator\n const opMap: Record = {\n \"+\": IROpcode.I32_ADD,\n \"-\": IROpcode.I32_SUB,\n \"*\": IROpcode.I32_MUL,\n \"/\": IROpcode.I32_DIV_S,\n \"%\": IROpcode.I32_REM_S,\n \"&\": IROpcode.I32_AND,\n \"|\": IROpcode.I32_OR,\n \"^\": IROpcode.I32_XOR,\n \"<<\": IROpcode.I32_SHL,\n \">>\": IROpcode.I32_SHR_S,\n \">>>\": IROpcode.I32_SHR_U,\n \"==\": IROpcode.I32_EQ,\n \"!=\": IROpcode.I32_NE,\n \"<\": IROpcode.I32_LT_S,\n \">\": IROpcode.I32_GT_S,\n \"<=\": IROpcode.I32_LE_S,\n \">=\": IROpcode.I32_GE_S,\n };\n\n // Handle logical operators specially\n if (expr.operator === \"&&\") {\n // a && b: if a is false, result is 0, else result is b\n this.emit({ opcode: IROpcode.I32_AND, operands: [] });\n return;\n }\n\n if (expr.operator === \"||\") {\n // a || b: if a is true, result is a, else result is b\n this.emit({ opcode: IROpcode.I32_OR, operands: [] });\n return;\n }\n\n const opcode = opMap[expr.operator];\n if (opcode !== undefined) {\n this.emit({ opcode, operands: [] });\n }\n }\n\n private generateUnaryExpression(expr: UnaryExpression): void {\n if (expr.prefix) {\n if (expr.operator === \"-\") {\n this.emit({ opcode: IROpcode.CONST_I32, operands: [0] });\n this.generateExpression(expr.operand);\n this.emit({ opcode: IROpcode.I32_SUB, operands: [] });\n } else if (expr.operator === \"!\") {\n this.generateExpression(expr.operand);\n this.emit({ opcode: IROpcode.I32_EQZ, operands: [] });\n } else if (expr.operator === \"~\") {\n this.generateExpression(expr.operand);\n this.emit({ opcode: IROpcode.CONST_I32, operands: [-1] });\n this.emit({ opcode: IROpcode.I32_XOR, operands: [] });\n } else if (expr.operator === \"++\" || expr.operator === \"--\") {\n if (expr.operand.kind === \"Identifier\") {\n const localIndex = this.localMap.get(expr.operand.name);\n if (localIndex !== undefined) {\n this.emit({ opcode: IROpcode.LOCAL_GET, operands: [localIndex] });\n this.emit({ opcode: IROpcode.CONST_I32, operands: [1] });\n this.emit({\n opcode: expr.operator === \"++\"\n ? IROpcode.I32_ADD\n : IROpcode.I32_SUB,\n operands: [],\n });\n this.emit({ opcode: IROpcode.LOCAL_TEE, operands: [localIndex] });\n }\n }\n }\n } else {\n // Postfix\n if (expr.operand.kind === \"Identifier\") {\n const localIndex = this.localMap.get(expr.operand.name);\n if (localIndex !== undefined) {\n this.emit({ opcode: IROpcode.LOCAL_GET, operands: [localIndex] }); // Original value\n this.emit({ opcode: IROpcode.LOCAL_GET, operands: [localIndex] });\n this.emit({ opcode: IROpcode.CONST_I32, operands: [1] });\n this.emit({\n opcode: expr.operator === \"++\"\n ? IROpcode.I32_ADD\n : IROpcode.I32_SUB,\n operands: [],\n });\n this.emit({ opcode: IROpcode.LOCAL_SET, operands: [localIndex] }); // Store new value\n // Original value remains on stack\n }\n }\n }\n }\n\n private generateCallExpression(expr: CallExpression): void {\n // Generate arguments\n for (const arg of expr.arguments) {\n this.generateExpression(arg);\n }\n\n // Get function index\n if (expr.callee.kind === \"Identifier\") {\n const funcIndex = this.functionIndex.get(expr.callee.name);\n if (funcIndex !== undefined) {\n this.emit({ opcode: IROpcode.CALL, operands: [funcIndex] });\n }\n }\n }\n\n private generateAssignmentExpression(expr: AssignmentExpression): void {\n if (expr.left.kind === \"Identifier\") {\n const localIndex = this.localMap.get(expr.left.name);\n const globalInfo = this.globalScope.get(expr.left.name);\n\n if (expr.operator === \"=\") {\n this.generateExpression(expr.right);\n } else {\n // Compound assignment\n this.generateExpression(expr.left);\n this.generateExpression(expr.right);\n\n const opMap: Record = {\n \"+=\": IROpcode.I32_ADD,\n \"-=\": IROpcode.I32_SUB,\n \"*=\": IROpcode.I32_MUL,\n \"/=\": IROpcode.I32_DIV_S,\n \"%=\": IROpcode.I32_REM_S,\n \"&=\": IROpcode.I32_AND,\n \"|=\": IROpcode.I32_OR,\n \"^=\": IROpcode.I32_XOR,\n \"<<=\": IROpcode.I32_SHL,\n \">>=\": IROpcode.I32_SHR_S,\n };\n\n const opcode = opMap[expr.operator];\n if (opcode) {\n this.emit({ opcode, operands: [] });\n }\n }\n\n if (localIndex !== undefined) {\n this.emit({ opcode: IROpcode.LOCAL_TEE, operands: [localIndex] });\n } else if (globalInfo) {\n this.emit({\n opcode: IROpcode.GLOBAL_SET,\n operands: [globalInfo.index],\n });\n this.emit({\n opcode: IROpcode.GLOBAL_GET,\n operands: [globalInfo.index],\n });\n }\n }\n }\n\n private generateConditionalExpression(expr: ConditionalExpression): void {\n this.generateExpression(expr.condition);\n this.emit({ opcode: IROpcode.IF, operands: [], blockType: \"i32\" });\n this.generateExpression(expr.consequent);\n this.emit({ opcode: IROpcode.ELSE, operands: [] });\n this.generateExpression(expr.alternate);\n this.emit({ opcode: IROpcode.END, operands: [] });\n }\n\n private emit(instr: IRInstruction): void {\n if (this.currentFunction) {\n this.currentFunction.body.push(instr);\n }\n }\n\n private resolveType(type?: TypeAnnotation): WasmType {\n if (!type) return \"i32\";\n if (type.kind === \"PrimitiveType\") {\n const name = type.name.toLowerCase();\n const typeMap: Record = {\n \"i8\": \"i32\",\n \"i16\": \"i32\",\n \"i32\": \"i32\",\n \"i64\": \"i64\",\n \"u8\": \"i32\",\n \"u16\": \"i32\",\n \"u32\": \"i32\",\n \"u64\": \"i64\",\n \"int\": \"i32\",\n \"uint\": \"i32\",\n \"byte\": \"i32\",\n \"f32\": \"f32\",\n \"f64\": \"f64\",\n \"float\": \"f32\",\n \"double\": \"f64\",\n \"bool\": \"i32\",\n \"boolean\": \"i32\",\n \"void\": \"void\",\n \"number\": \"f64\",\n };\n return typeMap[name] || \"i32\";\n }\n return \"i32\";\n }\n\n private expressionProducesValue(expr: Expression): boolean {\n if (expr.kind === \"AssignmentExpression\") return true;\n if (expr.kind === \"CallExpression\") return true;\n if (\n expr.kind === \"UnaryExpression\" &&\n (expr.operator === \"++\" || expr.operator === \"--\")\n ) return true;\n return true; // Most expressions produce values\n }\n\n private getBlockResultType(_stmt: IfStatement): WasmType | undefined {\n // For now, if blocks don't produce values\n // A more sophisticated analysis would check if both branches return values\n return undefined;\n }\n}\n\n// ============================================================================\n// SECTION 8: OPTIMIZER\n// ============================================================================\n\nexport class IROptimizer {\n optimize(module: IRModule): IRModule {\n for (const func of module.functions) {\n func.body = this.optimizeFunction(func.body);\n }\n return module;\n }\n\n private optimizeFunction(body: IRInstruction[]): IRInstruction[] {\n let optimized = [...body];\n\n // Multiple optimization passes\n for (let pass = 0; pass < 3; pass++) {\n optimized = this.constantFolding(optimized);\n optimized = this.deadCodeElimination(optimized);\n optimized = this.peepholeOptimizations(optimized);\n }\n\n return optimized;\n }\n\n private constantFolding(body: IRInstruction[]): IRInstruction[] {\n const result: IRInstruction[] = [];\n\n for (let i = 0; i < body.length; i++) {\n const instr = body[i];\n\n // Check for constant binary operations\n if (result.length >= 2) {\n const prev1 = result[result.length - 2];\n const prev2 = result[result.length - 1];\n\n if (\n prev1.opcode === IROpcode.CONST_I32 &&\n prev2.opcode === IROpcode.CONST_I32\n ) {\n const a = prev1.operands[0] as number;\n const b = prev2.operands[0] as number;\n let folded: number | null = null;\n\n switch (instr.opcode) {\n case IROpcode.I32_ADD:\n folded = a + b;\n break;\n case IROpcode.I32_SUB:\n folded = a - b;\n break;\n case IROpcode.I32_MUL:\n folded = a * b;\n break;\n case IROpcode.I32_DIV_S:\n if (b !== 0) folded = Math.floor(a / b);\n break;\n case IROpcode.I32_REM_S:\n if (b !== 0) folded = a % b;\n break;\n case IROpcode.I32_AND:\n folded = a & b;\n break;\n case IROpcode.I32_OR:\n folded = a | b;\n break;\n case IROpcode.I32_XOR:\n folded = a ^ b;\n break;\n case IROpcode.I32_SHL:\n folded = a << (b & 31);\n break;\n case IROpcode.I32_SHR_S:\n folded = a >> (b & 31);\n break;\n case IROpcode.I32_EQ:\n folded = a === b ? 1 : 0;\n break;\n case IROpcode.I32_NE:\n folded = a !== b ? 1 : 0;\n break;\n case IROpcode.I32_LT_S:\n folded = a < b ? 1 : 0;\n break;\n case IROpcode.I32_GT_S:\n folded = a > b ? 1 : 0;\n break;\n case IROpcode.I32_LE_S:\n folded = a <= b ? 1 : 0;\n break;\n case IROpcode.I32_GE_S:\n folded = a >= b ? 1 : 0;\n break;\n }\n\n if (folded !== null) {\n result.pop();\n result.pop();\n result.push({ opcode: IROpcode.CONST_I32, operands: [folded | 0] });\n continue;\n }\n }\n }\n\n result.push(instr);\n }\n\n return result;\n }\n\n private deadCodeElimination(body: IRInstruction[]): IRInstruction[] {\n // Remove unreachable code after unconditional branches\n const result: IRInstruction[] = [];\n let reachable = true;\n\n for (const instr of body) {\n if (!reachable) {\n // Skip until we hit a label or end\n if (instr.opcode === IROpcode.END || instr.opcode === IROpcode.ELSE) {\n reachable = true;\n result.push(instr);\n }\n continue;\n }\n\n result.push(instr);\n\n if (\n instr.opcode === IROpcode.RETURN ||\n instr.opcode === IROpcode.BR ||\n instr.opcode === IROpcode.UNREACHABLE\n ) {\n reachable = false;\n }\n\n if (\n instr.opcode === IROpcode.IF ||\n instr.opcode === IROpcode.BLOCK ||\n instr.opcode === IROpcode.LOOP\n ) {\n reachable = true;\n }\n }\n\n return result;\n }\n\n private peepholeOptimizations(body: IRInstruction[]): IRInstruction[] {\n const result: IRInstruction[] = [];\n\n for (let i = 0; i < body.length; i++) {\n const instr = body[i];\n\n // Optimize: x * 2 -> x << 1\n if (instr.opcode === IROpcode.I32_MUL && result.length >= 1) {\n const prev = result[result.length - 1];\n if (prev.opcode === IROpcode.CONST_I32) {\n const val = prev.operands[0] as number;\n if (val > 0 && (val & (val - 1)) === 0) {\n const shift = Math.log2(val);\n result.pop();\n result.push({ opcode: IROpcode.CONST_I32, operands: [shift] });\n result.push({ opcode: IROpcode.I32_SHL, operands: [] });\n continue;\n }\n }\n }\n\n // Optimize: x + 0 -> x\n if (instr.opcode === IROpcode.I32_ADD && result.length >= 1) {\n const prev = result[result.length - 1];\n if (prev.opcode === IROpcode.CONST_I32 && prev.operands[0] === 0) {\n result.pop();\n continue;\n }\n }\n\n // Optimize: x * 1 -> x\n if (instr.opcode === IROpcode.I32_MUL && result.length >= 1) {\n const prev = result[result.length - 1];\n if (prev.opcode === IROpcode.CONST_I32 && prev.operands[0] === 1) {\n result.pop();\n continue;\n }\n }\n\n // Optimize: x * 0 -> 0\n if (instr.opcode === IROpcode.I32_MUL && result.length >= 1) {\n const prev = result[result.length - 1];\n if (prev.opcode === IROpcode.CONST_I32 && prev.operands[0] === 0) {\n result.pop();\n result.push({ opcode: IROpcode.DROP, operands: [] });\n result.push({ opcode: IROpcode.CONST_I32, operands: [0] });\n continue;\n }\n }\n\n // Optimize: local.get \\$x; local.set \\$x -> (nothing)\n if (instr.opcode === IROpcode.LOCAL_SET && result.length >= 1) {\n const prev = result[result.length - 1];\n if (\n prev.opcode === IROpcode.LOCAL_GET &&\n prev.operands[0] === instr.operands[0]\n ) {\n result.pop();\n continue;\n }\n }\n\n result.push(instr);\n }\n\n return result;\n }\n}\n\n// ============================================================================\n// SECTION 9: WAT CODE GENERATOR\n// ============================================================================\n\nexport class WATGenerator {\n generate(module: IRModule): string {\n const lines: string[] = [\"(module\"];\n\n // Memory\n for (const mem of module.memories) {\n let memStr = ` (memory $${mem.name}`;\n if (mem.exported) memStr = ` (memory (export \"${mem.name}\")`;\n memStr += ` ${mem.initial}`;\n if (mem.maximum !== undefined) memStr += ` ${mem.maximum}`;\n memStr += \")\";\n lines.push(memStr);\n }\n\n // Globals\n for (const global of module.globals) {\n const mutStr = global.mutable ? `(mut ${global.type})` : global.type;\n const exportStr = global.exported ? ` (export \"${global.name}\")` : \"\";\n const initStr = this.generateInitExpr(global.init);\n lines.push(` (global $${global.name}${exportStr} ${mutStr} ${initStr})`);\n }\n\n // Functions\n for (const func of module.functions) {\n lines.push(this.generateFunction(func));\n }\n\n lines.push(\")\");\n return lines.join(\"\\n\");\n }\n\n private generateInitExpr(instrs: IRInstruction[]): string {\n if (instrs.length === 0) return \"(i32.const 0)\";\n\n const instr = instrs[0];\n switch (instr.opcode) {\n case IROpcode.CONST_I32:\n return `(i32.const ${instr.operands[0]})`;\n case IROpcode.CONST_I64:\n return `(i64.const ${instr.operands[0]})`;\n case IROpcode.CONST_F32:\n return `(f32.const ${instr.operands[0]})`;\n case IROpcode.CONST_F64:\n return `(f64.const ${instr.operands[0]})`;\n default:\n return \"(i32.const 0)\";\n }\n }\n\n private generateFunction(func: IRFunction): string {\n const lines: string[] = [];\n\n // Function signature\n let sig = ` (func $${func.name}`;\n if (func.exported) {\n sig += ` (export \"${func.name}\")`;\n }\n\n for (const param of func.params) {\n sig += ` (param $${param.name} ${param.type})`;\n }\n\n if (func.results.length > 0) {\n sig += ` (result ${func.results.join(\" \")})`;\n }\n\n lines.push(sig);\n\n // Locals\n for (const local of func.locals) {\n lines.push(` (local $${local.name} ${local.type})`);\n }\n\n // Body\n for (const instr of func.body) {\n lines.push(\" \" + this.generateInstruction(instr, func));\n }\n\n lines.push(\" )\");\n return lines.join(\"\\n\");\n }\n\n private generateInstruction(instr: IRInstruction, func: IRFunction): string {\n const opcodeToWat: Record = {\n [IROpcode.CONST_I32]: \"i32.const\",\n [IROpcode.CONST_I64]: \"i64.const\",\n [IROpcode.CONST_F32]: \"f32.const\",\n [IROpcode.CONST_F64]: \"f64.const\",\n [IROpcode.LOCAL_GET]: \"local.get\",\n [IROpcode.LOCAL_SET]: \"local.set\",\n [IROpcode.LOCAL_TEE]: \"local.tee\",\n [IROpcode.GLOBAL_GET]: \"global.get\",\n [IROpcode.GLOBAL_SET]: \"global.set\",\n [IROpcode.I32_ADD]: \"i32.add\",\n [IROpcode.I32_SUB]: \"i32.sub\",\n [IROpcode.I32_MUL]: \"i32.mul\",\n [IROpcode.I32_DIV_S]: \"i32.div_s\",\n [IROpcode.I32_DIV_U]: \"i32.div_u\",\n [IROpcode.I32_REM_S]: \"i32.rem_s\",\n [IROpcode.I32_REM_U]: \"i32.rem_u\",\n [IROpcode.I32_AND]: \"i32.and\",\n [IROpcode.I32_OR]: \"i32.or\",\n [IROpcode.I32_XOR]: \"i32.xor\",\n [IROpcode.I32_SHL]: \"i32.shl\",\n [IROpcode.I32_SHR_S]: \"i32.shr_s\",\n [IROpcode.I32_SHR_U]: \"i32.shr_u\",\n [IROpcode.I32_ROTL]: \"i32.rotl\",\n [IROpcode.I32_ROTR]: \"i32.rotr\",\n [IROpcode.I32_CLZ]: \"i32.clz\",\n [IROpcode.I32_CTZ]: \"i32.ctz\",\n [IROpcode.I32_POPCNT]: \"i32.popcnt\",\n [IROpcode.I32_EQZ]: \"i32.eqz\",\n [IROpcode.I32_EQ]: \"i32.eq\",\n [IROpcode.I32_NE]: \"i32.ne\",\n [IROpcode.I32_LT_S]: \"i32.lt_s\",\n [IROpcode.I32_LT_U]: \"i32.lt_u\",\n [IROpcode.I32_GT_S]: \"i32.gt_s\",\n [IROpcode.I32_GT_U]: \"i32.gt_u\",\n [IROpcode.I32_LE_S]: \"i32.le_s\",\n [IROpcode.I32_LE_U]: \"i32.le_u\",\n [IROpcode.I32_GE_S]: \"i32.ge_s\",\n [IROpcode.I32_GE_U]: \"i32.ge_u\",\n [IROpcode.I64_ADD]: \"i64.add\",\n [IROpcode.I64_SUB]: \"i64.sub\",\n [IROpcode.I64_MUL]: \"i64.mul\",\n [IROpcode.I64_DIV_S]: \"i64.div_s\",\n [IROpcode.I64_DIV_U]: \"i64.div_u\",\n [IROpcode.I64_REM_S]: \"i64.rem_s\",\n [IROpcode.I64_REM_U]: \"i64.rem_u\",\n [IROpcode.I64_AND]: \"i64.and\",\n [IROpcode.I64_OR]: \"i64.or\",\n [IROpcode.I64_XOR]: \"i64.xor\",\n [IROpcode.I64_SHL]: \"i64.shl\",\n [IROpcode.I64_SHR_S]: \"i64.shr_s\",\n [IROpcode.I64_SHR_U]: \"i64.shr_u\",\n [IROpcode.I64_ROTL]: \"i64.rotl\",\n [IROpcode.I64_ROTR]: \"i64.rotr\",\n [IROpcode.I64_CLZ]: \"i64.clz\",\n [IROpcode.I64_CTZ]: \"i64.ctz\",\n [IROpcode.I64_POPCNT]: \"i64.popcnt\",\n [IROpcode.I64_EQZ]: \"i64.eqz\",\n [IROpcode.I64_EQ]: \"i64.eq\",\n [IROpcode.I64_NE]: \"i64.ne\",\n [IROpcode.I64_LT_S]: \"i64.lt_s\",\n [IROpcode.I64_LT_U]: \"i64.lt_u\",\n [IROpcode.I64_GT_S]: \"i64.gt_s\",\n [IROpcode.I64_GT_U]: \"i64.gt_u\",\n [IROpcode.I64_LE_S]: \"i64.le_s\",\n [IROpcode.I64_LE_U]: \"i64.le_u\",\n [IROpcode.I64_GE_S]: \"i64.ge_s\",\n [IROpcode.I64_GE_U]: \"i64.ge_u\",\n [IROpcode.F32_ADD]: \"f32.add\",\n [IROpcode.F32_SUB]: \"f32.sub\",\n [IROpcode.F32_MUL]: \"f32.mul\",\n [IROpcode.F32_DIV]: \"f32.div\",\n [IROpcode.F32_MIN]: \"f32.min\",\n [IROpcode.F32_MAX]: \"f32.max\",\n [IROpcode.F32_ABS]: \"f32.abs\",\n [IROpcode.F32_NEG]: \"f32.neg\",\n [IROpcode.F32_CEIL]: \"f32.ceil\",\n [IROpcode.F32_FLOOR]: \"f32.floor\",\n [IROpcode.F32_TRUNC]: \"f32.trunc\",\n [IROpcode.F32_NEAREST]: \"f32.nearest\",\n [IROpcode.F32_SQRT]: \"f32.sqrt\",\n [IROpcode.F32_EQ]: \"f32.eq\",\n [IROpcode.F32_NE]: \"f32.ne\",\n [IROpcode.F32_LT]: \"f32.lt\",\n [IROpcode.F32_GT]: \"f32.gt\",\n [IROpcode.F32_LE]: \"f32.le\",\n [IROpcode.F32_GE]: \"f32.ge\",\n [IROpcode.F32_COPYSIGN]: \"f32.copysign\",\n [IROpcode.F64_ADD]: \"f64.add\",\n [IROpcode.F64_SUB]: \"f64.sub\",\n [IROpcode.F64_MUL]: \"f64.mul\",\n [IROpcode.F64_DIV]: \"f64.div\",\n [IROpcode.F64_MIN]: \"f64.min\",\n [IROpcode.F64_MAX]: \"f64.max\",\n [IROpcode.F64_ABS]: \"f64.abs\",\n [IROpcode.F64_NEG]: \"f64.neg\",\n [IROpcode.F64_CEIL]: \"f64.ceil\",\n [IROpcode.F64_FLOOR]: \"f64.floor\",\n [IROpcode.F64_TRUNC]: \"f64.trunc\",\n [IROpcode.F64_NEAREST]: \"f64.nearest\",\n [IROpcode.F64_SQRT]: \"f64.sqrt\",\n [IROpcode.F64_EQ]: \"f64.eq\",\n [IROpcode.F64_NE]: \"f64.ne\",\n [IROpcode.F64_LT]: \"f64.lt\",\n [IROpcode.F64_GT]: \"f64.gt\",\n [IROpcode.F64_LE]: \"f64.le\",\n [IROpcode.F64_GE]: \"f64.ge\",\n [IROpcode.F64_COPYSIGN]: \"f64.copysign\",\n [IROpcode.I32_WRAP_I64]: \"i32.wrap_i64\",\n [IROpcode.I64_EXTEND_I32_S]: \"i64.extend_i32_s\",\n [IROpcode.I64_EXTEND_I32_U]: \"i64.extend_i32_u\",\n [IROpcode.I32_TRUNC_F32_S]: \"i32.trunc_f32_s\",\n [IROpcode.I32_TRUNC_F32_U]: \"i32.trunc_f32_u\",\n [IROpcode.I32_TRUNC_F64_S]: \"i32.trunc_f64_s\",\n [IROpcode.I32_TRUNC_F64_U]: \"i32.trunc_f64_u\",\n [IROpcode.I64_TRUNC_F32_S]: \"i64.trunc_f32_s\",\n [IROpcode.I64_TRUNC_F32_U]: \"i64.trunc_f32_u\",\n [IROpcode.I64_TRUNC_F64_S]: \"i64.trunc_f64_s\",\n [IROpcode.I64_TRUNC_F64_U]: \"i64.trunc_f64_u\",\n [IROpcode.F32_CONVERT_I32_S]: \"f32.convert_i32_s\",\n [IROpcode.F32_CONVERT_I32_U]: \"f32.convert_i32_u\",\n [IROpcode.F32_CONVERT_I64_S]: \"f32.convert_i64_s\",\n [IROpcode.F32_CONVERT_I64_U]: \"f32.convert_i64_u\",\n [IROpcode.F64_CONVERT_I32_S]: \"f64.convert_i32_s\",\n [IROpcode.F64_CONVERT_I32_U]: \"f64.convert_i32_u\",\n [IROpcode.F64_CONVERT_I64_S]: \"f64.convert_i64_s\",\n [IROpcode.F64_CONVERT_I64_U]: \"f64.convert_i64_u\",\n [IROpcode.F32_DEMOTE_F64]: \"f32.demote_f64\",\n [IROpcode.F64_PROMOTE_F32]: \"f64.promote_f32\",\n [IROpcode.I32_REINTERPRET_F32]: \"i32.reinterpret_f32\",\n [IROpcode.I64_REINTERPRET_F64]: \"i64.reinterpret_f64\",\n [IROpcode.F32_REINTERPRET_I32]: \"f32.reinterpret_i32\",\n [IROpcode.F64_REINTERPRET_I64]: \"f64.reinterpret_i64\",\n [IROpcode.I32_LOAD]: \"i32.load\",\n [IROpcode.I64_LOAD]: \"i64.load\",\n [IROpcode.F32_LOAD]: \"f32.load\",\n [IROpcode.F64_LOAD]: \"f64.load\",\n [IROpcode.I32_LOAD8_S]: \"i32.load8_s\",\n [IROpcode.I32_LOAD8_U]: \"i32.load8_u\",\n [IROpcode.I32_LOAD16_S]: \"i32.load16_s\",\n [IROpcode.I32_LOAD16_U]: \"i32.load16_u\",\n [IROpcode.I64_LOAD8_S]: \"i64.load8_s\",\n [IROpcode.I64_LOAD8_U]: \"i64.load8_u\",\n [IROpcode.I64_LOAD16_S]: \"i64.load16_s\",\n [IROpcode.I64_LOAD16_U]: \"i64.load16_u\",\n [IROpcode.I64_LOAD32_S]: \"i64.load32_s\",\n [IROpcode.I64_LOAD32_U]: \"i64.load32_u\",\n [IROpcode.I32_STORE]: \"i32.store\",\n [IROpcode.I64_STORE]: \"i64.store\",\n [IROpcode.F32_STORE]: \"f32.store\",\n [IROpcode.F64_STORE]: \"f64.store\",\n [IROpcode.I32_STORE8]: \"i32.store8\",\n [IROpcode.I32_STORE16]: \"i32.store16\",\n [IROpcode.I64_STORE8]: \"i64.store8\",\n [IROpcode.I64_STORE16]: \"i64.store16\",\n [IROpcode.I64_STORE32]: \"i64.store32\",\n [IROpcode.MEMORY_SIZE]: \"memory.size\",\n [IROpcode.MEMORY_GROW]: \"memory.grow\",\n [IROpcode.BLOCK]: \"block\",\n [IROpcode.LOOP]: \"loop\",\n [IROpcode.IF]: \"if\",\n [IROpcode.ELSE]: \"else\",\n [IROpcode.END]: \"end\",\n [IROpcode.BR]: \"br\",\n [IROpcode.BR_IF]: \"br_if\",\n [IROpcode.BR_TABLE]: \"br_table\",\n [IROpcode.RETURN]: \"return\",\n [IROpcode.CALL]: \"call\",\n [IROpcode.CALL_INDIRECT]: \"call_indirect\",\n [IROpcode.DROP]: \"drop\",\n [IROpcode.SELECT]: \"select\",\n [IROpcode.UNREACHABLE]: \"unreachable\",\n [IROpcode.NOP]: \"nop\",\n };\n\n const watOp = opcodeToWat[instr.opcode];\n\n // Handle special cases\n switch (instr.opcode) {\n case IROpcode.CONST_I32:\n case IROpcode.CONST_I64:\n case IROpcode.CONST_F32:\n case IROpcode.CONST_F64:\n return `${watOp} ${instr.operands[0]}`;\n\n case IROpcode.LOCAL_GET:\n case IROpcode.LOCAL_SET:\n case IROpcode.LOCAL_TEE: {\n const localIndex = instr.operands[0] as number;\n const localName = this.getLocalName(func, localIndex);\n return `${watOp} $${localName}`;\n }\n\n case IROpcode.GLOBAL_GET:\n case IROpcode.GLOBAL_SET:\n return `${watOp} ${instr.operands[0]}`;\n\n case IROpcode.CALL:\n return `${watOp} ${instr.operands[0]}`;\n\n case IROpcode.BR:\n case IROpcode.BR_IF:\n return `${watOp} ${instr.operands[0]}`;\n\n case IROpcode.IF:\n if (instr.blockType) {\n return `(${watOp} (result ${instr.blockType})`;\n }\n return `(${watOp}`;\n\n case IROpcode.BLOCK:\n case IROpcode.LOOP:\n if (instr.blockType) {\n return `(${watOp} (result ${instr.blockType})`;\n }\n return `(${watOp}`;\n\n case IROpcode.END:\n return \")\";\n\n case IROpcode.ELSE:\n return \")(else\";\n\n default:\n return watOp || `;; unknown opcode ${instr.opcode}`;\n }\n }\n\n private getLocalName(func: IRFunction, index: number): string {\n if (index < func.params.length) {\n return func.params[index].name;\n }\n const localIndex = index - func.params.length;\n if (localIndex < func.locals.length) {\n return func.locals[localIndex].name;\n }\n return `local_${index}`;\n }\n}\n\n// ============================================================================\n// SECTION 10: WABT INTEGRATION\n// ============================================================================\n\nexport let wabtInstance: any = null;\n\nasync function getWabt() {\n if (!wabtInstance) {\n wabtInstance = await wabtInit();\n }\n return wabtInstance;\n}\n\n// ============================================================================\n// SECTION 11: COMPILER PIPELINE\n// ============================================================================\n\nexport interface CompileRequest {\n language: string;\n code: string;\n optimize?: boolean;\n}\n\nexport interface Diagnostic {\n kind: \"info\" | \"warning\" | \"error\";\n message: string;\n line?: number;\n column?: number;\n}\n\nexport interface CompileResponse {\n ok: boolean;\n language: string;\n wasmBase64?: string;\n wasmSize?: number;\n wat?: string;\n ir?: string;\n ast?: string;\n diagnostics: Diagnostic[];\n error?: string;\n timing?: {\n lexer?: number;\n parser?: number;\n semantic?: number;\n irgen?: number;\n optimize?: number;\n watgen?: number;\n assemble?: number;\n total: number;\n };\n}\n\nexport function encodeBase64(bytes: Uint8Array): string {\n let binary = \"\";\n for (let i = 0; i < bytes.length; i++) {\n binary += String.fromCharCode(bytes[i]);\n }\n return btoa(binary);\n}\n\nexport class Compiler {\n async compile(source: string, optimize = true): Promise {\n const startTime = performance.now();\n const diagnostics: Diagnostic[] = [];\n const timing: CompileResponse[\"timing\"] = { total: 0 };\n\n try {\n // Phase 1: Lexical Analysis\n const lexerStart = performance.now();\n const lexer = new Lexer(source);\n const { tokens, errors: lexerErrors } = lexer.tokenize();\n timing.lexer = performance.now() - lexerStart;\n\n for (const err of lexerErrors) {\n diagnostics.push({\n kind: \"error\",\n message: err.message,\n line: err.line,\n column: err.column,\n });\n }\n\n if (lexerErrors.length > 0) {\n throw new Error(\"Lexer errors\");\n }\n\n // Phase 2: Parsing\n const parserStart = performance.now();\n const parser = new Parser(tokens);\n const { program, errors: parseErrors } = parser.parse();\n timing.parser = performance.now() - parserStart;\n\n for (const err of parseErrors) {\n diagnostics.push({\n kind: \"error\",\n message: err.message,\n line: err.token.line,\n column: err.token.column,\n });\n }\n\n if (parseErrors.length > 0) {\n throw new Error(\"Parse errors\");\n }\n\n // Phase 3: Semantic Analysis\n const semanticStart = performance.now();\n const analyzer = new SemanticAnalyzer();\n const { errors: semanticErrors, warnings: semanticWarnings } = analyzer\n .analyze(program);\n timing.semantic = performance.now() - semanticStart;\n\n for (const warn of semanticWarnings) {\n diagnostics.push({\n kind: \"warning\",\n message: warn.message,\n line: warn.loc?.line,\n column: warn.loc?.column,\n });\n }\n\n for (const err of semanticErrors) {\n diagnostics.push({\n kind: \"error\",\n message: err.message,\n line: err.loc?.line,\n column: err.loc?.column,\n });\n }\n\n if (semanticErrors.length > 0) {\n throw new Error(\"Semantic errors\");\n }\n\n // Phase 4: IR Generation\n const irgenStart = performance.now();\n const irGenerator = new IRGenerator();\n let irModule = irGenerator.generate(program);\n timing.irgen = performance.now() - irgenStart;\n\n // Phase 5: Optimization\n if (optimize) {\n const optimizeStart = performance.now();\n const optimizer = new IROptimizer();\n irModule = optimizer.optimize(irModule);\n timing.optimize = performance.now() - optimizeStart;\n }\n\n // Phase 6: WAT Generation\n const watgenStart = performance.now();\n const watGenerator = new WATGenerator();\n const wat = watGenerator.generate(irModule);\n timing.watgen = performance.now() - watgenStart;\n\n // Phase 7: WABT Assembly\n const assembleStart = performance.now();\n const wabt = await getWabt();\n let wasmModule: any = null;\n\n try {\n wasmModule = wabt.parseWat(\"module.wat\", wat);\n wasmModule.resolveNames();\n wasmModule.validate();\n\n const { buffer, log } = wasmModule.toBinary({\n log: true,\n write_debug_names: true,\n });\n\n if (log && String(log).trim()) {\n diagnostics.push({ kind: \"info\", message: String(log).trim() });\n }\n\n timing.assemble = performance.now() - assembleStart;\n timing.total = performance.now() - startTime;\n\n return {\n ok: true,\n language: \"universal\",\n wasmBase64: encodeBase64(new Uint8Array(buffer)),\n wasmSize: buffer.byteLength,\n wat,\n diagnostics,\n timing,\n };\n } finally {\n if (wasmModule && wasmModule.destroy) {\n wasmModule.destroy();\n }\n }\n } catch (err) {\n timing.total = performance.now() - startTime;\n return {\n ok: false,\n language: \"universal\",\n diagnostics,\n error: String(err),\n timing,\n };\n }\n }\n}\n\n// Also support direct WAT compilation\nasync function compileWat(code: string): Promise {\n let wasmModule: any = null;\n try {\n const wabt = await getWabt();\n wasmModule = wabt.parseWat(\"module.wat\", code);\n wasmModule.resolveNames();\n wasmModule.validate();\n\n const { buffer, log } = wasmModule.toBinary({\n log: true,\n write_debug_names: true,\n });\n\n const diagnostics: Diagnostic[] = [];\n if (log && String(log).trim()) {\n diagnostics.push({ kind: \"info\", message: String(log).trim() });\n }\n\n return {\n ok: true,\n language: \"wat\",\n wasmBase64: encodeBase64(new Uint8Array(buffer)),\n wasmSize: buffer.byteLength,\n wat: code,\n diagnostics,\n };\n } catch (err) {\n return {\n ok: false,\n language: \"wat\",\n diagnostics: [],\n error: String(err),\n };\n } finally {\n if (wasmModule && wasmModule.destroy) {\n wasmModule.destroy();\n }\n }\n}\n\n// ============================================================================","deleted","label",[99],"permalink","https://www.val.town/x/ypiy/untitled-2689/code/compiler_semantic.ts","extension","actionData","errors"]