feat: add missing functions in abstract contracts

solidity/contracts/utils/ContractBAbstract.sol

@@ -0,0 +1,17 @@
+pragma solidity ^0.8.0;
+
+import {IContractBAbstract} from '../../interfaces/IContractBAbstract.sol';
+import {IContractB2Abstract} from '../../interfaces/IContractB2Abstract.sol';
+
+abstract contract ContractBAbstract is IContractBAbstract, IContractB2Abstract {
+  uint256 public uintVariable;
+
+  constructor(uint256 _uintVariable) {
+    uintVariable = _uintVariable;
+  }
+
+  function setVariablesA(uint256 _newValue) public returns (bool _result) {
+    uintVariable = _newValue;
+    _result = true;
+  }
+}

solidity/interfaces/IContractB2Abstract.sol

@@ -0,0 +1,5 @@
+pragma solidity ^0.8.0;
+
+interface IContractB2Abstract {
+  function undefinedInterfaceFunc2(uint256 _someNumber) external returns (bool _result);
+}

solidity/interfaces/IContractBAbstract.sol

@@ -0,0 +1,5 @@
+pragma solidity ^0.8.0;
+
+interface IContractBAbstract {
+  function undefinedInterfaceFunc(uint256 _someNumber) external returns (bool _result);
+}

src/smock-foundry.ts

@@ -7,6 +7,7 @@ import {
   getSourceUnits,
   smockableNode,
   compileSolidityFilesFoundry,
+  renderAbstractUnimplementedFunctions,
 } from './utils';
 import path from 'path';
 import { ensureDir } from 'fs-extra';
@@ -44,6 +45,10 @@ export async function generateMockContracts(
           // Libraries are not mocked
           if (contract.kind === 'library') continue;
 
+          if (contract.abstract) {
+            mockContent += await renderAbstractUnimplementedFunctions(contract);
+          }
+
           for (const node of contract.children) {
             if (!smockableNode(node)) continue;
             mockContent += await renderNodeMock(node);

src/utils.ts

@@ -1,7 +1,17 @@
 import Handlebars from 'handlebars';
 import path from 'path';
 import { glob } from 'fast-glob';
-import { VariableDeclaration, FunctionDefinition, ImportDirective, ASTNode, ASTKind, ASTReader, SourceUnit, compileSol } from 'solc-typed-ast';
+import {
+  VariableDeclaration,
+  FunctionDefinition,
+  ImportDirective,
+  ASTNode,
+  ASTKind,
+  ASTReader,
+  SourceUnit,
+  compileSol,
+  ContractDefinition,
+} from 'solc-typed-ast';
 import { userDefinedTypes, explicitTypes } from './types';
 import { readFileSync } from 'fs'; // TODO: Replace with fs/promises
 import { ensureDir, emptyDir } from 'fs-extra';
@@ -261,7 +271,8 @@ export async function getSourceUnits(rootPath: string, contractsDirectories: str
     includePath: [rootPath],
   });
 
-  const sourceUnits = new ASTReader().read(compiledFiles.data, ASTKind.Any, compiledFiles.files)
+  const sourceUnits = new ASTReader()
+    .read(compiledFiles.data, ASTKind.Any, compiledFiles.files)
     // Skip source units that are not in the contracts directories
     .filter((sourceUnit) => contractsDirectories.some((directory) => sourceUnit.absolutePath.includes(directory)));
 
@@ -281,3 +292,30 @@ export function smockableNode(node: ASTNode): boolean {
 
   return true;
 }
+
+/**
+ * Renders the abstract functions that are not implemented in the current contract
+ * @param contract The contract to render the abstract functions from
+ * @returns The content of the functions
+ */
+export async function renderAbstractUnimplementedFunctions(contract: ContractDefinition): Promise<string> {
+  let content = '';
+
+  if (contract.vLinearizedBaseContracts.length > 1) {
+    const functions = contract.vFunctions;
+
+    // Skip the first contract, which is the current contract
+    for (let i = 1; i < contract.vLinearizedBaseContracts.length; i++) {
+      const base = contract.vLinearizedBaseContracts[i];
+
+      for (const baseFunction of base.vFunctions) {
+        // If the function is not implemented in the current contract, render it
+        if (!functions.some((func) => func.raw?.functionSelector === baseFunction.raw?.functionSelector)) {
+          content += await renderNodeMock(baseFunction);
+        }
+      }
+    }
+  }
+
+  return content;
+}