parser works

Author: ci-bot

libs/remix-solidity/src/compiler/compiler.ts

@@ -165,8 +165,11 @@ export class Compiler {
       this.state.compileJSON = (source: SourceWithTarget) => {
         const missingInputs: string[] = []
         const missingInputsCallback = (path: string) => {
+          console.log(`[Compiler] 🚨 MISSING IMPORT DETECTED: "${path}"`)
+          console.log(`[Compiler] ⛔ Stopping compilation at first missing import for debugging`)
           missingInputs.push(path)
-          return { error: 'Deferred import' }
+          // Instead of deferring, throw an error to stop compilation immediately
+          throw new Error(`Missing import: ${path}`)
         }
         let result: CompilationResult = {}
         let input = ""
@@ -267,8 +270,11 @@ export class Compiler {
         this.state.compileJSON = (source: SourceWithTarget) => {
           const missingInputs: string[] = []
           const missingInputsCallback = (path: string) => {
+            console.log(`[Compiler] 🚨 MISSING IMPORT DETECTED: "${path}"`)
+            console.log(`[Compiler] ⛔ Stopping compilation at first missing import for debugging`)
             missingInputs.push(path)
-            return { error: 'Deferred import' }
+            // Instead of deferring, throw an error to stop compilation immediately
+            throw new Error(`Missing import: ${path}`)
           }
           let result: CompilationResult = {}
           let input = ""

libs/remix-solidity/src/compiler/dependency-resolver.example.ts

@@ -0,0 +1,73 @@
+/**
+ * Example usage of DependencyResolver
+ * 
+ * This shows how to use the new pre-compilation dependency tree builder
+ * to resolve imports with full context awareness.
+ */
+
+import { DependencyResolver } from './dependency-resolver'
+
+// Example usage in a compilation flow:
+export async function exampleUsage(pluginApi: any, contractFile: string) {
+  console.log('🎯 Starting context-aware dependency resolution...')
+  
+  // 1. Create a DependencyResolver for the entry file
+  const depResolver = new DependencyResolver(pluginApi, contractFile)
+  
+  // 2. Build the complete dependency tree
+  //    This will recursively resolve all imports, tracking which file requests which dependency
+  const sourceBundle = await depResolver.buildDependencyTree(contractFile)
+  
+  // 3. Get the complete source bundle for compilation
+  const compilerInput = depResolver.toCompilerInput()
+  
+  console.log(`✅ Built source bundle with ${sourceBundle.size} files`)
+  
+  // 4. Optional: Inspect the import graph
+  const importGraph = depResolver.getImportGraph()
+  console.log('📊 Import graph:')
+  importGraph.forEach((imports, file) => {
+    console.log(`  ${file} imports:`)
+    imports.forEach(imp => console.log(`    - ${imp}`))
+  })
+  
+  // 5. Optional: Check package contexts
+  for (const [file] of sourceBundle) {
+    const context = depResolver.getPackageContext(file)
+    if (context) {
+      console.log(`📦 ${file} belongs to ${context}`)
+    }
+  }
+  
+  // 6. Pass the source bundle to the Solidity compiler
+  // const compilerOutput = await compile(compilerInput, ...)
+  
+  return compilerInput
+}
+
+/**
+ * Example scenario: Resolving contracts from multiple parent packages
+ * 
+ * File structure:
+ * 
+ * MyContract.sol
+ *   ├─ import "@chainlink/contracts-ccip@1.6.1/src/v0.8/ccip/Router.sol"
+ *   │    └─ import "@chainlink/contracts/src/v0.8/vendor/openzeppelin-solidity/v4.8.3/token/ERC20/IERC20.sol"
+ *   │         (This should resolve using contracts-ccip@1.6.1's package.json, which specifies contracts@1.4.0)
+ *   │
+ *   └─ import "@chainlink/contracts-ccip@1.6.2/src/v0.8/ccip/libraries/Client.sol"
+ *        └─ import "@chainlink/contracts/src/v0.8/shared/access/OwnerIsCreator.sol"
+ *             (This should resolve using contracts-ccip@1.6.2's package.json, which specifies contracts@1.5.0)
+ * 
+ * With the old approach (compiler's missing imports callback):
+ * - ❌ We don't know which file requested @chainlink/contracts
+ * - ❌ We can't determine if it should be 1.4.0 or 1.5.0
+ * - ❌ LIFO approach picks the most recent parent (might be wrong!)
+ * 
+ * With the new approach (DependencyResolver):
+ * - ✅ We know Router.sol (from contracts-ccip@1.6.1) requests IERC20.sol
+ * - ✅ We check contracts-ccip@1.6.1's package.json → contracts@1.4.0
+ * - ✅ We resolve to @chainlink/contracts@1.4.0/...
+ * - ✅ Similarly for Client.sol → contracts@1.5.0
+ * - ✅ Both versions coexist peacefully (different files, no conflict)
+ */

libs/remix-solidity/src/compiler/dependency-resolver.ts

@@ -0,0 +1,280 @@
+'use strict'
+
+import { Plugin } from '@remixproject/engine'
+import { ImportResolver } from './import-resolver'
+
+/**
+ * Pre-compilation dependency tree builder
+ * 
+ * This class manually walks the Solidity import graph BEFORE compilation,
+ * tracking which file requests which import. This enables accurate resolution
+ * of dependencies even when multiple versions of packages are used.
+ * 
+ * Key difference from compiler's missing imports callback:
+ * - We know the REQUESTING file for each import
+ * - We can resolve based on that file's package context
+ * - We build the complete source bundle before compiling
+ */
+export class DependencyResolver {
+  private pluginApi: Plugin
+  private resolver: ImportResolver
+  private sourceFiles: Map<string, string> = new Map() // resolved path -> content
+  private processedFiles: Set<string> = new Set() // Track already processed files
+  private importGraph: Map<string, Set<string>> = new Map() // file -> files it imports
+  private fileToPackageContext: Map<string, string> = new Map() // file -> package@version it belongs to
+
+  constructor(pluginApi: Plugin, targetFile: string) {
+    this.pluginApi = pluginApi
+    this.resolver = new ImportResolver(pluginApi, targetFile)
+  }
+
+  /**
+   * Build complete dependency tree starting from entry file
+   * Returns a map of resolved paths to their contents
+   */
+  public async buildDependencyTree(entryFile: string): Promise<Map<string, string>> {
+    console.log(`[DependencyResolver] 🌳 Building dependency tree from: ${entryFile}`)
+    
+    this.sourceFiles.clear()
+    this.processedFiles.clear()
+    this.importGraph.clear()
+    this.fileToPackageContext.clear()
+    
+    // Start recursive import resolution
+    await this.processFile(entryFile, null)
+    
+    console.log(`[DependencyResolver] ✅ Built source bundle with ${this.sourceFiles.size} files`)
+    
+    return this.sourceFiles
+  }
+
+  /**
+   * Check if a path is a local file (not an npm package)
+   */
+  private isLocalFile(path: string): boolean {
+    // Local files typically:
+    // - End with .sol
+    // - Don't start with @ or contain package-like structure
+    // - Are relative paths or simple filenames
+    // - But NOT relative paths within npm packages (those should be resolved via ImportResolver)
+    return path.endsWith('.sol') && !path.includes('@') && !path.includes('node_modules') && !path.startsWith('../') && !path.startsWith('./')
+  }
+
+  /**
+   * Resolve a relative import path against the current file
+   * E.g., if currentFile is "@chainlink/contracts-ccip@1.6.1/contracts/applications/CCIPClientExample.sol"
+   * and importPath is "../libraries/Client.sol", 
+   * result should be "@chainlink/contracts-ccip@1.6.1/contracts/libraries/Client.sol"
+   */
+  private resolveRelativeImport(currentFile: string, importPath: string): string {
+    if (!importPath.startsWith('./') && !importPath.startsWith('../')) {
+      return importPath // Not a relative path
+    }
+
+    // Get the directory of the current file
+    const currentDir = currentFile.substring(0, currentFile.lastIndexOf('/'))
+    
+    // Split paths into parts
+    const currentParts = currentDir.split('/')
+    const importParts = importPath.split('/')
+    
+    // Process the relative path
+    for (const part of importParts) {
+      if (part === '..') {
+        currentParts.pop() // Go up one directory
+      } else if (part === '.') {
+        // Stay in current directory, do nothing
+      } else {
+        currentParts.push(part)
+      }
+    }
+    
+    const resolvedPath = currentParts.join('/')
+    console.log(`[DependencyResolver]   🔗 Resolved relative import: ${importPath} → ${resolvedPath}`)
+    return resolvedPath
+  }
+
+  /**
+   * Process a single file: fetch content, extract imports, resolve dependencies
+   */
+  private async processFile(
+    importPath: string, 
+    requestingFile: string | null,
+    packageContext?: string
+  ): Promise<void> {
+    // Avoid processing the same file twice
+    if (this.processedFiles.has(importPath)) {
+      console.log(`[DependencyResolver]   ⏭️  Already processed: ${importPath}`)
+      return
+    }
+
+    console.log(`[DependencyResolver] 📄 Processing: ${importPath}`)
+    console.log(`[DependencyResolver]   📍 Requested by: ${requestingFile || 'entry point'}`)
+    
+    if (packageContext) {
+      console.log(`[DependencyResolver]   📦 Package context: ${packageContext}`)
+      this.fileToPackageContext.set(importPath, packageContext)
+      
+      // Tell the resolver about this context so it can make context-aware decisions
+      this.resolver.setPackageContext(packageContext)
+    }
+
+    this.processedFiles.add(importPath)
+
+    try {
+      let content: string
+
+      // Handle local files differently from npm packages
+      if (this.isLocalFile(importPath)) {
+        console.log(`[DependencyResolver]   📁 Local file detected, reading directly`, importPath)
+        // For local files, read directly from file system
+        content = await this.pluginApi.call('fileManager', 'readFile', importPath)
+      } else {
+        // For npm packages, use the resolver
+        content = await this.resolver.resolveAndSave(importPath, undefined, false)
+      }
+      
+      if (!content) {
+        console.log(`[DependencyResolver] ⚠️  Failed to resolve: ${importPath}`)
+        return
+      }
+
+      // Store the resolved content using the original import path as key
+      // The compiler expects source keys to match import statements exactly
+      const resolvedPath = this.isLocalFile(importPath) ? importPath : this.getResolvedPath(importPath)
+      this.sourceFiles.set(importPath, content)
+      
+      // If this is a versioned path (like @package@1.5.0/...) but the original import 
+      // was unversioned, also store under the unversioned path for compiler compatibility
+      if (!this.isLocalFile(importPath) && importPath.includes('@') && importPath.match(/@[^/]+@\d+\.\d+\.\d+\//)) {
+        const unversionedPath = importPath.replace(/@([^@/]+(?:\/[^@/]+)?)@\d+\.\d+\.\d+\//, '@$1/')
+        this.sourceFiles.set(unversionedPath, content)
+        console.log(`[DependencyResolver]   🔄 Also stored under unversioned path: ${unversionedPath}`)
+      }
+      
+
+      
+      // Determine package context for this file (only for npm packages)
+      if (!this.isLocalFile(importPath)) {
+        const filePackageContext = this.extractPackageContext(importPath)
+        if (filePackageContext) {
+          this.fileToPackageContext.set(resolvedPath, filePackageContext)
+          console.log(`[DependencyResolver]   📦 File belongs to: ${filePackageContext}`)
+        }
+      }
+
+      // Extract imports from this file
+      const imports = this.extractImports(content)
+      
+      if (imports.length > 0) {
+        console.log(`[DependencyResolver]   🔗 Found ${imports.length} imports`)
+        this.importGraph.set(resolvedPath, new Set(imports))
+        
+        // Determine the package context to pass to child imports
+        const currentFilePackageContext = this.isLocalFile(importPath) ? null : this.extractPackageContext(importPath)
+        
+        // Recursively process each import
+        for (const importedPath of imports) {
+          console.log(`[DependencyResolver]   ➡️  Processing import: ${importedPath}`)
+          
+          // Resolve relative imports against the original import path (not the resolved path)
+          // This ensures the resolved import matches what the compiler expects
+          let resolvedImportPath = importedPath
+          if (importedPath.startsWith('./') || importedPath.startsWith('../')) {
+            resolvedImportPath = this.resolveRelativeImport(importPath, importedPath)
+            console.log(`[DependencyResolver]   🔗 Resolving import via ImportResolver: "${resolvedImportPath}"`)
+          }
+          
+          await this.processFile(resolvedImportPath, resolvedPath, currentFilePackageContext)
+        }
+      }
+    } catch (err) {
+      console.log(`[DependencyResolver] ❌ Error processing ${importPath}:`, err)
+    }
+  }
+
+  /**
+   * Extract import statements from Solidity source code
+   */
+  private extractImports(content: string): string[] {
+    const imports: string[] = []
+    
+    // Match: import "path/to/file.sol";
+    // Match: import 'path/to/file.sol';
+    // Match: import {Symbol} from "path/to/file.sol";
+    // Match: import * as Name from "path/to/file.sol";
+    const importRegex = /import\s+(?:{[^}]*}\s+from\s+)?(?:\*\s+as\s+\w+\s+from\s+)?["']([^"']+)["']/g
+    
+    let match
+    while ((match = importRegex.exec(content)) !== null) {
+      const importPath = match[1]
+      if (importPath) {
+        imports.push(importPath)
+      }
+    }
+    
+    return imports
+  }
+
+  /**
+   * Extract package context from a file path
+   * E.g., "@openzeppelin/contracts@4.8.0/token/ERC20/IERC20.sol" -> "@openzeppelin/contracts@4.8.0"
+   */
+  private extractPackageContext(path: string): string | null {
+    // Match: @scope/package@version or package@version at start of path
+    const scopedMatch = path.match(/^(@[^/]+\/[^/@]+)@([^/]+)/)
+    if (scopedMatch) {
+      return `${scopedMatch[1]}@${scopedMatch[2]}`
+    }
+    
+    const regularMatch = path.match(/^([^/@]+)@([^/]+)/)
+    if (regularMatch) {
+      return `${regularMatch[1]}@${regularMatch[2]}`
+    }
+    
+    return null
+  }
+
+  /**
+   * Get the resolved path for a file (what the compiler will see)
+   */
+  private getResolvedPath(importPath: string): string {
+    // Get the actual resolved path from the ImportResolver's resolutions
+    const resolved = this.resolver.getResolution(importPath)
+    return resolved || importPath
+  }
+
+  /**
+   * Get the complete source bundle as a map
+   */
+  public getSourceBundle(): Map<string, string> {
+    return this.sourceFiles
+  }
+
+  /**
+   * Get the import graph (which files import which)
+   */
+  public getImportGraph(): Map<string, Set<string>> {
+    return this.importGraph
+  }
+
+  /**
+   * Get the package context for a file
+   */
+  public getPackageContext(filePath: string): string | null {
+    return this.fileToPackageContext.get(filePath) || null
+  }
+
+  /**
+   * Convert source bundle to Solidity compiler input format
+   */
+  public toCompilerInput(): { [fileName: string]: { content: string } } {
+    const sources: { [fileName: string]: { content: string } } = {}
+    
+    for (const [path, content] of this.sourceFiles.entries()) {
+      sources[path] = { content }
+    }
+    
+    return sources
+  }
+}