skittles 1.2.7 → 1.3.0

package/dist/compiler/parser.js

@@ -2,9 +2,47 @@ import ts from "typescript";
 // Module-level registries, populated during parse()
 let _knownStructs = new Map();
 let _knownContractInterfaces = new Set();
-let _knownEnums = new Set();
+let _knownEnums = new Map();
 let _knownCustomErrors = new Set();
 let _fileConstants = new Map();
+let _currentSourceFile = null;
+// String type tracking for string.length and string comparison transforms
+let _currentVarTypes = new Map();
+let _currentStringNames = new Set();
+function getSourceLine(node) {
+    if (!_currentSourceFile)
+        return undefined;
+    return _currentSourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1; // 1-based
+}
+function setupStringTracking(parameters, varTypes) {
+    _currentVarTypes = varTypes;
+    _currentStringNames = new Set();
+    for (const param of parameters) {
+        if (param.type.kind === "string") {
+            _currentStringNames.add(param.name);
+        }
+    }
+}
+function isStringExpr(expr) {
+    if (expr.kind === "string-literal")
+        return true;
+    if (expr.kind === "identifier" && _currentStringNames.has(expr.name))
+        return true;
+    if (expr.kind === "property-access" &&
+        expr.object.kind === "identifier" &&
+        expr.object.name === "this") {
+        const type = _currentVarTypes.get(expr.property);
+        return type?.kind === "string";
+    }
+    if (expr.kind === "call" &&
+        expr.callee.kind === "property-access" &&
+        expr.callee.object.kind === "identifier" &&
+        expr.callee.object.name === "string" &&
+        expr.callee.property === "concat") {
+        return true;
+    }
+    return false;
+}
 // ============================================================
 // Main entry
 // ============================================================
@@ -23,7 +61,7 @@ export function collectTypes(source, filePath) {
     const prevEnums = _knownEnums;
     const prevInterfaces = _knownContractInterfaces;
     _knownStructs = structs;
-    _knownEnums = new Set();
+    _knownEnums = new Map();
     _knownContractInterfaces = new Set();
     ts.forEachChild(sourceFile, (node) => {
         if (ts.isTypeAliasDeclaration(node) && node.name && ts.isTypeLiteralNode(node.type)) {
@@ -47,6 +85,7 @@ export function collectTypes(source, filePath) {
 }
 export function parse(source, filePath, externalTypes, externalFunctions) {
     const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
+    _currentSourceFile = sourceFile;
     const structs = new Map();
     const enums = new Map();
     const contractInterfaces = new Map();
@@ -79,7 +118,7 @@ export function parse(source, filePath, externalTypes, externalFunctions) {
         }
     });
     _knownStructs = structs;
-    _knownEnums = new Set(enums.keys());
+    _knownEnums = new Map(enums);
     // Second pass: parse interfaces (may reference struct/enum types collected above)
     ts.forEachChild(sourceFile, (node) => {
         if (ts.isInterfaceDeclaration(node) && node.name) {
@@ -139,6 +178,34 @@ export function parse(source, filePath, externalTypes, externalFunctions) {
             }
         }
     });
+    // Post-process: infer overrides for abstract method implementations
+    const abstractMethodsByContract = new Map();
+    for (const contract of contracts) {
+        if (contract.isAbstract) {
+            const abstractMethods = new Set();
+            for (const fn of contract.functions) {
+                if (fn.isAbstract) {
+                    abstractMethods.add(fn.name);
+                }
+            }
+            if (abstractMethods.size > 0) {
+                abstractMethodsByContract.set(contract.name, abstractMethods);
+            }
+        }
+    }
+    for (const contract of contracts) {
+        for (const parentName of contract.inherits) {
+            const abstractMethods = abstractMethodsByContract.get(parentName);
+            if (!abstractMethods)
+                continue;
+            for (const fn of contract.functions) {
+                if (abstractMethods.has(fn.name) && !fn.isOverride) {
+                    fn.isOverride = true;
+                    fn.isVirtual = false;
+                }
+            }
+        }
+    }
     return contracts;
 }
 /**
@@ -156,7 +223,7 @@ export function collectFunctions(source, filePath) {
     const prevEnums = _knownEnums;
     const prevInterfaces = _knownContractInterfaces;
     _knownStructs = new Map();
-    _knownEnums = new Set();
+    _knownEnums = new Map();
     _knownContractInterfaces = new Set();
     ts.forEachChild(sourceFile, (node) => {
         if (ts.isFunctionDeclaration(node) && node.name && node.body) {
@@ -180,6 +247,21 @@ export function collectFunctions(source, filePath) {
     _knownContractInterfaces = prevInterfaces;
     return { functions, constants };
 }
+/**
+ * Pre-scan a source file to collect the names of all contract classes
+ * (top-level class declarations that do not extend Error).
+ * Used by the compiler to track which file defines each contract.
+ */
+export function collectClassNames(source, filePath) {
+    const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
+    const names = [];
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isClassDeclaration(node) && node.name && !extendsError(node)) {
+            names.push(node.name.text);
+        }
+    });
+    return names;
+}
 function parseArrayDestructuring(pattern, initializer, varTypes) {
     const statements = [];
     if (ts.isArrayLiteralExpression(initializer)) {
@@ -233,9 +315,140 @@ function parseArrayDestructuring(pattern, initializer, varTypes) {
     }
     return statements;
 }
+function parseObjectDestructuring(pattern, initializer, varTypes, decl) {
+    const statements = [];
+    if (ts.isObjectLiteralExpression(initializer)) {
+        // Direct object literal: const { a, b } = { a: 1, b: 2 }
+        const propMap = new Map();
+        for (const prop of initializer.properties) {
+            if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                propMap.set(prop.name.text, prop.initializer);
+            }
+        }
+        for (const elem of pattern.elements) {
+            if (ts.isBindingElement(elem) && ts.isIdentifier(elem.name)) {
+                const name = elem.name.text;
+                const propName = elem.propertyName && ts.isIdentifier(elem.propertyName)
+                    ? elem.propertyName.text
+                    : name;
+                const init = propMap.has(propName)
+                    ? parseExpression(propMap.get(propName))
+                    : undefined;
+                const type = init ? inferType(init, varTypes) : undefined;
+                statements.push({
+                    kind: "variable-declaration",
+                    name,
+                    type,
+                    initializer: init,
+                });
+            }
+        }
+        return statements;
+    }
+    // Non-literal initializer: const { amount, timestamp } = this.getStakeInfo(account)
+    // Try to resolve struct type for a temp variable approach
+    let structType;
+    // Check explicit type annotation
+    if (decl.type) {
+        structType = parseType(decl.type);
+    }
+    // If no explicit type, try to find it from a this.method() call
+    if (!structType && ts.isCallExpression(initializer)) {
+        const callee = initializer.expression;
+        if (ts.isPropertyAccessExpression(callee) &&
+            callee.expression.kind === ts.SyntaxKind.ThisKeyword) {
+            const methodName = callee.name.text;
+            const cls = findEnclosingClass(decl);
+            if (cls) {
+                const retTypeNode = findMethodReturnType(cls, methodName);
+                if (retTypeNode) {
+                    structType = parseType(retTypeNode);
+                }
+            }
+        }
+    }
+    const initExpr = parseExpression(initializer);
+    if (structType?.kind === "struct" && structType.structName) {
+        // Temp variable + field accesses
+        const tempName = `_${structType.structName.charAt(0).toLowerCase()}${structType.structName.slice(1)}`;
+        statements.push({
+            kind: "variable-declaration",
+            name: tempName,
+            type: structType,
+            initializer: initExpr,
+        });
+        const fieldMap = new Map();
+        if (structType.structFields) {
+            for (const f of structType.structFields) {
+                fieldMap.set(f.name, f.type);
+            }
+        }
+        for (const elem of pattern.elements) {
+            if (ts.isBindingElement(elem) && ts.isIdentifier(elem.name)) {
+                const name = elem.name.text;
+                const propName = elem.propertyName && ts.isIdentifier(elem.propertyName)
+                    ? elem.propertyName.text
+                    : name;
+                statements.push({
+                    kind: "variable-declaration",
+                    name,
+                    type: fieldMap.get(propName),
+                    initializer: {
+                        kind: "property-access",
+                        object: { kind: "identifier", name: tempName },
+                        property: propName,
+                    },
+                });
+            }
+        }
+    }
+    else {
+        // Fallback: property-access expressions directly on the initializer
+        for (const elem of pattern.elements) {
+            if (ts.isBindingElement(elem) && ts.isIdentifier(elem.name)) {
+                const name = elem.name.text;
+                const propName = elem.propertyName && ts.isIdentifier(elem.propertyName)
+                    ? elem.propertyName.text
+                    : name;
+                statements.push({
+                    kind: "variable-declaration",
+                    name,
+                    type: undefined,
+                    initializer: {
+                        kind: "property-access",
+                        object: initExpr,
+                        property: propName,
+                    },
+                });
+            }
+        }
+    }
+    return statements;
+}
+function findEnclosingClass(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isClassDeclaration(current))
+            return current;
+        current = current.parent;
+    }
+    return undefined;
+}
+function findMethodReturnType(cls, methodName) {
+    for (const member of cls.members) {
+        if (ts.isMethodDeclaration(member) &&
+            member.name &&
+            ts.isIdentifier(member.name) &&
+            member.name.text === methodName) {
+            return member.type;
+        }
+    }
+    return undefined;
+}
 function parseStandaloneFunction(node, varTypes, eventNames) {
     const name = node.name ? node.name.text : "unknown";
     const parameters = node.parameters.map(parseParameter);
+    setupStringTracking(parameters, varTypes);
     const returnType = node.type ? parseType(node.type) : null;
     const body = node.body ? parseBlock(node.body, varTypes, eventNames) : [];
     const stateMutability = inferStateMutability(body);
@@ -248,12 +461,14 @@ function parseStandaloneFunction(node, varTypes, eventNames) {
         isVirtual: false,
         isOverride: false,
         body,
+        sourceLine: getSourceLine(node),
     };
 }
 function parseStandaloneArrowFunction(decl, varTypes, eventNames) {
     const name = ts.isIdentifier(decl.name) ? decl.name.text : "unknown";
     const arrow = decl.initializer;
     const parameters = arrow.parameters.map(parseParameter);
+    setupStringTracking(parameters, varTypes);
     const returnType = arrow.type ? parseType(arrow.type) : null;
     let body = [];
     if (arrow.body) {
@@ -274,6 +489,7 @@ function parseStandaloneArrowFunction(decl, varTypes, eventNames) {
         isVirtual: false,
         isOverride: false,
         body,
+        sourceLine: getSourceLine(decl),
     };
 }
 function extendsError(node) {
@@ -330,6 +546,7 @@ function parseInterfaceAsContractInterface(node) {
 // ============================================================
 function parseClass(node, filePath, knownStructs = new Map(), knownEnums = new Map(), knownContractInterfaces = new Map(), knownCustomErrors = new Map(), fileFunctions = [], fileConstants = new Map()) {
     const name = node.name?.text ?? "Unknown";
+    const isAbstract = hasModifier(node.modifiers, ts.SyntaxKind.AbstractKeyword);
     const variables = [];
     const functions = [];
     const events = [];
@@ -413,9 +630,48 @@ function parseClass(node, filePath, knownStructs = new Map(), knownEnums = new M
             functions.push(parseSetAccessor(member, varTypes, eventNames));
         }
     }
-    // Inject file level standalone functions as internal helpers
+    // Inject only file level standalone functions that are actually used by this contract.
+    // First, collect function names called directly by class methods, constructor, and variable initializers.
+    const fileFnNames = new Set(fileFunctions.map((f) => f.name));
+    const usedFileFnNames = new Set();
+    const collectFnCalls = (stmts) => {
+        walkStatements(stmts, (expr) => {
+            if (expr.kind === "call" && expr.callee.kind === "identifier" && fileFnNames.has(expr.callee.name)) {
+                usedFileFnNames.add(expr.callee.name);
+            }
+        });
+    };
+    for (const f of functions)
+        collectFnCalls(f.body);
+    if (ctor)
+        collectFnCalls(ctor.body);
+    for (const v of variables) {
+        if (v.initialValue) {
+            walkStatements([{ kind: "expression", expression: v.initialValue }], (expr) => {
+                if (expr.kind === "call" && expr.callee.kind === "identifier" && fileFnNames.has(expr.callee.name)) {
+                    usedFileFnNames.add(expr.callee.name);
+                }
+            });
+        }
+    }
+    // Transitively include file functions called by other used file functions
+    let fnChanged = true;
+    while (fnChanged) {
+        fnChanged = false;
+        for (const fn of fileFunctions) {
+            if (!usedFileFnNames.has(fn.name))
+                continue;
+            walkStatements(fn.body, (expr) => {
+                if (expr.kind === "call" && expr.callee.kind === "identifier" && fileFnNames.has(expr.callee.name) && !usedFileFnNames.has(expr.callee.name)) {
+                    usedFileFnNames.add(expr.callee.name);
+                    fnChanged = true;
+                }
+            });
+        }
+    }
     for (const fn of fileFunctions) {
-        // Avoid duplicates if a class method already has the same name
+        if (!usedFileFnNames.has(fn.name))
+            continue;
         if (!functions.some((f) => f.name === fn.name)) {
             functions.push(fn);
         }
@@ -436,13 +692,92 @@ function parseClass(node, filePath, knownStructs = new Map(), knownEnums = new M
             }
         }
     }
+    // Determine which structs and enums are actually referenced by this contract
+    const usedStructNames = new Set();
+    const usedEnumNames = new Set();
+    const collectTypeRef = (type) => {
+        if (!type)
+            return;
+        if (type.kind === "struct" && type.structName)
+            usedStructNames.add(type.structName);
+        if (type.kind === "enum" && type.structName)
+            usedEnumNames.add(type.structName);
+        if (type.keyType)
+            collectTypeRef(type.keyType);
+        if (type.valueType)
+            collectTypeRef(type.valueType);
+        if (type.tupleTypes)
+            for (const t of type.tupleTypes)
+                collectTypeRef(t);
+        // Include struct field types transitively
+        if (type.structFields)
+            for (const f of type.structFields)
+                collectTypeRef(f.type);
+    };
+    const collectBodyTypeRefs = (stmts) => {
+        walkStatements(stmts, (expr) => {
+            // Enum member access: Color.Red
+            if (expr.kind === "property-access" && expr.object.kind === "identifier" && knownEnums.has(expr.object.name)) {
+                usedEnumNames.add(expr.object.name);
+            }
+            // Type arguments on call expressions (e.g. contract interface casts)
+            if (expr.kind === "call" && expr.typeArgs) {
+                for (const t of expr.typeArgs)
+                    collectTypeRef(t);
+            }
+        }, (stmt) => {
+            if (stmt.kind === "variable-declaration" && stmt.type)
+                collectTypeRef(stmt.type);
+            if (stmt.kind === "try-catch" && stmt.returnType)
+                collectTypeRef(stmt.returnType);
+        });
+    };
+    for (const v of variables) {
+        collectTypeRef(v.type);
+        if (v.initialValue)
+            collectBodyTypeRefs([{ kind: "expression", expression: v.initialValue }]);
+    }
+    for (const f of functions) {
+        for (const p of f.parameters)
+            collectTypeRef(p.type);
+        if (f.returnType)
+            collectTypeRef(f.returnType);
+        collectBodyTypeRefs(f.body);
+    }
+    if (ctor) {
+        for (const p of ctor.parameters)
+            collectTypeRef(p.type);
+        collectBodyTypeRefs(ctor.body);
+    }
+    for (const e of events) {
+        for (const p of e.parameters)
+            collectTypeRef(p.type);
+    }
+    // Transitively include structs whose fields reference other structs/enums
+    let typeChanged = true;
+    while (typeChanged) {
+        typeChanged = false;
+        for (const sName of usedStructNames) {
+            const fields = knownStructs.get(sName);
+            if (!fields)
+                continue;
+            for (const field of fields) {
+                const sizeBefore = usedStructNames.size + usedEnumNames.size;
+                collectTypeRef(field.type);
+                if (usedStructNames.size + usedEnumNames.size > sizeBefore)
+                    typeChanged = true;
+            }
+        }
+    }
     const contractStructs = [];
     for (const [sName, fields] of knownStructs) {
-        contractStructs.push({ name: sName, fields });
+        if (usedStructNames.has(sName))
+            contractStructs.push({ name: sName, fields });
     }
     const contractEnums = [];
     for (const [eName, members] of knownEnums) {
-        contractEnums.push({ name: eName, members });
+        if (usedEnumNames.has(eName))
+            contractEnums.push({ name: eName, members });
     }
     // Determine which interfaces this contract actually references
     const usedIfaceNames = new Set();
@@ -458,10 +793,12 @@ function parseClass(node, filePath, knownStructs = new Map(), knownEnums = new M
             collectContractInterfaceTypeRefs(p.type, usedIfaceNames);
         if (f.returnType)
             collectContractInterfaceTypeRefs(f.returnType, usedIfaceNames);
+        collectBodyContractInterfaceRefs(f.body, usedIfaceNames);
     }
     if (ctor) {
         for (const p of ctor.parameters)
             collectContractInterfaceTypeRefs(p.type, usedIfaceNames);
+        collectBodyContractInterfaceRefs(ctor.body, usedIfaceNames);
     }
     // Deep copy only used interfaces so mutability updates don't leak to shared state
     const contractIfaceList = [];
@@ -530,6 +867,8 @@ function parseClass(node, filePath, knownStructs = new Map(), knownEnums = new M
         customErrors: contractCustomErrors,
         ctor,
         inherits,
+        isAbstract,
+        sourceLine: getSourceLine(node),
     };
 }
 // ============================================================
@@ -545,11 +884,11 @@ function tryParseEvent(node) {
         return null;
     const name = node.name && ts.isIdentifier(node.name) ? node.name.text : "Unknown";
     if (!node.type.typeArguments || node.type.typeArguments.length === 0) {
-        return { name, parameters: [] };
+        return { name, parameters: [], sourceLine: getSourceLine(node) };
     }
     const typeArg = node.type.typeArguments[0];
     if (!ts.isTypeLiteralNode(typeArg)) {
-        return { name, parameters: [] };
+        return { name, parameters: [], sourceLine: getSourceLine(node) };
     }
     const parameters = [];
     for (const member of typeArg.members) {
@@ -574,7 +913,7 @@ function tryParseEvent(node) {
             parameters.push({ name: paramName, type: paramType, indexed });
         }
     }
-    return { name, parameters };
+    return { name, parameters, sourceLine: getSourceLine(node) };
 }
 // ============================================================
 // Error detection (SkittlesError<{...}>)
@@ -629,49 +968,54 @@ function parseProperty(node) {
             initialValue = parseExpression(node.initializer);
         }
     }
-    return { name, type, visibility, immutable, constant, initialValue };
+    return { name, type, visibility, immutable, constant, initialValue, sourceLine: getSourceLine(node) };
 }
 function parseMethod(node, varTypes, eventNames) {
     const name = node.name && ts.isIdentifier(node.name) ? node.name.text : "unknown";
     const parameters = node.parameters.map(parseParameter);
+    setupStringTracking(parameters, varTypes);
     const returnType = node.type
         ? parseType(node.type)
         : null;
     const visibility = getVisibility(node.modifiers);
+    const isAbstractMethod = hasModifier(node.modifiers, ts.SyntaxKind.AbstractKeyword);
     const body = node.body ? parseBlock(node.body, varTypes, eventNames) : [];
-    const stateMutability = inferStateMutability(body, varTypes);
+    const stateMutability = isAbstractMethod ? inferAbstractStateMutability() : inferStateMutability(body, varTypes, parameters);
     const isOverride = hasModifier(node.modifiers, ts.SyntaxKind.OverrideKeyword);
     const isVirtual = !isOverride;
-    return { name, parameters, returnType, visibility, stateMutability, isVirtual, isOverride, body };
+    return { name, parameters, returnType, visibility, stateMutability, isVirtual, isOverride, isAbstract: isAbstractMethod ? true : undefined, body, sourceLine: getSourceLine(node) };
 }
 function parseGetAccessor(node, varTypes, eventNames) {
     const name = node.name && ts.isIdentifier(node.name) ? node.name.text : "unknown";
     const parameters = [];
+    setupStringTracking(parameters, varTypes);
     const returnType = node.type
         ? parseType(node.type)
         : null;
     const visibility = getVisibility(node.modifiers);
     const body = node.body ? parseBlock(node.body, varTypes, eventNames) : [];
-    const stateMutability = inferStateMutability(body, varTypes);
+    const stateMutability = inferStateMutability(body, varTypes, parameters);
     const isOverride = hasModifier(node.modifiers, ts.SyntaxKind.OverrideKeyword);
     const isVirtual = !isOverride;
-    return { name, parameters, returnType, visibility, stateMutability, isVirtual, isOverride, body };
+    return { name, parameters, returnType, visibility, stateMutability, isVirtual, isOverride, body, sourceLine: getSourceLine(node) };
 }
 function parseSetAccessor(node, varTypes, eventNames) {
     const name = node.name && ts.isIdentifier(node.name) ? node.name.text : "unknown";
     const parameters = node.parameters.map(parseParameter);
+    setupStringTracking(parameters, varTypes);
     const returnType = null; // setters don't return
     const visibility = getVisibility(node.modifiers);
     const body = node.body ? parseBlock(node.body, varTypes, eventNames) : [];
-    const stateMutability = inferStateMutability(body, varTypes);
+    const stateMutability = inferStateMutability(body, varTypes, parameters);
     const isOverride = hasModifier(node.modifiers, ts.SyntaxKind.OverrideKeyword);
     const isVirtual = !isOverride;
-    return { name, parameters, returnType, visibility, stateMutability, isVirtual, isOverride, body };
+    return { name, parameters, returnType, visibility, stateMutability, isVirtual, isOverride, body, sourceLine: getSourceLine(node) };
 }
 function parseArrowProperty(node, varTypes, eventNames) {
     const name = node.name && ts.isIdentifier(node.name) ? node.name.text : "unknown";
     const arrow = node.initializer;
     const parameters = arrow.parameters.map(parseParameter);
+    setupStringTracking(parameters, varTypes);
     const returnType = arrow.type
         ? parseType(arrow.type)
         : null;
@@ -686,22 +1030,27 @@ function parseArrowProperty(node, varTypes, eventNames) {
             body = [{ kind: "return", value: parseExpression(arrow.body) }];
         }
     }
-    const stateMutability = inferStateMutability(body, varTypes);
+    const stateMutability = inferStateMutability(body, varTypes, parameters);
     const isOverride = hasModifier(node.modifiers, ts.SyntaxKind.OverrideKeyword);
     const isVirtual = !isOverride;
-    return { name, parameters, returnType, visibility, stateMutability, isVirtual, isOverride, body };
+    return { name, parameters, returnType, visibility, stateMutability, isVirtual, isOverride, body, sourceLine: getSourceLine(node) };
 }
 function parseConstructorDecl(node, varTypes, eventNames) {
     const parameters = node.parameters.map(parseParameter);
+    setupStringTracking(parameters, varTypes);
     const body = node.body ? parseBlock(node.body, varTypes, eventNames) : [];
-    return { parameters, body };
+    return { parameters, body, sourceLine: getSourceLine(node) };
 }
 function parseParameter(node) {
     const name = ts.isIdentifier(node.name) ? node.name.text : "unknown";
     const type = node.type
         ? parseType(node.type)
         : { kind: "uint256" };
-    return { name, type };
+    const param = { name, type };
+    if (node.initializer) {
+        param.defaultValue = parseExpression(node.initializer);
+    }
+    return param;
 }
 // ============================================================
 // Type parsing
@@ -711,7 +1060,7 @@ export function parseType(node) {
         const name = ts.isIdentifier(node.typeName)
             ? node.typeName.text
             : "";
-        if (name === "Record" &&
+        if ((name === "Record" || name === "Map") &&
             node.typeArguments &&
             node.typeArguments.length === 2) {
             return {
@@ -720,6 +1069,14 @@ export function parseType(node) {
                 valueType: parseType(node.typeArguments[1]),
             };
         }
+        if (name === "ReadonlyArray" &&
+            node.typeArguments &&
+            node.typeArguments.length === 1) {
+            return {
+                kind: "array",
+                valueType: parseType(node.typeArguments[0]),
+            };
+        }
         if (name === "address")
             return { kind: "address" };
         if (name === "bytes")
@@ -751,6 +1108,20 @@ export function parseType(node) {
             valueType: parseType(node.elementType),
         };
     }
+    if (ts.isTypeOperatorNode(node) && node.operator === ts.SyntaxKind.ReadonlyKeyword) {
+        return parseType(node.type);
+    }
+    if (ts.isTupleTypeNode(node)) {
+        return {
+            kind: "tuple",
+            tupleTypes: node.elements.map((el) => {
+                if (ts.isNamedTupleMember(el)) {
+                    return parseType(el.type);
+                }
+                return parseType(el);
+            }),
+        };
+    }
     switch (node.kind) {
         case ts.SyntaxKind.NumberKeyword:
             return { kind: "uint256" };
@@ -805,11 +1176,21 @@ export function parseExpression(node) {
         return { kind: "number-literal", value: "0" };
     }
     if (ts.isPropertyAccessExpression(node)) {
-        return {
-            kind: "property-access",
-            object: parseExpression(node.expression),
-            property: node.name.text,
-        };
+        const object = parseExpression(node.expression);
+        const property = node.name.text;
+        // string.length → bytes(str).length
+        if (property === "length" && isStringExpr(object)) {
+            return {
+                kind: "property-access",
+                object: {
+                    kind: "call",
+                    callee: { kind: "identifier", name: "bytes" },
+                    args: [object],
+                },
+                property: "length",
+            };
+        }
+        return { kind: "property-access", object, property };
     }
     if (ts.isElementAccessExpression(node)) {
         return {
@@ -824,6 +1205,21 @@ export function parseExpression(node) {
         if (opKind === ts.SyntaxKind.CommaToken) {
             return parseExpression(node.right);
         }
+        // Desugar **= to x = x ** y (Solidity has no **= operator)
+        if (opKind === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
+            const target = parseExpression(node.left);
+            return {
+                kind: "assignment",
+                operator: "=",
+                target,
+                value: {
+                    kind: "binary",
+                    operator: "**",
+                    left: target,
+                    right: parseExpression(node.right),
+                },
+            };
+        }
         const operator = getBinaryOperator(opKind);
         if (isAssignmentOperator(opKind)) {
             return {
@@ -833,11 +1229,22 @@ export function parseExpression(node) {
                 value: parseExpression(node.right),
             };
         }
+        const left = parseExpression(node.left);
+        const right = parseExpression(node.right);
+        // String comparison: str === other → keccak256(str) == keccak256(other)
+        if ((operator === "==" || operator === "!=") && (isStringExpr(left) || isStringExpr(right))) {
+            return {
+                kind: "binary",
+                operator,
+                left: { kind: "call", callee: { kind: "identifier", name: "keccak256" }, args: [left] },
+                right: { kind: "call", callee: { kind: "identifier", name: "keccak256" }, args: [right] },
+            };
+        }
         return {
             kind: "binary",
             operator,
-            left: parseExpression(node.left),
-            right: parseExpression(node.right),
+            left,
+            right,
         };
     }
     if (ts.isPrefixUnaryExpression(node)) {
@@ -857,11 +1264,26 @@ export function parseExpression(node) {
         };
     }
     if (ts.isCallExpression(node)) {
-        return {
+        const callExpr = {
             kind: "call",
             callee: parseExpression(node.expression),
             args: node.arguments.map(parseExpression),
         };
+        if (node.typeArguments && node.typeArguments.length > 0) {
+            const firstTypeArg = node.typeArguments[0];
+            if (ts.isTupleTypeNode(firstTypeArg)) {
+                callExpr.typeArgs = firstTypeArg.elements.map((elem) => {
+                    if (ts.isNamedTupleMember(elem)) {
+                        return parseType(elem.type);
+                    }
+                    return parseType(elem);
+                });
+            }
+            else {
+                callExpr.typeArgs = node.typeArguments.map((ta) => parseType(ta));
+            }
+        }
+        return callExpr;
     }
     if (ts.isNewExpression(node)) {
         const callee = ts.isIdentifier(node.expression)
@@ -897,6 +1319,13 @@ export function parseExpression(node) {
             whenFalse: parseExpression(node.whenFalse),
         };
     }
+    // Array literal expressions: [a, b, c] → tuple literal
+    if (ts.isArrayLiteralExpression(node)) {
+        return {
+            kind: "tuple-literal",
+            elements: node.elements.map(parseExpression),
+        };
+    }
     // Object literal expressions: { x: 1, y: 2 } → struct construction
     if (ts.isObjectLiteralExpression(node)) {
         const properties = [];
@@ -949,6 +1378,7 @@ export function parseStatement(node, varTypes, eventNames = new Set()) {
             value: node.expression
                 ? parseExpression(node.expression)
                 : undefined,
+            sourceLine: getSourceLine(node),
         };
     }
     if (ts.isVariableStatement(node)) {
@@ -959,17 +1389,27 @@ export function parseStatement(node, varTypes, eventNames = new Set()) {
             ? parseExpression(decl.initializer)
             : undefined;
         const type = explicitType || (initializer ? inferType(initializer, varTypes) : undefined);
-        return { kind: "variable-declaration", name, type, initializer };
+        if (type?.kind === "string") {
+            _currentStringNames.add(name);
+        }
+        return { kind: "variable-declaration", name, type, initializer, sourceLine: getSourceLine(node) };
     }
     if (ts.isExpressionStatement(node)) {
         const emitStmt = tryParseEmitStatement(node.expression, eventNames);
-        if (emitStmt)
+        if (emitStmt) {
+            emitStmt.sourceLine = getSourceLine(node);
             return emitStmt;
+        }
+        const consoleLogStmt = tryParseConsoleLog(node.expression);
+        if (consoleLogStmt) {
+            consoleLogStmt.sourceLine = getSourceLine(node);
+            return consoleLogStmt;
+        }
         // Detect delete expressions: `delete this.mapping[key]`
         if (ts.isDeleteExpression(node.expression)) {
-            return { kind: "delete", target: parseExpression(node.expression.expression) };
+            return { kind: "delete", target: parseExpression(node.expression.expression), sourceLine: getSourceLine(node) };
         }
-        return { kind: "expression", expression: parseExpression(node.expression) };
+        return { kind: "expression", expression: parseExpression(node.expression), sourceLine: getSourceLine(node) };
     }
     if (ts.isIfStatement(node)) {
         const condition = parseExpression(node.expression);
@@ -977,7 +1417,7 @@ export function parseStatement(node, varTypes, eventNames = new Set()) {
         const elseBody = node.elseStatement
             ? parseBlock(node.elseStatement, varTypes, eventNames)
             : undefined;
-        return { kind: "if", condition, thenBody, elseBody };
+        return { kind: "if", condition, thenBody, elseBody, sourceLine: getSourceLine(node) };
     }
     if (ts.isForStatement(node)) {
         let initializer;
@@ -1013,6 +1453,7 @@ export function parseStatement(node, varTypes, eventNames = new Set()) {
                 ? parseExpression(node.incrementor)
                 : undefined,
             body: parseBlock(node.statement, varTypes, eventNames),
+            sourceLine: getSourceLine(node),
         };
     }
     if (ts.isWhileStatement(node)) {
@@ -1020,6 +1461,7 @@ export function parseStatement(node, varTypes, eventNames = new Set()) {
             kind: "while",
             condition: parseExpression(node.expression),
             body: parseBlock(node.statement, varTypes, eventNames),
+            sourceLine: getSourceLine(node),
         };
     }
     if (ts.isDoStatement(node)) {
@@ -1027,13 +1469,14 @@ export function parseStatement(node, varTypes, eventNames = new Set()) {
             kind: "do-while",
             condition: parseExpression(node.expression),
             body: parseBlock(node.statement, varTypes, eventNames),
+            sourceLine: getSourceLine(node),
         };
     }
     if (node.kind === ts.SyntaxKind.BreakStatement) {
-        return { kind: "break" };
+        return { kind: "break", sourceLine: getSourceLine(node) };
     }
     if (node.kind === ts.SyntaxKind.ContinueStatement) {
-        return { kind: "continue" };
+        return { kind: "continue", sourceLine: getSourceLine(node) };
     }
     if (ts.isForOfStatement(node)) {
         // Desugar: for (const item of arr) { ... }
@@ -1083,8 +1526,55 @@ export function parseStatement(node, varTypes, eventNames = new Set()) {
                 prefix: false,
             },
             body: [itemDecl, ...innerBody],
+            sourceLine: getSourceLine(node),
         };
     }
+    if (ts.isForInStatement(node)) {
+        // Desugar: for (const item in EnumType) { ... }
+        // →  for (uint256 _i = 0; _i < memberCount; _i++) { EnumType item = EnumType(_i); ... }
+        const enumName = ts.isIdentifier(node.expression) ? node.expression.text : "";
+        const enumMembers = _knownEnums.get(enumName);
+        if (enumMembers) {
+            const itemName = ts.isVariableDeclarationList(node.initializer)
+                ? (ts.isIdentifier(node.initializer.declarations[0].name) ? node.initializer.declarations[0].name.text : "_item")
+                : "_item";
+            const indexName = `_i_${itemName}`;
+            const innerBody = parseBlock(node.statement, varTypes, eventNames);
+            // Prepend: EnumType item = EnumType(_i);
+            const itemDecl = {
+                kind: "variable-declaration",
+                name: itemName,
+                type: { kind: "enum", structName: enumName },
+                initializer: {
+                    kind: "call",
+                    callee: { kind: "identifier", name: enumName },
+                    args: [{ kind: "identifier", name: indexName }],
+                },
+            };
+            return {
+                kind: "for",
+                initializer: {
+                    kind: "variable-declaration",
+                    name: indexName,
+                    type: { kind: "uint256" },
+                    initializer: { kind: "number-literal", value: "0" },
+                },
+                condition: {
+                    kind: "binary",
+                    operator: "<",
+                    left: { kind: "identifier", name: indexName },
+                    right: { kind: "number-literal", value: String(enumMembers.length) },
+                },
+                incrementor: {
+                    kind: "unary",
+                    operator: "++",
+                    operand: { kind: "identifier", name: indexName },
+                    prefix: false,
+                },
+                body: [itemDecl, ...innerBody],
+            };
+        }
+    }
     if (ts.isSwitchStatement(node)) {
         const discriminant = parseExpression(node.expression);
         const cases = [];
@@ -1104,7 +1594,53 @@ export function parseStatement(node, varTypes, eventNames = new Set()) {
                 cases.push({ value: undefined, body });
             }
         }
-        return { kind: "switch", discriminant, cases };
+        return { kind: "switch", discriminant, cases, sourceLine: getSourceLine(node) };
+    }
+    if (ts.isTryStatement(node)) {
+        const tryBlock = node.tryBlock;
+        const catchClause = node.catchClause;
+        const tryStatements = tryBlock.statements;
+        if (tryStatements.length === 0) {
+            throw new Error("try block must contain at least one statement with an external call");
+        }
+        // The first statement must be an external call (either variable declaration or expression)
+        const firstStmt = tryStatements[0];
+        let call;
+        let returnVarName;
+        let returnType;
+        if (ts.isVariableStatement(firstStmt)) {
+            const decl = firstStmt.declarationList.declarations[0];
+            returnVarName = ts.isIdentifier(decl.name) ? decl.name.text : undefined;
+            returnType = decl.type ? parseType(decl.type) : undefined;
+            if (decl.initializer) {
+                call = parseExpression(decl.initializer);
+                if (!returnType) {
+                    returnType = inferType(call, varTypes);
+                }
+            }
+            else {
+                throw new Error("try block variable declaration must have an initializer with an external call");
+            }
+        }
+        else if (ts.isExpressionStatement(firstStmt)) {
+            call = parseExpression(firstStmt.expression);
+        }
+        else {
+            throw new Error("First statement in try block must be an external call");
+        }
+        // Remaining statements become success body
+        const successBody = [];
+        for (let i = 1; i < tryStatements.length; i++) {
+            successBody.push(...parseStatements(tryStatements[i], varTypes, eventNames));
+        }
+        // Parse catch body
+        const catchBody = [];
+        if (catchClause && catchClause.block) {
+            for (const stmt of catchClause.block.statements) {
+                catchBody.push(...parseStatements(stmt, varTypes, eventNames));
+            }
+        }
+        return { kind: "try-catch", call, returnVarName, returnType, successBody, catchBody };
     }
     if (ts.isThrowStatement(node)) {
         // Pattern: throw new ErrorName(args) (class extends Error style)
@@ -1116,14 +1652,14 @@ export function parseStatement(node, varTypes, eventNames = new Set()) {
                 const args = node.expression.arguments
                     ? Array.from(node.expression.arguments).map(parseExpression)
                     : [];
-                return { kind: "revert", customError: errorName, customErrorArgs: args };
+                return { kind: "revert", customError: errorName, customErrorArgs: args, sourceLine: getSourceLine(node) };
             }
             let message;
             if (node.expression.arguments &&
                 node.expression.arguments.length > 0) {
                 message = parseExpression(node.expression.arguments[0]);
             }
-            return { kind: "revert", message };
+            return { kind: "revert", message, sourceLine: getSourceLine(node) };
         }
         // Pattern: throw this.ErrorName(args) (SkittlesError property style)
         if (node.expression && ts.isCallExpression(node.expression)) {
@@ -1133,11 +1669,11 @@ export function parseStatement(node, varTypes, eventNames = new Set()) {
                 const errorName = callee.name.text;
                 if (_knownCustomErrors.has(errorName)) {
                     const args = node.expression.arguments.map(parseExpression);
-                    return { kind: "revert", customError: errorName, customErrorArgs: args };
+                    return { kind: "revert", customError: errorName, customErrorArgs: args, sourceLine: getSourceLine(node) };
                 }
             }
         }
-        return { kind: "revert" };
+        return { kind: "revert", sourceLine: getSourceLine(node) };
     }
     throw new Error(`Unsupported statement: ${ts.SyntaxKind[node.kind]}`);
 }
@@ -1155,6 +1691,7 @@ function parseStatements(node, varTypes, eventNames) {
     if (ts.isVariableStatement(node)) {
         // Multi declaration: let a=1, b=2, c=3
         if (node.declarationList.declarations.length > 1) {
+            const sl = getSourceLine(node);
             return node.declarationList.declarations.map((decl) => {
                 const name = ts.isIdentifier(decl.name) ? decl.name.text : "unknown";
                 const explicitType = decl.type ? parseType(decl.type) : undefined;
@@ -1162,7 +1699,10 @@ function parseStatements(node, varTypes, eventNames) {
                     ? parseExpression(decl.initializer)
                     : undefined;
                 const type = explicitType || (initializer ? inferType(initializer, varTypes) : undefined);
-                return { kind: "variable-declaration", name, type, initializer };
+                if (type?.kind === "string") {
+                    _currentStringNames.add(name);
+                }
+                return { kind: "variable-declaration", name, type, initializer, sourceLine: sl };
             });
         }
         // Array destructuring: const [a, b, c] = [7, 8, 9]
@@ -1170,6 +1710,10 @@ function parseStatements(node, varTypes, eventNames) {
         if (decl.name && ts.isArrayBindingPattern(decl.name) && decl.initializer) {
             return parseArrayDestructuring(decl.name, decl.initializer, varTypes);
         }
+        // Object destructuring: const { a, b } = { a: 1, b: 2 }
+        if (decl.name && ts.isObjectBindingPattern(decl.name) && decl.initializer) {
+            return parseObjectDestructuring(decl.name, decl.initializer, varTypes, decl);
+        }
     }
     return [parseStatement(node, varTypes, eventNames)];
 }
@@ -1211,6 +1755,23 @@ function tryParseEmitStatement(node, eventNames) {
     return { kind: "emit", eventName, args };
 }
 // ============================================================
+// Console.log detection: console.log(args)
+// ============================================================
+function tryParseConsoleLog(node) {
+    if (!ts.isCallExpression(node))
+        return null;
+    const callee = node.expression;
+    if (!ts.isPropertyAccessExpression(callee))
+        return null;
+    if (callee.name.text !== "log")
+        return null;
+    const obj = callee.expression;
+    if (!ts.isIdentifier(obj) || obj.text !== "console")
+        return null;
+    const args = node.arguments.map(parseExpression);
+    return { kind: "console-log", args };
+}
+// ============================================================
 // State mutability inference
 // ============================================================
 /**
@@ -1344,6 +1905,14 @@ function walkStatements(stmts, onExpr, onStmt) {
             case "delete":
                 walkExpr(stmt.target);
                 break;
+            case "try-catch":
+                walkExpr(stmt.call);
+                stmt.successBody.forEach(walkStmt);
+                stmt.catchBody.forEach(walkStmt);
+                break;
+            case "console-log":
+                stmt.args.forEach(walkExpr);
+                break;
         }
     }
     stmts.forEach(walkStmt);
@@ -1360,13 +1929,31 @@ function collectThisCalls(stmts) {
     });
     return names;
 }
-export function inferStateMutability(body, varTypes) {
+function inferAbstractStateMutability() {
+    return "nonpayable";
+}
+export function inferStateMutability(body, varTypes, params) {
     let readsState = false;
     let writesState = false;
     let usesMsgValue = false;
+    let readsEnvironment = false;
+    const thisCallCallees = new Set();
+    // Track local variable types for detecting external contract calls on locals
+    const localVarTypes = new Map();
+    if (params) {
+        for (const p of params) {
+            localVarTypes.set(p.name, p.type);
+        }
+    }
     walkStatements(body, (expr) => {
+        if (expr.kind === "call" &&
+            expr.callee.kind === "property-access" &&
+            expr.callee.object.kind === "identifier" &&
+            expr.callee.object.name === "this") {
+            thisCallCallees.add(expr.callee);
+        }
         if (expr.kind === "property-access") {
-            if (expr.object.kind === "identifier" && expr.object.name === "this") {
+            if (expr.object.kind === "identifier" && expr.object.name === "this" && !thisCallCallees.has(expr)) {
                 readsState = true;
             }
             if (expr.object.kind === "identifier" &&
@@ -1374,6 +1961,24 @@ export function inferStateMutability(body, varTypes) {
                 expr.property === "value") {
                 usesMsgValue = true;
             }
+            // EVM environment reads: msg.sender, msg.data, msg.sig, block.*, tx.*
+            // (msg.value is excluded here because it is handled separately as payable)
+            if (expr.object.kind === "identifier" &&
+                ((expr.object.name === "msg" && expr.property !== "value") ||
+                    expr.object.name === "block" ||
+                    expr.object.name === "tx")) {
+                readsEnvironment = true;
+            }
+        }
+        // `self` reads the contract's own address (address(this))
+        if (expr.kind === "identifier" && expr.name === "self") {
+            readsEnvironment = true;
+        }
+        // `gasleft()` reads remaining gas from the environment
+        if (expr.kind === "call" &&
+            expr.callee.kind === "identifier" &&
+            expr.callee.name === "gasleft") {
+            readsEnvironment = true;
         }
         if (expr.kind === "assignment" && isStateAccess(expr.target)) {
             writesState = true;
@@ -1386,9 +1991,21 @@ export function inferStateMutability(body, varTypes) {
         if (expr.kind === "call" && isStateMutatingCall(expr)) {
             writesState = true;
         }
+        // addr.transfer(amount) sends ETH, which is state-mutating
+        // Only match when the receiver is not `this` and not a contract-interface variable
+        if (expr.kind === "call" &&
+            expr.callee.kind === "property-access" &&
+            expr.callee.property === "transfer" &&
+            expr.args.length === 1 &&
+            !isContractInterfaceReceiver(expr.callee.object, varTypes, localVarTypes)) {
+            writesState = true;
+        }
         if (expr.kind === "call" && varTypes && isExternalContractCall(expr, varTypes)) {
             writesState = true;
         }
+        if (expr.kind === "call" && isExternalContractCallOnLocal(expr, localVarTypes)) {
+            writesState = true;
+        }
     }, (stmt) => {
         if (stmt.kind === "emit") {
             writesState = true;
@@ -1396,12 +2013,16 @@ export function inferStateMutability(body, varTypes) {
         if (stmt.kind === "delete" && isStateAccess(stmt.target)) {
             writesState = true;
         }
+        if (stmt.kind === "variable-declaration" && stmt.type &&
+            stmt.type.kind === "contract-interface" && stmt.name) {
+            localVarTypes.set(stmt.name, stmt.type);
+        }
     });
     if (usesMsgValue)
         return "payable";
     if (writesState)
         return "nonpayable";
-    if (readsState)
+    if (readsState || readsEnvironment)
         return "view";
     return "pure";
 }
@@ -1480,6 +2101,29 @@ function collectContractInterfaceTypeRefs(type, refs) {
     if (type.valueType)
         collectContractInterfaceTypeRefs(type.valueType, refs);
 }
+function collectBodyContractInterfaceRefs(stmts, refs) {
+    for (const stmt of stmts) {
+        if (stmt.kind === "variable-declaration" && stmt.type) {
+            collectContractInterfaceTypeRefs(stmt.type, refs);
+        }
+        if (stmt.kind === "if") {
+            collectBodyContractInterfaceRefs(stmt.thenBody, refs);
+            if (stmt.elseBody)
+                collectBodyContractInterfaceRefs(stmt.elseBody, refs);
+        }
+        if (stmt.kind === "for" || stmt.kind === "while" || stmt.kind === "do-while") {
+            collectBodyContractInterfaceRefs(stmt.body, refs);
+        }
+        if (stmt.kind === "switch") {
+            for (const c of stmt.cases)
+                collectBodyContractInterfaceRefs(c.body, refs);
+        }
+        if (stmt.kind === "try-catch") {
+            collectBodyContractInterfaceRefs(stmt.successBody, refs);
+            collectBodyContractInterfaceRefs(stmt.catchBody, refs);
+        }
+    }
+}
 function isStateAccess(expr) {
     if (expr.kind === "property-access" &&
         expr.object.kind === "identifier" &&
@@ -1504,6 +2148,18 @@ function isExternalContractCall(expr, varTypes) {
     }
     return false;
 }
+function isExternalContractCallOnLocal(expr, localVarTypes) {
+    if (expr.callee.kind === "property-access" &&
+        expr.callee.object.kind === "identifier" &&
+        expr.callee.object.name !== "this") {
+        const varName = expr.callee.object.name;
+        const varType = localVarTypes.get(varName);
+        if (varType && varType.kind === "contract-interface") {
+            return true;
+        }
+    }
+    return false;
+}
 function isStateMutatingCall(expr) {
     if (expr.callee.kind !== "property-access")
         return false;
@@ -1512,6 +2168,34 @@ function isStateMutatingCall(expr) {
         return false;
     return isStateAccess(expr.callee.object);
 }
+/**
+ * Check if the receiver of a property-access is `this` or a contract-interface typed variable.
+ * Used to distinguish `addr.transfer(amount)` (ETH transfer) from
+ * `this.transfer(...)` or `token.transfer(...)` (contract method calls).
+ */
+function isContractInterfaceReceiver(receiver, varTypes, localVarTypes) {
+    // this.transfer(...) is an internal contract call
+    if (receiver.kind === "identifier" && receiver.name === "this")
+        return true;
+    // this.token.transfer(...) where token is a contract-interface state variable
+    if (receiver.kind === "property-access" &&
+        receiver.object.kind === "identifier" &&
+        receiver.object.name === "this") {
+        const propType = varTypes?.get(receiver.property);
+        if (propType && propType.kind === "contract-interface")
+            return true;
+    }
+    // token.transfer(...) where token is a contract-interface local/param
+    if (receiver.kind === "identifier") {
+        const localType = localVarTypes?.get(receiver.name);
+        if (localType && localType.kind === "contract-interface")
+            return true;
+        const stateType = varTypes?.get(receiver.name);
+        if (stateType && stateType.kind === "contract-interface")
+            return true;
+    }
+    return false;
+}
 function getVisibility(modifiers) {
     if (!modifiers)
         return "public";