move partial transpilation form class Transform to function transpile

src/ast-resolver.ts

@@ -16,7 +16,7 @@ export class ASTResolver {
 
   constructor(
     readonly output: SolcOutput,
-    readonly exclude?: (source: string) => boolean,
+    readonly exclude?: (source: string) => boolean | 'soft',
   ) {
     this.deref = astDereferencer(output);
   }
@@ -28,7 +28,7 @@ export class ASTResolver {
   resolveNode<T extends ExtendedNodeType>(nodeType: T, id: number): ExtendedNodeTypeMap[T] {
     const { node, sourceUnit } = this.deref.withSourceUnit(nodeType, id);
     const source = sourceUnit.absolutePath;
-    if (this.exclude?.(source)) {
+    if (this.exclude?.(source) == true) {
       throw new Error(`Symbol #${id} was imported from an excluded file (${source})`);
     } else {
       return node;

src/index.ts

@@ -3,10 +3,13 @@ import fs from 'fs';
 import { mapValues } from 'lodash';
 import { minimatch } from 'minimatch';
 
+import { findAll } from 'solidity-ast/utils';
+import { Node } from 'solidity-ast/node';
+
 import { matcher } from './utils/matcher';
 import { renamePath, isRenamed } from './rename';
 import { SolcOutput, SolcInput } from './solc/input-output';
-import { Transform } from './transform';
+import { Transform, TransformData } from './transform';
 import { generateWithInit } from './generate-with-init';
 import { findAlreadyInitializable } from './find-already-initializable';
 
@@ -76,10 +79,13 @@ export async function transpile(
   paths: Paths,
   options: TranspileOptions = {},
 ): Promise<OutputFile[]> {
+  const nodeData: { node: Node; data: Partial<TransformData> }[] = [];
+
   const outputPaths = getExtraOutputPaths(paths, options);
   const alreadyInitializable = findAlreadyInitializable(solcOutput, options.initializablePath);
 
   const excludeSet = new Set([...alreadyInitializable, ...Object.values(outputPaths)]);
+  const peerExcludedSet = new Set<string>();
   const excludeMatch = matcher(options.exclude ?? []);
 
   const namespaceInclude = (source: string) => {
@@ -88,11 +94,34 @@ export async function transpile(
     return namespaced && !namespaceExclude.some(p => minimatch(source, p));
   };
 
+  if (options.peerProject !== undefined) {
+    for (const [source, { ast }] of Object.entries(solcOutput.sources)) {
+      const importFromPeer = path.join(options.peerProject, source);
+      const contracts = [...findAll('ContractDefinition', ast)];
+
+      // populate nodeData
+      nodeData.push(
+        ...contracts
+          .filter(node => node.contractKind !== 'contract')
+          .map(node => ({ node, data: { importFromPeer } })),
+      );
+
+      // soft exclude files that have no
+      if (contracts.every(({ contractKind }) => contractKind !== 'contract')) {
+        peerExcludedSet.add(source);
+      }
+    }
+  }
+
   const transform = new Transform(solcInput, solcOutput, {
-    exclude: source => excludeSet.has(source) || (excludeMatch(source) ?? isRenamed(source)),
-    peerProject: options.peerProject,
+    exclude: source =>
+      peerExcludedSet.has(source)
+        ? 'soft'
+        : excludeSet.has(source) || (excludeMatch(source) ?? isRenamed(source)),
   });
 
+  nodeData.forEach(({ node, data }) => Object.assign(transform.getData(node), data));
+
   transform.apply(renameIdentifiers);
   transform.apply(renameContractDefinition);
   transform.apply(renameInheritdoc);

src/transform.ts

@@ -1,7 +1,5 @@
 import { mapValues } from 'lodash';
-import path from 'path';
 import { SourceUnit } from 'solidity-ast';
-import { findAll } from 'solidity-ast/utils';
 import { Node } from 'solidity-ast/node';
 import { SolcInput, SolcOutput } from './solc/input-output';
 import { srcDecoder, SrcDecoder } from './solc/src-decoder';
@@ -46,8 +44,7 @@ interface TransformState {
 }
 
 interface TransformOptions {
-  exclude?: (source: string) => boolean;
-  peerProject?: string;
+  exclude?: (source: string) => boolean | 'soft';
 }
 
 export class Transform {
@@ -61,30 +58,17 @@ export class Transform {
   readonly getLayout: LayoutGetter;
   readonly resolver: ASTResolver;
 
-  constructor(input: SolcInput, output: SolcOutput, options?: TransformOptions) {
+  constructor(input: SolcInput, output: SolcOutput, options: TransformOptions = {}) {
     this.decodeSrc = srcDecoder(output);
     this.getLayout = layoutGetter(output);
-    this.resolver = new ASTResolver(output, options?.exclude);
+    this.resolver = new ASTResolver(output, options.exclude);
 
     for (const source in input.sources) {
-      if (options?.exclude?.(source)) {
+      const excluded = options.exclude?.(source);
+      if (excluded === true || excluded === 'soft') {
         continue;
       }
 
-      if (options?.peerProject) {
-        const contracts = [...findAll('ContractDefinition', output.sources[source].ast)];
-
-        for (const noContract of contracts.filter(
-          ({ contractKind }) => contractKind !== 'contract',
-        )) {
-          this.getData(noContract).importFromPeer = path.join(options.peerProject, source);
-        }
-
-        if (contracts.every(({ contractKind }) => contractKind !== 'contract')) {
-          continue;
-        }
-      }
-
       const s = input.sources[source];
       if (!('content' in s)) {
         throw new Error(`Missing content for ${source}`);

src/transformations/fix-import-directives.ts

@@ -40,7 +40,9 @@ export function fixImportDirectives(withPeerProject?: boolean) {
         imports[importPath] ??= [];
         imports[importPath].push(
           [
-            contract !== undefined && importFromPeer === undefined ? renameContract(a.foreign.name) : a.foreign.name,
+            contract !== undefined && importFromPeer === undefined
+              ? renameContract(a.foreign.name)
+              : a.foreign.name,
             [null, undefined, a.foreign.name].includes(a.local) ? '' : ` as ${a.local}`,
           ].join(''),
         );