fix decoding ctor

Author: ci-bot

libs/remix-debug/src/solidity-decoder/helpers/callTreeHelper.ts

@@ -115,13 +115,14 @@ export function getGeneratedSources (tree, scopeId, contractObj) {
  *
  * @param {InternalCallTree} tree - The call tree instance
  * @param {Object} functionDefinition - AST function definition node
+ * @param {Object} contractDefinition - AST function definition node
  * @param {number} step - VM trace step index at function entry
  * @param {string} scopeId - Scope identifier for this function
  * @param {Object} contractObj - Contract object with ABI
  * @param {Object} sourceLocation - Source location of the function
  * @param {string} address - Contract address
  */
-export async function registerFunctionParameters (tree, functionDefinition, step, scopeId, contractObj, sourceLocation, address) {
+export async function registerFunctionParameters (tree, functionDefinition, contractDefinition, step, scopeId, contractObj, sourceLocation, address) {
   if (!sourceLocation) return
   if (sourceLocation.jump !== 'i') return
   tree.functionCallStack.push(step)
@@ -147,6 +148,11 @@ export async function registerFunctionParameters (tree, functionDefinition, step
         functionDefinitionAndInputs.inputs = addInputParams(step, functionDefinition, inputs, tree, scopeId, states, contractObj, sourceLocation, stack.length)
       }
 
+      // For constructors, also register inherited constructor parameters
+      if (functionDefinition.kind === 'constructor') {
+        await registerInheritedConstructorParams(step, functionDefinition, contractDefinition, tree, scopeId, states, contractObj, sourceLocation, address, stack.length)
+      }
+
       // return params - register them but they're not yet on the stack
       if (outputs && outputs.parameters && outputs.parameters.length > 0) {
         addReturnParams(step + 1, functionDefinition, outputs, tree, scopeId, states, contractObj, sourceLocation)
@@ -164,6 +170,120 @@ export async function registerFunctionParameters (tree, functionDefinition, step
   tree.functionDefinitionsByScope[scopeId] = functionDefinitionAndInputs
 }
 
+/**
+ * Registers inherited constructor parameters for a constructor function.
+ * The layout follows: main constructor params start at stack index 0, then inherited constructors 
+ * in reverse order (last inherited constructor first, then the one at length-2, etc.)
+ *
+ * @param {number} step - current step
+ * @param {Object} functionDefinition - Constructor function definition
+ * @param {InternalCallTree} tree - The call tree instance
+ * @param {string} scopeId - Current scope identifier
+ * @param {Object} states - State variable definitions
+ * @param {Object} contractObj - Contract object with name and ABI
+ * @param {Object} sourceLocation - Source location of the constructor
+ * @param {string} address - Contract address
+ * @param {number} stackLength - Current stack depth at constructor entry
+ */
+export async function registerInheritedConstructorParams(step, functionDefinition, contractDefinition, tree: InternalCallTree, scopeId, states, contractObj, sourceLocation, address, stackLength) {
+  try {
+    if (!contractDefinition) {
+      if (tree.debug) console.log(`[registerInheritedConstructorParams] No contract definition or linearized base contracts found`)
+      return
+    }
+
+    // Get linearized base contracts (excluding the current contract which is first)
+    const baseContracts = await tree.solidityProxy.getLinearizedBaseContracts(address, contractDefinition.id)
+
+    // Find constructors in inherited contracts
+    const inheritedConstructors = []
+    for (const baseContract of baseContracts) {
+      if (baseContract.nodes) {
+        const constructor = baseContract.nodes.find(node => 
+          node.nodeType === 'FunctionDefinition' && node.kind === 'constructor'
+        )
+        if (constructor && constructor.parameters && constructor.parameters.parameters && constructor.parameters.parameters.length > 0) {
+          inheritedConstructors.push(constructor)
+        }
+      }
+    }
+
+    if (inheritedConstructors.length === 0) {
+      if (tree.debug) console.log(`[registerInheritedConstructorParams] No inherited constructors with parameters found`)
+      return
+    }
+
+    if (tree.debug) {
+      console.log(`[registerInheritedConstructorParams] Found ${inheritedConstructors.length} inherited constructors with parameters`)
+    }
+
+    // Calculate starting stack index for inherited constructor parameters
+    // Main constructor params start at index 0, inherited constructor params follow
+    const mainConstructorParamCount = functionDefinition.parameters?.parameters?.length || 0
+    let currentStackIndex = mainConstructorParamCount
+
+    // Process inherited constructors in reverse order (last inherited first)
+    for (let i = 0; i < inheritedConstructors.length; i++) {
+      const inheritedConstructor = inheritedConstructors[i]
+      const parameterList = inheritedConstructor.parameters
+      const paramCount = parameterList.parameters.length
+
+      if (tree.debug) {
+        console.log(`[registerInheritedConstructorParams] Processing inherited constructor from contract ${contractsById[inheritedConstructor.parent]?.name || 'unknown'}`)
+        console.log(`  - Parameter count: ${paramCount}`)
+        console.log(`  - Starting stack index: ${currentStackIndex}`)
+      }
+
+      // Register parameters for this inherited constructor
+      for (let j = 0; j < paramCount; j++) {
+        const param = parameterList.parameters[j]
+        const stackIndex = currentStackIndex + j
+
+        // Ensure stack index is valid
+        if (stackIndex < 0 || stackIndex >= stackLength) {
+          if (tree.debug) console.warn(`[registerInheritedConstructorParams] Invalid stack index ${stackIndex} for inherited parameter ${param.name}`)
+          continue
+        }
+
+        let location = extractLocationFromAstVariable(param)
+        location = location === 'default' ? 'memory' : location
+        const attributesName = param.name === '' ? `$inherited_${i}_${j}` : `inherited_${param.name}`
+
+        const newParam = {
+          name: attributesName,
+          type: parseType(param.typeDescriptions.typeString, states, contractObj.name, location),
+          stackIndex: stackIndex,
+          sourceLocation: sourceLocation,
+          abi: contractObj.contract.abi,
+          isParameter: true,
+          isReturnParameter: false,
+          isInheritedConstructorParam: true,
+          declarationStep: step,
+          safeToDecodeAtStep: step,
+          scope: inheritedConstructor.body?.id,
+          id: param.id,
+          inheritedFrom: contractsById[inheritedConstructor.parent]?.name || 'unknown'
+        }
+
+        tree.scopes[scopeId].locals[attributesName] = newParam
+        if (!tree.variables[param.id]) tree.variables[param.id] = newParam
+
+        // Bind parameter to symbolic stack with lifecycle tracking
+        tree.symbolicStackManager.bindVariableWithLifecycle(step + 1, newParam, stackIndex, 'assigned', scopeId)
+
+        if (tree.debug) {
+          console.log(`[registerInheritedConstructorParams] Bound inherited parameter: ${attributesName} at stack index ${stackIndex} from ${newParam.inheritedFrom}`)
+        }
+      }
+
+      currentStackIndex += paramCount
+    }
+
+  } catch (error) {
+    console.error('Error in registerInheritedConstructorParams:', error)
+  }
+}
+
 /**
  * Includes variable declarations in the current scope if a new local variable is encountered at this step.
  * Checks the AST for variable declarations at the current source location and adds them to scope locals.
@@ -675,6 +795,7 @@ export function debugVariableTracking(tree: InternalCallTree, step: number, scop
 export async function resolveNodesAtSourceLocation (tree, sourceLocation, generatedSources, address) {
   const ast = await tree.solidityProxy.ast(sourceLocation, generatedSources, address)
   let funcDef
+  let contractDef
   const blocksDef = []
   if (ast) {
     const nodes = nodesAtPosition(null, sourceLocation.start, { ast })
@@ -690,12 +811,15 @@ export async function resolveNodesAtSourceLocation (tree, sourceLocation, genera
           funcDef = node
           blocksDef.push(node)
         }
+        if (node && node.nodeType === 'ContractDefinition') {
+          contractDef = node
+        }
       }
     }
 
-    return { nodes, functionDefinition: funcDef, blocksDefinition: blocksDef }
+    return { nodes, functionDefinition: funcDef, contractDefinition: contractDef, blocksDefinition: blocksDef }
   } else {
-    return { nodes: [], functionDefinition: null, blocksDefinition: []}
+    return { nodes: [], functionDefinition: null, contractDefinition: null, blocksDefinition: []}
   }
 }
 

libs/remix-debug/src/solidity-decoder/internalCallTree.ts

@@ -203,16 +203,6 @@ export class InternalCallTree {
   gasCostPerLine
   /** Converter for transforming source offsets to line/column positions */
   offsetToLineColumnConverter
-  /** VM trace index where pending constructor execution is expected to start */
-  pendingConstructorExecutionAt: number
-  /** AST node ID of the pending constructor */
-  pendingConstructorId: number
-  /** Pending constructor function definition waiting for execution */
-  pendingConstructor
-  /** Pending constructor entry stack index */
-  pendingConstructorEntryStackIndex
-  /** Map tracking which constructors have started execution and at what source location offset */
-  constructorsStartExecution
   /** Map of variable IDs to their metadata (name, type, stackIndex, sourceLocation, declarationStep, safeToDecodeAtStep) */
   variables: {
     [Key: number]: any
@@ -241,7 +231,7 @@ export class InternalCallTree {
     * @param {Object} opts  - { includeLocalVariables, debugWithGeneratedSources }
     */
   constructor (debuggerEvent, traceManager, solidityProxy, codeManager, opts, offsetToLineColumnConverter?) {
-    this.debug = opts.debug || false
+    this.debug = opts.debug || true
     this.getCache = opts.getCache
     this.includeLocalVariables = opts.includeLocalVariables
     this.debugWithGeneratedSources = opts.debugWithGeneratedSources
@@ -312,11 +302,6 @@ export class InternalCallTree {
     this.astWalker = new AstWalker()
     this.reducedTrace = []
     this.locationAndOpcodePerVMTraceIndex = {}
-    this.pendingConstructorExecutionAt = -1
-    this.pendingConstructorId = -1
-    this.constructorsStartExecution = {}
-    this.pendingConstructorEntryStackIndex = -1
-    this.pendingConstructor = null
     this.variables = {}
     this.symbolicStackManager.reset()
     this.mergedScope = {}
@@ -766,12 +751,12 @@ async function buildTree (tree: InternalCallTree, step, scopeId, isCreation, fun
     // check if there is a function at destination - but only for AST node resolution
     const contractObj = await tree.solidityProxy.contractObjectAtAddress(address)
     const generatedSources = getGeneratedSources(tree, scopeId, contractObj)
-    const { nodes, blocksDefinition, functionDefinition } = await resolveNodesAtSourceLocation(tree, sourceLocation, generatedSources, address)
+    const { nodes, blocksDefinition, functionDefinition, contractDefinition } = await resolveNodesAtSourceLocation(tree, validSourceLocation || sourceLocation, generatedSources, address)
 
     if (!tree.scopes[scopeId].functionDefinition && stepDetail.op === 'JUMPDEST' && functionDefinition && (tree.scopes[scopeId].firstStep === step - 1 || tree.scopes[scopeId].firstStep === step - 2)) {
       tree.scopes[scopeId].functionDefinition = functionDefinition
       tree.scopes[scopeId].lowLevelScope = false
-      await registerFunctionParameters(tree, functionDefinition, step - 1, scopeId, contractObj, previousSourceLocation, address)
+      await registerFunctionParameters(tree, functionDefinition, contractDefinition, step - 1, scopeId, contractObj, previousSourceLocation, address)
     }
 
     // if the first step of the execution leads to invalid source (generated code), we consider it a low level scope.
@@ -829,7 +814,7 @@ async function buildTree (tree: InternalCallTree, step, scopeId, isCreation, fun
           tree.scopes[newScopeId].functionDefinition = functionDefinition
           tree.scopes[newScopeId].lowLevelScope = false
           // Register function parameters when entering new function scope (internal calls or external calls)
-          await registerFunctionParameters(tree, functionDefinition, step, newScopeId, contractObj, sourceLocation, address)
+          await registerFunctionParameters(tree, functionDefinition, contractDefinition, step, newScopeId, contractObj, sourceLocation, address)
         }
         let externalCallResult
         try {
@@ -857,7 +842,7 @@ async function buildTree (tree: InternalCallTree, step, scopeId, isCreation, fun
         console.error(e)
         return { outStep: step, error: 'InternalCallTree - ' + e.message }
       }
-    } else if (callDepthChange(step, tree.traceManager.trace) || isStopInstruction(stepDetail) || isReturnInstruction(stepDetail) || (isJumpOutOfFunction && !originIsCall) || isRevert || isConstructorExit(tree, step, scopeId, tree.pendingConstructorEntryStackIndex, stepDetail, isConstructor)) {
+    } else if (callDepthChange(step, tree.traceManager.trace) || isStopInstruction(stepDetail) || isReturnInstruction(stepDetail) || (isJumpOutOfFunction && !originIsCall) || isRevert) {
       const popCount = countConsecutivePopOpcodes(tree.traceManager.trace, step)
       // if not, we might be returning from a CALL or internal function. This is what is checked here.
       // For constructors in inheritance chains, we also check if stack depth has returned to entry level

libs/remix-debug/src/solidity-decoder/solidityProxy.ts

@@ -2,7 +2,7 @@
 import { util } from '@remix-project/remix-lib'
 import { isContractCreation } from '../trace/traceHelper'
 import { extractStateVariables } from './stateDecoder'
-import { extractContractDefinitions, extractStatesDefinitions } from './helpers/astHelper'
+import { extractContractDefinitions, extractStatesDefinitions, getLinearizedBaseContracts } from './helpers/astHelper'
 import type { CompilerAbstract } from '@remix-project/remix-solidity'
 
 export class SolidityProxy {
@@ -78,6 +78,13 @@ export class SolidityProxy {
     return this.cache.statesDefinitions[address]
   }
 
+  async getLinearizedBaseContracts(address: string, id: number) {
+    const compilationResult = await this.compilationResult(address)
+    if (!compilationResult || !compilationResult.data) return null
+    this.extractStatesDefinitions(address)
+    return getLinearizedBaseContracts(id, this.cache.contractDeclarations[address].contractById)    
+  }
+
   /**
     * extract the state variables of the given compiled @arg contractName (cached)
     *