Ignore function node IDs not found when validating parent initializer calls (#1137)

Author: ericglau

packages/core/CHANGELOG.md

@@ -1,8 +1,12 @@
 # Changelog
 
+## 1.42.2 (2025-03-19)
+
+- Fix `ASTDereferencerError` for additional scenario when validating initializers. ([#1137](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/1137))
+
 ## 1.42.1 (2025-01-24)
 
-- Fix `ASTDereferencerError` when validating initializers.
+- Fix `ASTDereferencerError` when validating initializers. ([#1118](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/1118))
 
 ## 1.42.0 (2025-01-23)
 

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openzeppelin/upgrades-core",
-  "version": "1.42.1",
+  "version": "1.42.2",
   "description": "",
   "repository": "https://github.com/OpenZeppelin/openzeppelin-upgrades/tree/master/packages/core",
   "license": "MIT",

packages/core/src/validate/run.ts

@@ -512,7 +512,10 @@ function setCachedOpcodes(key: number, scope: string, cache: OpcodeCache, errors
   }
 }
 
-function tryDerefFunction(deref: ASTDereferencer, referencedDeclaration: number): FunctionDefinition | undefined {
+export function tryDerefFunction(
+  deref: ASTDereferencer,
+  referencedDeclaration: number,
+): FunctionDefinition | undefined {
   try {
     return deref(['FunctionDefinition'], referencedDeclaration);
   } catch (e: any) {

packages/core/src/validate/run/initializer.ts

@@ -1,7 +1,7 @@
 import type { ContractDefinition, FunctionDefinition } from 'solidity-ast';
 import { ASTDereferencer, findAll } from 'solidity-ast/utils';
 import { SrcDecoder } from '../../src-decoder';
-import { ValidationExceptionInitializer, skipCheck } from '../run';
+import { ValidationExceptionInitializer, skipCheck, tryDerefFunction } from '../run';
 
 /**
  * Reports if this contract is non-abstract and any of the following are true:
@@ -141,6 +141,27 @@ function getParentsNotInitializedByOtherParents(
   return remainingParents;
 }
 
+/**
+ * Calls the callback if the referenced function definition is found in the AST.
+ * Otherwise, does nothing.
+ *
+ * @param deref AST dereferencer
+ * @param referencedDeclaration ID of the referenced function
+ * @param callback Function to call if the referenced function definition is found
+ */
+function doIfReferencedFunctionFound(
+  deref: ASTDereferencer,
+  referencedDeclaration: number | null | undefined,
+  callback: (functionDef: FunctionDefinition) => void,
+) {
+  if (referencedDeclaration && referencedDeclaration > 0) {
+    const functionDef = tryDerefFunction(deref, referencedDeclaration);
+    if (functionDef !== undefined) {
+      callback(functionDef);
+    }
+  }
+}
+
 /**
  * Reports exceptions for missing initializer calls, duplicate initializer calls, and incorrect initializer order.
  *
@@ -176,10 +197,9 @@ function* getInitializerCallExceptions(
       (fnCall.expression.nodeType === 'Identifier' || fnCall.expression.nodeType === 'MemberAccess')
     ) {
       let recursiveFunctionIds: number[] = [];
-      const referencedFn = fnCall.expression.referencedDeclaration;
-      if (referencedFn && referencedFn > 0) {
-        recursiveFunctionIds = getRecursiveFunctionIds(referencedFn, deref);
-      }
+      doIfReferencedFunctionFound(deref, fnCall.expression.referencedDeclaration, (functionDef: FunctionDefinition) => {
+        recursiveFunctionIds = getRecursiveFunctionIds(deref, functionDef);
+      });
 
       // For each recursively called function, if it is a parent initializer, then:
       // - Check if it was already called (duplicate call)
@@ -258,38 +278,41 @@ function* getInitializerCallExceptions(
 /**
  * Gets the IDs of all functions that are recursively called by the given function, including the given function itself at the end of the list.
  *
- * @param referencedFn The ID of the function to start from
  * @param deref AST dereferencer
+ * @param functionDef The node of the function definition to start from
  * @param visited Set of function IDs that have already been visited
  * @returns The IDs of all functions that are recursively called by the given function, including the given function itself at the end of the list.
  */
-function getRecursiveFunctionIds(referencedFn: number, deref: ASTDereferencer, visited?: Set<number>): number[] {
+function getRecursiveFunctionIds(
+  deref: ASTDereferencer,
+  functionDef: FunctionDefinition,
+  visited?: Set<number>,
+): number[] {
   const result: number[] = [];
 
   if (visited === undefined) {
     visited = new Set();
   }
-  if (visited.has(referencedFn)) {
+  if (visited.has(functionDef.id)) {
     return result;
   } else {
-    visited.add(referencedFn);
+    visited.add(functionDef.id);
   }
 
-  const fn = deref('FunctionDefinition', referencedFn);
-  const expressionStatements = fn.body?.statements?.filter(stmt => stmt.nodeType === 'ExpressionStatement') ?? [];
+  const expressionStatements =
+    functionDef.body?.statements?.filter(stmt => stmt.nodeType === 'ExpressionStatement') ?? [];
   for (const stmt of expressionStatements) {
     const fnCall = stmt.expression;
     if (
       fnCall.nodeType === 'FunctionCall' &&
       (fnCall.expression.nodeType === 'Identifier' || fnCall.expression.nodeType === 'MemberAccess')
     ) {
-      const referencedId = fnCall.expression.referencedDeclaration;
-      if (referencedId && referencedId > 0) {
-        result.push(...getRecursiveFunctionIds(referencedId, deref, visited));
-      }
+      doIfReferencedFunctionFound(deref, fnCall.expression.referencedDeclaration, (functionDef: FunctionDefinition) => {
+        result.push(...getRecursiveFunctionIds(deref, functionDef, visited));
+      });
     }
   }
-  result.push(referencedFn);
+  result.push(functionDef.id);
 
   return result;
 }