skittles 1.2.4 → 1.2.6

package/dist/compiler/parser.d.ts

@@ -1,17 +1,19 @@
 import ts from "typescript";
-import type { SkittlesContract, SkittlesFunction, SkittlesParameter, SkittlesType, Statement, Expression } from "../types/index.ts";
+import type { SkittlesContract, SkittlesFunction, SkittlesParameter, SkittlesType, SkittlesContractInterface, Statement, Expression } from "../types/index.ts";
 /**
- * Pre-scan a source file to collect interfaces (structs) and enums
- * without parsing any classes. Used by the compiler to resolve
- * cross-file type references.
+ * Pre-scan a source file to collect type aliases (structs), interfaces
+ * (contract interfaces), and enums without parsing any classes.
+ * Used by the compiler to resolve cross-file type references.
  */
 export declare function collectTypes(source: string, filePath: string): {
     structs: Map<string, SkittlesParameter[]>;
     enums: Map<string, string[]>;
+    contractInterfaces: Map<string, SkittlesContractInterface>;
 };
 export interface ExternalTypes {
     structs?: Map<string, SkittlesParameter[]>;
     enums?: Map<string, string[]>;
+    contractInterfaces?: Map<string, SkittlesContractInterface>;
 }
 export interface ExternalFunctions {
     functions?: SkittlesFunction[];
@@ -29,6 +31,6 @@ export declare function collectFunctions(source: string, filePath: string): {
 export declare function parseType(node: ts.TypeNode): SkittlesType;
 export declare function parseExpression(node: ts.Expression): Expression;
 export declare function parseStatement(node: ts.Statement, varTypes: Map<string, SkittlesType>, eventNames?: Set<string>): Statement;
-export declare function inferStateMutability(body: Statement[]): "pure" | "view" | "nonpayable" | "payable";
+export declare function inferStateMutability(body: Statement[], varTypes?: Map<string, SkittlesType>): "pure" | "view" | "nonpayable" | "payable";
 export declare function inferType(expr: Expression, varTypes: Map<string, SkittlesType>): SkittlesType | undefined;
 //# sourceMappingURL=parser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/compiler/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EACV,gBAAgB,EAEhB,gBAAgB,EAGhB,iBAAiB,EACjB,YAAY,EAGZ,SAAS,EACT,UAAU,EAGX,MAAM,mBAAmB,CAAC;AAY3B;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG;IAC9D,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;IAC1C,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC9B,CAkCA;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;IAC3C,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACrC;AAED,wBAAgB,KAAK,CACnB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,aAAa,CAAC,EAAE,aAAa,EAC7B,iBAAiB,CAAC,EAAE,iBAAiB,GACpC,gBAAgB,EAAE,CAkGpB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG;IAClE,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACpC,CAyCA;AAyiBD,wBAAgB,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,YAAY,CA0DzD;AAMD,wBAAgB,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,UAAU,CAqM/D;AAMD,wBAAgB,cAAc,CAC5B,IAAI,EAAE,EAAE,CAAC,SAAS,EAClB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EACnC,UAAU,GAAE,GAAG,CAAC,MAAM,CAAa,GAClC,SAAS,CAmOX;AAqPD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,GAAG,SAAS,CAgDlG;AAMD,wBAAgB,SAAS,CACvB,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GAClC,YAAY,GAAG,SAAS,CA+D1B"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/compiler/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EACV,gBAAgB,EAEhB,gBAAgB,EAGhB,iBAAiB,EACjB,YAAY,EAEZ,yBAAyB,EAGzB,SAAS,EACT,UAAU,EAGX,MAAM,mBAAmB,CAAC;AAa3B;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG;IAC9D,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;IAC1C,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC7B,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;CAC5D,CA2CA;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;IAC3C,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC9B,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;CAC7D;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACrC;AAED,wBAAgB,KAAK,CACnB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,aAAa,CAAC,EAAE,aAAa,EAC7B,iBAAiB,CAAC,EAAE,iBAAiB,GACpC,gBAAgB,EAAE,CAmHpB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG;IAClE,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACpC,CA4CA;AAspBD,wBAAgB,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,YAAY,CAiEzD;AAMD,wBAAgB,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,UAAU,CAqM/D;AAMD,wBAAgB,cAAc,CAC5B,IAAI,EAAE,EAAE,CAAC,SAAS,EAClB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EACnC,UAAU,GAAE,GAAG,CAAC,MAAM,CAAa,GAClC,SAAS,CAmOX;AAqPD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,QAAQ,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,GAAG,SAAS,CAmDxI;AAMD,wBAAgB,SAAS,CACvB,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GAClC,YAAY,GAAG,SAAS,CA+D1B"}

package/dist/compiler/parser.js

@@ -1,6 +1,7 @@
 import ts from "typescript";
 // Module-level registries, populated during parse()
 let _knownStructs = new Map();
+let _knownContractInterfaces = new Set();
 let _knownEnums = new Set();
 let _knownCustomErrors = new Set();
 let _fileConstants = new Map();
@@ -8,24 +9,32 @@ let _fileConstants = new Map();
 // Main entry
 // ============================================================
 /**
- * Pre-scan a source file to collect interfaces (structs) and enums
- * without parsing any classes. Used by the compiler to resolve
- * cross-file type references.
+ * Pre-scan a source file to collect type aliases (structs), interfaces
+ * (contract interfaces), and enums without parsing any classes.
+ * Used by the compiler to resolve cross-file type references.
  */
 export function collectTypes(source, filePath) {
     const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
     const structs = new Map();
     const enums = new Map();
+    const contractInterfaces = new Map();
     // Temporarily set module registries so parseType can resolve references
     const prevStructs = _knownStructs;
     const prevEnums = _knownEnums;
+    const prevInterfaces = _knownContractInterfaces;
     _knownStructs = structs;
     _knownEnums = new Set();
+    _knownContractInterfaces = new Set();
     ts.forEachChild(sourceFile, (node) => {
-        if (ts.isInterfaceDeclaration(node) && node.name) {
-            const fields = parseInterfaceFields(node);
+        if (ts.isTypeAliasDeclaration(node) && node.name && ts.isTypeLiteralNode(node.type)) {
+            const fields = parseTypeLiteralFields(node.type);
             structs.set(node.name.text, fields);
         }
+        if (ts.isInterfaceDeclaration(node) && node.name) {
+            const iface = parseInterfaceAsContractInterface(node);
+            contractInterfaces.set(node.name.text, iface);
+            _knownContractInterfaces.add(node.name.text);
+        }
         if (ts.isEnumDeclaration(node) && node.name) {
             const members = node.members.map((m) => ts.isIdentifier(m.name) ? m.name.text : "Unknown");
             enums.set(node.name.text, members);
@@ -33,12 +42,14 @@ export function collectTypes(source, filePath) {
     });
     _knownStructs = prevStructs;
     _knownEnums = prevEnums;
-    return { structs, enums };
+    _knownContractInterfaces = prevInterfaces;
+    return { structs, enums, contractInterfaces };
 }
 export function parse(source, filePath, externalTypes, externalFunctions) {
     const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
     const structs = new Map();
     const enums = new Map();
+    const contractInterfaces = new Map();
     const contracts = [];
     // Seed with externally resolved types (from other files)
     if (externalTypes?.structs) {
@@ -51,9 +62,15 @@ export function parse(source, filePath, externalTypes, externalFunctions) {
             enums.set(name, members);
         }
     }
+    if (externalTypes?.contractInterfaces) {
+        for (const [name, iface] of externalTypes.contractInterfaces) {
+            contractInterfaces.set(name, iface);
+        }
+    }
+    // First pass: collect structs and enums so they are available when parsing interfaces
     ts.forEachChild(sourceFile, (node) => {
-        if (ts.isInterfaceDeclaration(node) && node.name) {
-            const fields = parseInterfaceFields(node);
+        if (ts.isTypeAliasDeclaration(node) && node.name && ts.isTypeLiteralNode(node.type)) {
+            const fields = parseTypeLiteralFields(node.type);
             structs.set(node.name.text, fields);
         }
         if (ts.isEnumDeclaration(node) && node.name) {
@@ -61,9 +78,17 @@ export function parse(source, filePath, externalTypes, externalFunctions) {
             enums.set(node.name.text, members);
         }
     });
-    const customErrors = new Map();
     _knownStructs = structs;
     _knownEnums = new Set(enums.keys());
+    // Second pass: parse interfaces (may reference struct/enum types collected above)
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isInterfaceDeclaration(node) && node.name) {
+            const iface = parseInterfaceAsContractInterface(node);
+            contractInterfaces.set(node.name.text, iface);
+        }
+    });
+    const customErrors = new Map();
+    _knownContractInterfaces = new Set(contractInterfaces.keys());
     _knownCustomErrors = new Set();
     _fileConstants = new Map();
     // Collect file level constants (const declarations outside classes)
@@ -110,7 +135,7 @@ export function parse(source, filePath, externalTypes, externalFunctions) {
                 _knownCustomErrors.add(node.name.text);
             }
             else {
-                contracts.push(parseClass(node, filePath, structs, enums, customErrors, fileFunctions, fileConstants));
+                contracts.push(parseClass(node, filePath, structs, enums, contractInterfaces, customErrors, fileFunctions, fileConstants));
             }
         }
     });
@@ -126,11 +151,13 @@ export function collectFunctions(source, filePath) {
     const constants = new Map();
     const emptyVarTypes = new Map();
     const emptyEventNames = new Set();
-    // Need to set up struct/enum registries for type parsing
+    // Need to set up struct/enum/interface registries for type parsing
     const prevStructs = _knownStructs;
     const prevEnums = _knownEnums;
+    const prevInterfaces = _knownContractInterfaces;
     _knownStructs = new Map();
     _knownEnums = new Set();
+    _knownContractInterfaces = new Set();
     ts.forEachChild(sourceFile, (node) => {
         if (ts.isFunctionDeclaration(node) && node.name && node.body) {
             functions.push(parseStandaloneFunction(node, emptyVarTypes, emptyEventNames));
@@ -150,6 +177,7 @@ export function collectFunctions(source, filePath) {
     });
     _knownStructs = prevStructs;
     _knownEnums = prevEnums;
+    _knownContractInterfaces = prevInterfaces;
     return { functions, constants };
 }
 function parseArrayDestructuring(pattern, initializer, varTypes) {
@@ -262,7 +290,7 @@ function parseErrorClass(node) {
     }
     return [];
 }
-function parseInterfaceFields(node) {
+function parseTypeLiteralFields(node) {
     const fields = [];
     for (const member of node.members) {
         if (ts.isPropertySignature(member) &&
@@ -277,10 +305,30 @@ function parseInterfaceFields(node) {
     }
     return fields;
 }
+function parseInterfaceAsContractInterface(node) {
+    const name = node.name.text;
+    const functions = [];
+    for (const member of node.members) {
+        if (ts.isPropertySignature(member) && member.name && ts.isIdentifier(member.name)) {
+            const propName = member.name.text;
+            const returnType = member.type
+                ? parseType(member.type)
+                : { kind: "uint256" };
+            functions.push({ name: propName, parameters: [], returnType, stateMutability: "view" });
+        }
+        if (ts.isMethodSignature(member) && member.name && ts.isIdentifier(member.name)) {
+            const methodName = member.name.text;
+            const parameters = member.parameters.map(parseParameter);
+            const returnType = member.type ? parseType(member.type) : null;
+            functions.push({ name: methodName, parameters, returnType });
+        }
+    }
+    return { name, functions };
+}
 // ============================================================
 // Class level parsing
 // ============================================================
-function parseClass(node, filePath, knownStructs = new Map(), knownEnums = new Map(), knownCustomErrors = new Map(), fileFunctions = [], fileConstants = new Map()) {
+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 variables = [];
     const functions = [];
@@ -296,9 +344,13 @@ function parseClass(node, filePath, knownStructs = new Map(), knownEnums = new M
                     }
                 }
             }
-            // `implements` is accepted but not added to inherits.
-            // TypeScript enforces the shape constraint at compile time.
-            // Solidity doesn't have a separate `implements` keyword.
+            if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+                for (const type of clause.types) {
+                    if (ts.isIdentifier(type.expression)) {
+                        inherits.push(type.expression.text);
+                    }
+                }
+            }
         }
     }
     // Collect arrow function properties separately so they can be parsed as methods
@@ -371,6 +423,19 @@ function parseClass(node, filePath, knownStructs = new Map(), knownEnums = new M
     // Third pass: propagate state mutability through call chains.
     // If function A calls this.B(), and B is nonpayable, then A is also nonpayable.
     propagateStateMutability(functions);
+    // Build set of interface names this class implements
+    const implementedInterfaceNames = new Set();
+    if (node.heritageClauses) {
+        for (const clause of node.heritageClauses) {
+            if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+                for (const type of clause.types) {
+                    if (ts.isIdentifier(type.expression) && knownContractInterfaces.has(type.expression.text)) {
+                        implementedInterfaceNames.add(type.expression.text);
+                    }
+                }
+            }
+        }
+    }
     const contractStructs = [];
     for (const [sName, fields] of knownStructs) {
         contractStructs.push({ name: sName, fields });
@@ -379,6 +444,72 @@ function parseClass(node, filePath, knownStructs = new Map(), knownEnums = new M
     for (const [eName, members] of knownEnums) {
         contractEnums.push({ name: eName, members });
     }
+    // Determine which interfaces this contract actually references
+    const usedIfaceNames = new Set();
+    for (const iName of inherits) {
+        if (knownContractInterfaces.has(iName))
+            usedIfaceNames.add(iName);
+    }
+    for (const v of variables) {
+        collectContractInterfaceTypeRefs(v.type, usedIfaceNames);
+    }
+    for (const f of functions) {
+        for (const p of f.parameters)
+            collectContractInterfaceTypeRefs(p.type, usedIfaceNames);
+        if (f.returnType)
+            collectContractInterfaceTypeRefs(f.returnType, usedIfaceNames);
+    }
+    if (ctor) {
+        for (const p of ctor.parameters)
+            collectContractInterfaceTypeRefs(p.type, usedIfaceNames);
+    }
+    // Deep copy only used interfaces so mutability updates don't leak to shared state
+    const contractIfaceList = [];
+    for (const ifName of usedIfaceNames) {
+        const iface = knownContractInterfaces.get(ifName);
+        if (iface) {
+            contractIfaceList.push({
+                name: iface.name,
+                functions: iface.functions.map((fn) => ({ ...fn })),
+            });
+        }
+    }
+    // Fourth pass: for implemented interfaces, derive method mutabilities
+    // from the actual implementation and mark implementing members as override.
+    if (implementedInterfaceNames.size > 0) {
+        const interfaceFnNames = new Set();
+        for (const ifaceName of implementedInterfaceNames) {
+            const iface = contractIfaceList.find((i) => i.name === ifaceName);
+            if (!iface)
+                continue;
+            for (const ifn of iface.functions) {
+                interfaceFnNames.add(ifn.name);
+                if (ifn.stateMutability)
+                    continue;
+                const impl = functions.find((f) => f.name === ifn.name);
+                if (impl) {
+                    ifn.stateMutability = impl.stateMutability;
+                }
+                else {
+                    const varImpl = variables.find((v) => v.name === ifn.name && v.visibility === "public");
+                    if (varImpl) {
+                        ifn.stateMutability = "view";
+                    }
+                }
+            }
+        }
+        for (const fn of functions) {
+            if (interfaceFnNames.has(fn.name)) {
+                fn.isOverride = true;
+                fn.isVirtual = false;
+            }
+        }
+        for (const v of variables) {
+            if (v.visibility === "public" && interfaceFnNames.has(v.name) && !v.constant && !v.immutable) {
+                v.isOverride = true;
+            }
+        }
+    }
     const contractCustomErrors = [];
     for (const [cName, params] of knownCustomErrors) {
         contractCustomErrors.push({ name: cName, parameters: params });
@@ -395,6 +526,7 @@ function parseClass(node, filePath, knownStructs = new Map(), knownEnums = new M
         events,
         structs: contractStructs,
         enums: contractEnums,
+        contractInterfaces: contractIfaceList,
         customErrors: contractCustomErrors,
         ctor,
         inherits,
@@ -507,7 +639,7 @@ function parseMethod(node, varTypes, eventNames) {
         : null;
     const visibility = getVisibility(node.modifiers);
     const body = node.body ? parseBlock(node.body, varTypes, eventNames) : [];
-    const stateMutability = inferStateMutability(body);
+    const stateMutability = inferStateMutability(body, varTypes);
     const isOverride = hasModifier(node.modifiers, ts.SyntaxKind.OverrideKeyword);
     const isVirtual = !isOverride;
     return { name, parameters, returnType, visibility, stateMutability, isVirtual, isOverride, body };
@@ -520,7 +652,7 @@ function parseGetAccessor(node, varTypes, eventNames) {
         : null;
     const visibility = getVisibility(node.modifiers);
     const body = node.body ? parseBlock(node.body, varTypes, eventNames) : [];
-    const stateMutability = inferStateMutability(body);
+    const stateMutability = inferStateMutability(body, varTypes);
     const isOverride = hasModifier(node.modifiers, ts.SyntaxKind.OverrideKeyword);
     const isVirtual = !isOverride;
     return { name, parameters, returnType, visibility, stateMutability, isVirtual, isOverride, body };
@@ -531,7 +663,7 @@ function parseSetAccessor(node, varTypes, eventNames) {
     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);
+    const stateMutability = inferStateMutability(body, varTypes);
     const isOverride = hasModifier(node.modifiers, ts.SyntaxKind.OverrideKeyword);
     const isVirtual = !isOverride;
     return { name, parameters, returnType, visibility, stateMutability, isVirtual, isOverride, body };
@@ -554,7 +686,7 @@ function parseArrowProperty(node, varTypes, eventNames) {
             body = [{ kind: "return", value: parseExpression(arrow.body) }];
         }
     }
-    const stateMutability = inferStateMutability(body);
+    const stateMutability = inferStateMutability(body, varTypes);
     const isOverride = hasModifier(node.modifiers, ts.SyntaxKind.OverrideKeyword);
     const isVirtual = !isOverride;
     return { name, parameters, returnType, visibility, stateMutability, isVirtual, isOverride, body };
@@ -599,13 +731,19 @@ export function parseType(node) {
                 structFields: _knownStructs.get(name),
             };
         }
+        if (_knownContractInterfaces.has(name)) {
+            return {
+                kind: "contract-interface",
+                structName: name,
+            };
+        }
         if (_knownEnums.has(name)) {
             return {
                 kind: "enum",
                 structName: name,
             };
         }
-        throw new Error(`Unsupported type reference: "${name}". Skittles supports number, string, boolean, address, bytes, Record<K,V>, T[], interface structs, and enums.`);
+        throw new Error(`Unsupported type reference: "${name}". Skittles supports number, string, boolean, address, bytes, Record<K,V>, T[], type structs, interfaces, and enums.`);
     }
     if (ts.isArrayTypeNode(node)) {
         return {
@@ -1222,7 +1360,7 @@ function collectThisCalls(stmts) {
     });
     return names;
 }
-export function inferStateMutability(body) {
+export function inferStateMutability(body, varTypes) {
     let readsState = false;
     let writesState = false;
     let usesMsgValue = false;
@@ -1248,6 +1386,9 @@ export function inferStateMutability(body) {
         if (expr.kind === "call" && isStateMutatingCall(expr)) {
             writesState = true;
         }
+        if (expr.kind === "call" && varTypes && isExternalContractCall(expr, varTypes)) {
+            writesState = true;
+        }
     }, (stmt) => {
         if (stmt.kind === "emit") {
             writesState = true;
@@ -1330,6 +1471,15 @@ export function inferType(expr, varTypes) {
 // ============================================================
 // Helpers
 // ============================================================
+function collectContractInterfaceTypeRefs(type, refs) {
+    if (type.kind === "contract-interface" && type.structName) {
+        refs.add(type.structName);
+    }
+    if (type.keyType)
+        collectContractInterfaceTypeRefs(type.keyType, refs);
+    if (type.valueType)
+        collectContractInterfaceTypeRefs(type.valueType, refs);
+}
 function isStateAccess(expr) {
     if (expr.kind === "property-access" &&
         expr.object.kind === "identifier" &&
@@ -1341,6 +1491,19 @@ function isStateAccess(expr) {
     }
     return false;
 }
+function isExternalContractCall(expr, varTypes) {
+    if (expr.callee.kind === "property-access" &&
+        expr.callee.object.kind === "property-access" &&
+        expr.callee.object.object.kind === "identifier" &&
+        expr.callee.object.object.name === "this") {
+        const propName = expr.callee.object.property;
+        const propType = varTypes.get(propName);
+        if (propType && propType.kind === "contract-interface") {
+            return true;
+        }
+    }
+    return false;
+}
 function isStateMutatingCall(expr) {
     if (expr.callee.kind !== "property-access")
         return false;