skittles 1.2.7 → 1.3.1

package/dist/compiler/codegen.js

@@ -11,10 +11,17 @@ export function generateSolidityFile(contracts, imports) {
     parts.push("// SPDX-License-Identifier: MIT");
     parts.push("pragma solidity ^0.8.20;");
     parts.push("");
+    // Add Hardhat console import if any contract uses console.log
+    const needsConsoleImport = contracts.some(contractUsesConsoleLog);
+    if (needsConsoleImport) {
+        parts.push('import "hardhat/console.sol";');
+    }
     if (imports && imports.length > 0) {
         for (const imp of imports) {
             parts.push(`import "${imp}";`);
         }
+    }
+    if (needsConsoleImport || (imports && imports.length > 0)) {
         parts.push("");
     }
     // Collect and deduplicate contract interfaces across all contracts
@@ -63,8 +70,36 @@ export function generateSolidityFile(contracts, imports) {
         parts.push(generateInterfaceDecl(iface));
         parts.push("");
     }
+    // Build per-contract ancestor sets so deduplication only applies when the
+    // current contract inherits from the contract that first emitted a definition.
+    const contractByName = new Map(contracts.map((c) => [c.name, c]));
+    const ancestorsMap = new Map();
+    for (const contract of contracts) {
+        const ancestors = new Set();
+        const queue = [...contract.inherits.filter((n) => contractByName.has(n))];
+        let queueIndex = 0;
+        while (queueIndex < queue.length) {
+            const name = queue[queueIndex++];
+            if (ancestors.has(name))
+                continue;
+            ancestors.add(name);
+            const parent = contractByName.get(name);
+            if (parent) {
+                for (const gp of parent.inherits) {
+                    if (contractByName.has(gp))
+                        queue.push(gp);
+                }
+            }
+        }
+        ancestorsMap.set(contract.name, ancestors);
+    }
+    // Track all contracts that emitted each definition / function so child
+    // contracts that inherit from any of those origins can skip re-emission.
+    const definitionOrigins = new Map();
+    const functionOrigins = new Map();
     for (let i = 0; i < contracts.length; i++) {
-        parts.push(generateContractBody(contracts[i], emittedFileScopeTypes));
+        const ancestors = ancestorsMap.get(contracts[i].name);
+        parts.push(generateContractBody(contracts[i], emittedFileScopeTypes, definitionOrigins, functionOrigins, ancestors));
         if (i < contracts.length - 1) {
             parts.push("");
         }
@@ -75,28 +110,49 @@ export function generateSolidityFile(contracts, imports) {
 export function generateSolidity(contract, imports) {
     return generateSolidityFile([contract], imports);
 }
-function generateContractBody(contract, fileScopeTypes = new Set()) {
+function generateContractBody(contract, fileScopeTypes = new Set(), definitionOrigins = new Map(), functionOrigins = new Map(), ancestors = new Set()) {
     const parts = [];
     const inheritance = contract.inherits.length > 0
         ? ` is ${contract.inherits.join(", ")}`
         : "";
-    parts.push(`contract ${contract.name}${inheritance} {`);
+    const abstractPrefix = contract.isAbstract ? "abstract " : "";
+    parts.push(`${abstractPrefix}contract ${contract.name}${inheritance} {`);
+    const hasAncestorOrigin = (origins) => origins !== undefined && Array.from(origins).some((o) => ancestors.has(o));
+    const addOrigin = (map, key) => {
+        let origins = map.get(key);
+        if (!origins) {
+            origins = new Set();
+            map.set(key, origins);
+        }
+        origins.add(contract.name);
+    };
     for (const en of contract.enums ?? []) {
         if (fileScopeTypes.has(en.name))
             continue;
+        if (hasAncestorOrigin(definitionOrigins.get(en.name)))
+            continue;
+        addOrigin(definitionOrigins, en.name);
         parts.push(`    enum ${en.name} { ${en.members.join(", ")} }`);
         parts.push("");
     }
+    let emittedCustomErrorCount = 0;
     for (const ce of contract.customErrors ?? []) {
+        if (hasAncestorOrigin(definitionOrigins.get(ce.name)))
+            continue;
+        addOrigin(definitionOrigins, ce.name);
         const params = ce.parameters.map((p) => `${generateType(p.type)} ${p.name}`).join(", ");
         parts.push(`    error ${ce.name}(${params});`);
+        emittedCustomErrorCount++;
     }
-    if ((contract.customErrors ?? []).length > 0) {
+    if (emittedCustomErrorCount > 0) {
         parts.push("");
     }
     for (const s of contract.structs ?? []) {
         if (fileScopeTypes.has(s.name))
             continue;
+        if (hasAncestorOrigin(definitionOrigins.get(s.name)))
+            continue;
+        addOrigin(definitionOrigins, s.name);
         parts.push(generateStructDecl(s));
         parts.push("");
     }
@@ -109,19 +165,43 @@ function generateContractBody(contract, fileScopeTypes = new Set()) {
     for (const v of contract.variables) {
         parts.push(`    ${generateVariable(v)}`);
     }
+    const readonlyArrayVars = contract.variables.filter((v) => v.immutable && v.type.kind === SkittlesTypeKind.Array);
+    // Skip functions already emitted by an ancestor contract in the same file
+    // (shared file-level functions injected into both parent and child), unless
+    // the child explicitly overrides them.  Use a full signature key (name +
+    // full parameter types) so overloads are not incorrectly suppressed.
+    const getFunctionKey = (f) => {
+        const paramTypes = f.parameters
+            .map((p) => (p.type ? generateType(p.type) : "unknown"))
+            .join(",");
+        return `${f.name}(${paramTypes})`;
+    };
+    const functionsToEmit = contract.functions.filter((f) => {
+        const key = getFunctionKey(f);
+        return !hasAncestorOrigin(functionOrigins.get(key)) || f.isOverride;
+    });
+    for (const f of functionsToEmit) {
+        addOrigin(functionOrigins, getFunctionKey(f));
+    }
     if (contract.variables.length > 0 &&
-        (contract.ctor || contract.functions.length > 0)) {
+        (contract.ctor || functionsToEmit.length > 0 || readonlyArrayVars.length > 0)) {
         parts.push("");
     }
     if (contract.ctor) {
-        parts.push(generateConstructor(contract.ctor));
-        if (contract.functions.length > 0) {
+        parts.push(generateConstructor(contract.ctor, contract.inherits));
+        if (functionsToEmit.length > 0 || readonlyArrayVars.length > 0) {
             parts.push("");
         }
     }
-    for (let i = 0; i < contract.functions.length; i++) {
-        parts.push(generateFunction(contract.functions[i]));
-        if (i < contract.functions.length - 1) {
+    for (let i = 0; i < functionsToEmit.length; i++) {
+        parts.push(generateFunction(functionsToEmit[i]));
+        if (i < functionsToEmit.length - 1 || readonlyArrayVars.length > 0) {
+            parts.push("");
+        }
+    }
+    for (let i = 0; i < readonlyArrayVars.length; i++) {
+        parts.push(generateReadonlyArrayGetter(readonlyArrayVars[i]));
+        if (i < readonlyArrayVars.length - 1) {
             parts.push("");
         }
     }
@@ -165,6 +245,11 @@ function collectReferencedTypeNames(type, structs, enums) {
         collectReferencedTypeNames(type.keyType, structs, enums);
         collectReferencedTypeNames(type.valueType, structs, enums);
     }
+    else if (type.kind === SkittlesTypeKind.Tuple && type.tupleTypes) {
+        for (const t of type.tupleTypes) {
+            collectReferencedTypeNames(t, structs, enums);
+        }
+    }
 }
 function generateInterfaceDecl(iface) {
     const lines = [];
@@ -178,7 +263,13 @@ function generateInterfaceDecl(iface) {
             : "";
         let returns = "";
         if (f.returnType && f.returnType.kind !== SkittlesTypeKind.Void) {
-            returns = ` returns (${generateParamType(f.returnType)})`;
+            if (f.returnType.kind === SkittlesTypeKind.Tuple) {
+                const tupleParams = (f.returnType.tupleTypes ?? []).map(generateParamType).join(", ");
+                returns = ` returns (${tupleParams})`;
+            }
+            else {
+                returns = ` returns (${generateParamType(f.returnType)})`;
+            }
         }
         lines.push(`    function ${f.name}(${params}) external${mut}${returns};`);
     }
@@ -205,7 +296,8 @@ function isValueType(type) {
 }
 function generateVariable(v) {
     const type = generateType(v.type);
-    const vis = mapVisibility(v.visibility);
+    const isReadonlyArray = v.immutable && v.type.kind === SkittlesTypeKind.Array;
+    const vis = isReadonlyArray ? "internal" : mapVisibility(v.visibility);
     let modifier = "";
     if (v.constant) {
         modifier = " constant";
@@ -223,6 +315,16 @@ function generateVariable(v) {
     }
     return `${type} ${vis}${modifier}${overrideStr} ${v.name};`;
 }
+function generateReadonlyArrayGetter(v) {
+    const type = generateType(v.type);
+    const name = v.name;
+    const getterName = `get${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+    const lines = [];
+    lines.push(`    function ${getterName}() public view returns (${type} memory) {`);
+    lines.push(`        return ${name};`);
+    lines.push("    }");
+    return lines.join("\n");
+}
 function generateFunction(f) {
     if (f.name === "receive") {
         const lines = [];
@@ -250,23 +352,73 @@ function generateFunction(f) {
     const virtOverride = f.isOverride ? " override" : f.isVirtual ? " virtual" : "";
     let returns = "";
     if (f.returnType && f.returnType.kind !== SkittlesTypeKind.Void) {
-        returns = ` returns (${generateParamType(f.returnType)})`;
+        if (f.returnType.kind === SkittlesTypeKind.Tuple) {
+            const tupleParams = (f.returnType.tupleTypes ?? []).map(generateParamType).join(", ");
+            returns = ` returns (${tupleParams})`;
+        }
+        else {
+            returns = ` returns (${generateParamType(f.returnType)})`;
+        }
     }
     const lines = [];
-    lines.push(`    function ${f.name}(${params}) ${vis}${mut}${virtOverride}${returns} {`);
-    for (const s of f.body) {
-        lines.push(generateStatement(s, "        "));
+    if (f.isAbstract) {
+        lines.push(`    function ${f.name}(${params}) ${vis}${mut}${virtOverride}${returns};`);
+    }
+    else {
+        lines.push(`    function ${f.name}(${params}) ${vis}${mut}${virtOverride}${returns} {`);
+        for (const s of f.body) {
+            lines.push(generateStatement(s, "        "));
+        }
+        lines.push("    }");
     }
-    lines.push("    }");
     return lines.join("\n");
 }
-function generateConstructor(c) {
-    const params = c.parameters
+function isSuperCall(stmt) {
+    return (stmt.kind === "expression" &&
+        stmt.expression.kind === "call" &&
+        stmt.expression.callee.kind === "identifier" &&
+        stmt.expression.callee.name === "super");
+}
+function getSuperCallArgs(stmt) {
+    if (stmt.kind === "expression" &&
+        stmt.expression.kind === "call" &&
+        stmt.expression.callee.kind === "identifier" &&
+        stmt.expression.callee.name === "super") {
+        return stmt.expression.args;
+    }
+    return null;
+}
+function generateConstructor(c, inherits = []) {
+    const regularParams = c.parameters.filter((p) => !p.defaultValue);
+    const defaultParams = c.parameters.filter((p) => p.defaultValue);
+    const params = regularParams
         .map((p) => `${generateParamType(p.type)} ${p.name}`)
         .join(", ");
+    // Extract super() call(s) from the body and validate.
+    const superCalls = c.body.filter(isSuperCall);
+    if (superCalls.length > 1) {
+        throw new Error("Constructor contains multiple super() calls, but only one is allowed");
+    }
+    const bodyWithoutSuper = c.body.filter((s) => !isSuperCall(s));
+    let parentModifier = "";
+    if (superCalls.length === 1) {
+        const args = getSuperCallArgs(superCalls[0]);
+        if (args.length > 0) {
+            if (inherits.length === 0) {
+                throw new Error("Constructor contains a super(...) call, but no parent contract is specified in 'inherits'");
+            }
+            if (defaultParams.length > 0) {
+                throw new Error("super(...) with constructor parameters that have default values is not supported");
+            }
+            parentModifier = ` ${inherits[0]}(${args.map(generateExpression).join(", ")})`;
+        }
+    }
     const lines = [];
-    lines.push(`    constructor(${params}) {`);
-    for (const s of c.body) {
+    lines.push(`    constructor(${params})${parentModifier} {`);
+    for (const p of defaultParams) {
+        lines.push(`        ${generateParamType(p.type)} ${p.name} = ${generateExpression(p.defaultValue)};`);
+    }
+    for (const s of bodyWithoutSuper) {
         lines.push(generateStatement(s, "        "));
     }
     lines.push("    }");
@@ -301,6 +453,8 @@ export function generateType(type) {
             return type.structName ?? "UnknownInterface";
         case SkittlesTypeKind.Enum:
             return type.structName ?? "UnknownEnum";
+        case SkittlesTypeKind.Tuple:
+            return `(${(type.tupleTypes ?? []).map(generateType).join(", ")})`;
         case SkittlesTypeKind.Void:
             return "";
         default:
@@ -382,6 +536,16 @@ export function generateExpression(expr) {
             const callResult = tryGenerateBuiltinCall(expr);
             if (callResult)
                 return callResult;
+            // addr.transfer(amount) → payable(addr).transfer(amount)
+            // Exclude this.transfer(...) (internal call) and this.stateVar.transfer(...)
+            // (external contract interface call) to avoid misclassifying non-ETH transfers.
+            if (expr.callee.kind === "property-access" &&
+                expr.callee.property === "transfer" &&
+                expr.args.length === 1 &&
+                !isThisOrContractCall(expr.callee.object)) {
+                const addr = generateExpression(expr.callee.object);
+                return `payable(${addr}).transfer(${generateExpression(expr.args[0])})`;
+            }
             return `${generateExpression(expr.callee)}(${expr.args.map(generateExpression).join(", ")})`;
         }
         case "conditional":
@@ -392,6 +556,8 @@ export function generateExpression(expr) {
             const values = expr.properties.map((p) => generateExpression(p.value)).join(", ");
             return values;
         }
+        case "tuple-literal":
+            return `(${expr.elements.map(generateExpression).join(", ")})`;
         default:
             return "/* unsupported */";
     }
@@ -419,8 +585,19 @@ export function generateStatement(stmt, indent) {
             }
             return `${indent}${type} ${stmt.name};`;
         }
-        case "expression":
+        case "expression": {
+            if (stmt.expression.kind === "conditional" && indent) {
+                const conditionalExpr = stmt.expression;
+                const lines = [];
+                lines.push(`${indent}if (${generateExpression(conditionalExpr.condition)}) {`);
+                lines.push(generateStatement({ kind: "expression", expression: conditionalExpr.whenTrue }, inner));
+                lines.push(`${indent}} else {`);
+                lines.push(generateStatement({ kind: "expression", expression: conditionalExpr.whenFalse }, inner));
+                lines.push(`${indent}}`);
+                return lines.join("\n");
+            }
             return `${indent}${generateExpression(stmt.expression)};`;
+        }
         case "if": {
             if (isRequirePattern(stmt)) {
                 const negated = negateExpression(stmt.condition);
@@ -532,6 +709,26 @@ export function generateStatement(stmt, indent) {
             lines.push(`${indent}}`);
             return lines.join("\n");
         }
+        case "try-catch": {
+            const lines = [];
+            const callExpr = generateExpression(stmt.call);
+            let returns = "";
+            if (stmt.returnVarName && stmt.returnType && stmt.returnType.kind !== SkittlesTypeKind.Void) {
+                returns = ` returns (${generateType(stmt.returnType)} ${stmt.returnVarName})`;
+            }
+            lines.push(`${indent}try ${callExpr}${returns} {`);
+            for (const s of stmt.successBody) {
+                lines.push(generateStatement(s, inner));
+            }
+            lines.push(`${indent}} catch {`);
+            for (const s of stmt.catchBody) {
+                lines.push(generateStatement(s, inner));
+            }
+            lines.push(`${indent}}`);
+            return lines.join("\n");
+        }
+        case "console-log":
+            return `${indent}console.log(${stmt.args.map(generateExpression).join(", ")});`;
         default:
             return `${indent}// unsupported statement`;
     }
@@ -570,6 +767,16 @@ function negateOperator(op) {
     };
     return map[op] ?? null;
 }
+/**
+ * Check if a receiver expression is `this` (an internal contract method call).
+ * Used to avoid wrapping `this.transfer(...)` calls in `payable(...)`.
+ * Note: `this.stateVar.transfer(amount)` is NOT excluded here because
+ * codegen strips `this.` and the arg count (1 for ETH transfer vs 2+ for
+ * contract interface calls) serves as the discriminator.
+ */
+function isThisOrContractCall(receiver) {
+    return receiver.kind === "identifier" && receiver.name === "this";
+}
 // ============================================================
 // Built-in function recognition
 // ============================================================
@@ -597,8 +804,13 @@ function tryGenerateBuiltinCall(expr) {
             return `abi.encode(${args})`;
         case "abi.encodePacked":
             return `abi.encodePacked(${args})`;
-        case "abi.decode":
+        case "abi.decode": {
+            if (expr.typeArgs && expr.typeArgs.length > 0) {
+                const types = expr.typeArgs.map(generateType).join(", ");
+                return `abi.decode(${args}, (${types}))`;
+            }
             return `abi.decode(${args})`;
+        }
         case "ecrecover":
             return `ecrecover(${args})`;
         case "addmod":
@@ -609,6 +821,11 @@ function tryGenerateBuiltinCall(expr) {
             return `assert(${args})`;
         case "gasleft":
             return `gasleft()`;
+        case "Contract":
+            if (expr.typeArgs && expr.typeArgs.length > 0 && expr.typeArgs[0].kind === SkittlesTypeKind.ContractInterface && expr.typeArgs[0].structName) {
+                return `${expr.typeArgs[0].structName}(${args})`;
+            }
+            throw new Error("Contract<T>() requires a contract interface type argument, e.g. Contract<IToken>(address)");
         case "string.concat":
             return `string.concat(${args})`;
         case "bytes.concat":
@@ -618,6 +835,47 @@ function tryGenerateBuiltinCall(expr) {
     }
 }
 // ============================================================
+// Console.log detection
+// ============================================================
+function statementsUseConsoleLog(stmts) {
+    for (const stmt of stmts) {
+        if (stmt.kind === "console-log")
+            return true;
+        if (stmt.kind === "if") {
+            if (statementsUseConsoleLog(stmt.thenBody))
+                return true;
+            if (stmt.elseBody && statementsUseConsoleLog(stmt.elseBody))
+                return true;
+        }
+        if (stmt.kind === "for" || stmt.kind === "while" || stmt.kind === "do-while") {
+            if (statementsUseConsoleLog(stmt.body))
+                return true;
+        }
+        if (stmt.kind === "switch") {
+            for (const c of stmt.cases) {
+                if (statementsUseConsoleLog(c.body))
+                    return true;
+            }
+        }
+        if (stmt.kind === "try-catch") {
+            if (statementsUseConsoleLog(stmt.successBody))
+                return true;
+            if (statementsUseConsoleLog(stmt.catchBody))
+                return true;
+        }
+    }
+    return false;
+}
+function contractUsesConsoleLog(contract) {
+    for (const f of contract.functions) {
+        if (statementsUseConsoleLog(f.body))
+            return true;
+    }
+    if (contract.ctor && statementsUseConsoleLog(contract.ctor.body))
+        return true;
+    return false;
+}
+// ============================================================
 // Visibility mapping (Skittles simplification)
 // ============================================================
 function mapVisibility(vis) {
@@ -625,4 +883,130 @@ function mapVisibility(vis) {
         return "public";
     return "internal";
 }
+// ============================================================
+// Source map generation
+// ============================================================
+/**
+ * Build a source map that maps generated Solidity line numbers
+ * back to TypeScript source line numbers.
+ *
+ * The mapping is built by walking the IR (which has source line info
+ * from the parser) and counting lines in the generated Solidity output
+ * to correlate each Solidity line with its TypeScript origin.
+ */
+export function buildSourceMap(solidity, contracts, sourceFile) {
+    const solLines = solidity.split("\n");
+    const mappings = {};
+    let lineIdx = 0; // 0-based index into solLines
+    // Helper: find the next line matching a test, starting from lineIdx
+    function findLine(test) {
+        for (let i = lineIdx; i < solLines.length; i++) {
+            if (test(solLines[i])) {
+                lineIdx = i;
+                return i;
+            }
+        }
+        return -1;
+    }
+    function addMapping(solLineIdx, tsLine) {
+        if (tsLine !== undefined && solLineIdx >= 0) {
+            mappings[solLineIdx + 1] = tsLine; // convert to 1-based
+        }
+    }
+    /**
+     * Map function/constructor body statements to Solidity lines.
+     * Walks statements in order, using generateStatement to count lines
+     * for each statement so we know exactly where each one appears.
+     */
+    function mapBodyStatements(body, startLineIdx, indent) {
+        let currentIdx = startLineIdx;
+        for (const stmt of body) {
+            addMapping(currentIdx, stmt.sourceLine);
+            const stmtText = generateStatement(stmt, indent);
+            const stmtLineCount = stmtText.split("\n").length;
+            // Recurse into compound statement bodies
+            if (stmt.kind === "if" && !isRequirePattern(stmt)) {
+                // Line 0: if (cond) {
+                mapBodyStatements(stmt.thenBody, currentIdx + 1, indent + "    ");
+                if (stmt.elseBody) {
+                    const thenLineCount = stmt.thenBody.reduce((sum, s) => sum + generateStatement(s, indent + "    ").split("\n").length, 0);
+                    // } else { is at currentIdx + 1 + thenLineCount
+                    mapBodyStatements(stmt.elseBody, currentIdx + 1 + thenLineCount + 1, indent + "    ");
+                }
+            }
+            else if (stmt.kind === "expression" && stmt.expression.kind === "conditional" && indent) {
+                // Lowered void ternary: map all generated lines to the original source line
+                for (let i = 1; i < stmtLineCount; i++) {
+                    addMapping(currentIdx + i, stmt.sourceLine);
+                }
+            }
+            else if (stmt.kind === "for" || stmt.kind === "while") {
+                mapBodyStatements(stmt.body, currentIdx + 1, indent + "    ");
+            }
+            else if (stmt.kind === "do-while") {
+                mapBodyStatements(stmt.body, currentIdx + 1, indent + "    ");
+            }
+            currentIdx += stmtLineCount;
+        }
+    }
+    for (const contract of contracts) {
+        // Find the contract declaration line
+        const contractIdx = findLine((l) => {
+            const trimmed = l.trimStart();
+            return trimmed.startsWith(`contract ${contract.name}`) || trimmed.startsWith(`abstract contract ${contract.name}`);
+        });
+        if (contractIdx === -1)
+            continue;
+        addMapping(contractIdx, contract.sourceLine);
+        lineIdx = contractIdx + 1;
+        // Map events
+        for (const e of contract.events) {
+            const idx = findLine((l) => {
+                const trimmed = l.trim();
+                return trimmed.startsWith(`event ${e.name}(`);
+            });
+            if (idx !== -1) {
+                addMapping(idx, e.sourceLine);
+                lineIdx = idx + 1;
+            }
+        }
+        // Map variables
+        for (const v of contract.variables) {
+            const idx = findLine((l) => {
+                const trimmed = l.trim();
+                return trimmed.includes(` ${v.name}`) && trimmed.endsWith(";");
+            });
+            if (idx !== -1) {
+                addMapping(idx, v.sourceLine);
+                lineIdx = idx + 1;
+            }
+        }
+        // Map constructor
+        if (contract.ctor) {
+            const ctorIdx = findLine((l) => l.trim().startsWith("constructor("));
+            if (ctorIdx !== -1) {
+                addMapping(ctorIdx, contract.ctor.sourceLine);
+                lineIdx = ctorIdx + 1;
+                mapBodyStatements(contract.ctor.body, lineIdx, "        ");
+            }
+        }
+        // Map functions
+        for (const f of contract.functions) {
+            const funcIdx = findLine((l) => {
+                const trimmed = l.trim();
+                if (f.name === "receive")
+                    return trimmed.startsWith("receive()");
+                if (f.name === "fallback")
+                    return trimmed.startsWith("fallback()");
+                return trimmed.startsWith(`function ${f.name}(`);
+            });
+            if (funcIdx !== -1) {
+                addMapping(funcIdx, f.sourceLine);
+                lineIdx = funcIdx + 1;
+                mapBodyStatements(f.body, lineIdx, "        ");
+            }
+        }
+    }
+    return { sourceFile, mappings };
+}
 //# sourceMappingURL=codegen.js.map