hardhat 3.2.0 → 3.4.0

package/src/internal/builtin-plugins/solidity/build-system/build-system.ts

@@ -1,7 +1,11 @@
 import type { CompileCache } from "./cache.js";
 import type { DependencyGraphImplementation } from "./dependency-graph.js";
 import type { Artifact } from "../../../../types/artifacts.js";
-import type { SolcConfig, SolidityConfig } from "../../../../types/config.js";
+import type {
+  SolidityCompilerConfig,
+  SolcSolidityCompilerConfig,
+  SolidityConfig,
+} from "../../../../types/config.js";
 import type { HookManager } from "../../../../types/hooks.js";
 import type {
   SolidityBuildSystem,
@@ -18,6 +22,7 @@ import type {
   CacheHitInfo,
 } from "../../../../types/solidity/build-system.js";
 import type {
+  ToolVersions,
   CompilationJob,
   Compiler,
   CompilerOutput,
@@ -53,7 +58,9 @@ import debug from "debug";
 import pMap from "p-map";
 
 import { FileBuildResultType } from "../../../../types/solidity/build-system.js";
+import { getHardhatVersion } from "../../../utils/package.js";
 import { DEFAULT_BUILD_PROFILE } from "../build-profiles.js";
+import { getSolcCompilerForConfig } from "../solidity-hooks.js";
 
 import {
   getArtifactsDeclarationFile,
@@ -79,14 +86,12 @@ import { shouldSuppressWarning } from "./warning-suppression.js";
 const log = debug("hardhat:core:solidity:build-system");
 
 /**
- * Resolves the preferWasm setting for a given solc config, falling back
- * to the build profile's preferWasm if not set on the compiler.
+ * Returns true if the given compiler config is a SolcSolidityCompilerConfig.
  */
-function resolvePreferWasm(
-  solcConfig: SolcConfig,
-  buildProfilePreferWasm: boolean,
-): boolean {
-  return solcConfig.preferWasm ?? buildProfilePreferWasm;
+export function isSolcSolidityCompilerConfig(
+  config: SolidityCompilerConfig,
+): config is SolcSolidityCompilerConfig {
+  return config.type === undefined || config.type === "solc";
 }
 
 // Compiler warnings to suppress from build output.
@@ -150,15 +155,17 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
   public async getScope(fsPath: string): Promise<BuildScope> {
     if (
-      fsPath.startsWith(this.#options.solidityTestsPath) &&
+      fsPath.startsWith(this.#options.solidityTestsPath + path.sep) &&
       fsPath.endsWith(".sol")
     ) {
       return "tests";
     }
 
-    for (const sourcesPath of this.#options.soliditySourcesPaths) {
-      if (fsPath.startsWith(sourcesPath) && fsPath.endsWith(".t.sol")) {
-        return "tests";
+    if (fsPath.endsWith(".t.sol")) {
+      for (const sourcesPath of this.#options.soliditySourcesPaths) {
+        if (fsPath.startsWith(sourcesPath + path.sep)) {
+          return "tests";
+        }
       }
     }
 
@@ -169,10 +176,13 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     options: { scope?: BuildScope } = {},
   ): Promise<string[]> {
     const scope = options.scope ?? "contracts";
+    const unified = !this.#options.solidityConfig.splitTestsCompilation;
+
+    this.#ensureSplitCompilationModeIfTestsScope(scope);
 
     switch (scope) {
-      case "contracts":
-        const localFilesToCompile = (
+      case "contracts": {
+        const localContractFiles = (
           await Promise.all(
             this.#options.soliditySourcesPaths.map((dir) =>
               getAllFilesMatching(
@@ -188,8 +198,30 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
             npmModuleToNpmRootPath,
           );
 
-        return [...localFilesToCompile, ...npmFilesToBuild];
-      case "tests":
+        if (!unified) {
+          return [...localContractFiles, ...npmFilesToBuild];
+        }
+
+        // In unified mode, contracts scope returns all roots: contracts,
+        // tests, and npm files.
+        const testFiles = (
+          await Promise.all([
+            getAllFilesMatching(this.#options.solidityTestsPath, (f) =>
+              f.endsWith(".sol"),
+            ),
+            ...this.#options.soliditySourcesPaths.map(async (dir) => {
+              return getAllFilesMatching(dir, (f) => f.endsWith(".t.sol"));
+            }),
+          ])
+        ).flat(1);
+
+        // Remove duplicates in case there is an intersection between
+        // the tests.solidity paths and the sources paths
+        return Array.from(
+          new Set([...localContractFiles, ...npmFilesToBuild, ...testFiles]),
+        );
+      }
+      case "tests": {
         let rootFilePaths = (
           await Promise.all([
             getAllFilesMatching(this.#options.solidityTestsPath, (f) =>
@@ -205,6 +237,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         // the tests.solidity paths and the sources paths
         rootFilePaths = Array.from(new Set(rootFilePaths));
         return rootFilePaths;
+      }
     }
   }
 
@@ -216,12 +249,14 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
   public async build(
     rootFilePaths: string[],
-    _options?: BuildOptions,
+    options?: BuildOptions,
   ): Promise<CompilationJobCreationError | Map<string, FileBuildResult>> {
+    this.#ensureSplitCompilationModeIfTestsScope(options?.scope);
+
     return this.#hooks.runHandlerChain(
       "solidity",
       "build",
-      [rootFilePaths, _options],
+      [rootFilePaths, options],
       async (_context, nextRootFilePaths, nextOptions) =>
         this.#build(nextRootFilePaths, nextOptions),
     );
@@ -229,25 +264,27 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
   async #build(
     rootFilePaths: string[],
-    _options?: BuildOptions,
+    options?: BuildOptions,
   ): Promise<CompilationJobCreationError | Map<string, FileBuildResult>> {
-    const options: Required<BuildOptions> = {
+    const resolvedOptions: Required<BuildOptions> = {
       buildProfile: DEFAULT_BUILD_PROFILE,
       concurrency: Math.max(os.cpus().length - 1, 1),
       force: false,
       isolated: false,
       quiet: false,
       scope: "contracts",
-      ..._options,
+      ...options,
     };
 
-    await this.#downloadConfiguredCompilers(options.quiet);
+    await this.#downloadConfiguredCompilers(resolvedOptions.quiet);
 
-    const { buildProfile } = this.#getBuildProfile(options.buildProfile);
+    const { buildProfile } = this.#getBuildProfile(
+      resolvedOptions.buildProfile,
+    );
 
     const compilationJobsResult = await this.getCompilationJobs(
       rootFilePaths,
-      options,
+      resolvedOptions,
     );
 
     if (!compilationJobsResult.success) {
@@ -255,7 +292,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
 
     const spinner = createSpinner({
-      text: `Compiling your Solidity ${options.scope}...`,
+      text: `Compiling your Solidity ${resolvedOptions.scope}...`,
       enabled: true,
     });
     spinner.start();
@@ -281,7 +318,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         async (runnableCompilationJob) => {
           const { output, compiler } = await this.runCompilationJob(
             runnableCompilationJob,
-            options,
+            resolvedOptions,
           );
 
           return {
@@ -291,7 +328,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
           };
         },
         {
-          concurrency: options.concurrency,
+          concurrency: resolvedOptions.concurrency,
           // An error when running the compiler is not a compilation failure, but
           // a fatal failure trying to run it, so we just throw on the first error
           stopOnError: true,
@@ -316,7 +353,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
             const emitArtifactsResult = await this.emitArtifacts(
               compilationResult.compilationJob,
               compilationResult.compilerOutput,
-              options,
+              resolvedOptions,
             );
 
             const { artifactsPerFile } = emitArtifactsResult;
@@ -332,7 +369,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
               compilationResult,
               emitArtifactsResult,
               buildProfile.isolated,
-              options.scope,
+              resolvedOptions.scope,
             );
           }),
         );
@@ -400,10 +437,10 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         });
       }
 
-      if (!options.quiet) {
+      if (!resolvedOptions.quiet) {
         if (isSuccessfulBuild) {
           await this.#printCompilationResult(runnableCompilationJobs, {
-            scope: options.scope,
+            scope: resolvedOptions.scope,
           });
         }
       }
@@ -418,6 +455,8 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     rootFilePaths: string[],
     options?: GetCompilationJobsOptions,
   ): Promise<CompilationJobCreationError | GetCompilationJobsResult> {
+    this.#ensureSplitCompilationModeIfTestsScope(options?.scope);
+
     await this.#downloadConfiguredCompilers(options?.quiet);
 
     const dependencyGraph = await buildDependencyGraph(
@@ -433,13 +472,18 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
     log(`Using build profile ${buildProfileName}`);
 
+    let toolVersions: ToolVersions | undefined;
+    if (buildProfile.toolVersionsInBuildInfo === true) {
+      toolVersions = { hardhat: await getHardhatVersion() };
+    }
+
     const solcConfigSelector = new SolcConfigSelector(
       buildProfileName,
       buildProfile,
     );
 
     let subgraphsWithConfig: Array<
-      [SolcConfig, DependencyGraphImplementation]
+      [SolidityCompilerConfig, DependencyGraphImplementation]
     > = [];
     for (const [rootFile, resolvedFile] of dependencyGraph.getRoots()) {
       log(
@@ -459,19 +503,47 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
 
     // get longVersion and isWasm from the compiler for each version
-    const solcVersionToLongVersion = new Map<string, string>();
-    const versionIsWasm = new Map<string, boolean>();
-    for (const [solcConfig] of subgraphsWithConfig) {
-      let solcLongVersion = solcVersionToLongVersion.get(solcConfig.version);
-
-      if (solcLongVersion === undefined) {
-        const compiler = await getCompiler(solcConfig.version, {
-          preferWasm: resolvePreferWasm(solcConfig, buildProfile.preferWasm),
-          compilerPath: solcConfig.path,
-        });
-        solcLongVersion = compiler.longVersion;
-        solcVersionToLongVersion.set(solcConfig.version, solcLongVersion);
-        versionIsWasm.set(solcConfig.version, compiler.isSolcJs);
+    // These maps are keyed by compiler type first, then version, to avoid
+    // collisions between different compiler types using the same version string.
+    const solidityVersionToLongVersionPerCompilerType = new Map<
+      string,
+      Map<string, string>
+    >();
+    const versionIsWasmPerCompilerType = new Map<
+      string,
+      Map<string, boolean>
+    >();
+    for (const [compilerConfig] of subgraphsWithConfig) {
+      const compilerType = compilerConfig.type ?? "solc";
+      let longVersionMap =
+        solidityVersionToLongVersionPerCompilerType.get(compilerType);
+      if (longVersionMap === undefined) {
+        longVersionMap = new Map();
+        solidityVersionToLongVersionPerCompilerType.set(
+          compilerType,
+          longVersionMap,
+        );
+      }
+
+      let isWasmMap = versionIsWasmPerCompilerType.get(compilerType);
+      if (isWasmMap === undefined) {
+        isWasmMap = new Map();
+        versionIsWasmPerCompilerType.set(compilerType, isWasmMap);
+      }
+
+      let longVersion = longVersionMap.get(compilerConfig.version);
+
+      if (longVersion === undefined) {
+        const compiler = await this.#hooks.runHandlerChain(
+          "solidity",
+          "getCompiler",
+          [compilerConfig],
+          async (_context, cfg) =>
+            getSolcCompilerForConfig(cfg, buildProfile.preferWasm),
+        );
+        longVersion = compiler.longVersion;
+        longVersionMap.set(compilerConfig.version, longVersion);
+        isWasmMap.set(compilerConfig.version, compiler.isSolcJs);
       }
     }
 
@@ -480,19 +552,29 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     const sharedContentHashes = new Map<string, string>();
     await Promise.all(
       subgraphsWithConfig.map(async ([config, subgraph]) => {
-        const solcLongVersion = solcVersionToLongVersion.get(config.version);
+        const compilerType = config.type ?? "solc";
+        const longVersionMap =
+          solidityVersionToLongVersionPerCompilerType.get(compilerType);
 
         assertHardhatInvariant(
-          solcLongVersion !== undefined,
-          "solcLongVersion should not be undefined",
+          longVersionMap !== undefined,
+          `No long version map for compiler type ${compilerType}`,
+        );
+
+        const longVersion = longVersionMap.get(config.version);
+
+        assertHardhatInvariant(
+          longVersion !== undefined,
+          "longVersion should not be undefined",
         );
 
         const individualJob = new CompilationJobImplementation(
           subgraph,
           config,
-          solcLongVersion,
+          longVersion,
           this.#hooks,
           sharedContentHashes,
+          toolVersions,
         );
 
         await individualJob.getBuildId(); // precompute
@@ -516,7 +598,15 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     for (const [rootFile, compilationJob] of indexedIndividualJobs.entries()) {
       const jobHash = await compilationJob.getBuildId();
       const cacheResult = this.#compileCache[rootFile];
-      const isWasm = versionIsWasm.get(compilationJob.solcConfig.version);
+      const compilerType = compilationJob.solcConfig.type ?? "solc";
+      const isWasmMap = versionIsWasmPerCompilerType.get(compilerType);
+
+      assertHardhatInvariant(
+        isWasmMap !== undefined,
+        `No isWasm map for compiler type ${compilerType}`,
+      );
+
+      const isWasm = isWasmMap.get(compilationJob.solcConfig.version);
 
       assertHardhatInvariant(
         isWasm !== undefined,
@@ -529,12 +619,33 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         cacheResult === undefined ||
         cacheResult.jobHash !== jobHash ||
         cacheResult.isolated !== isolated ||
+        cacheResult.compilerType !== compilerType ||
         cacheResult.wasm !== isWasm
       ) {
         rootFilesToCompile.add(rootFile);
         continue;
       }
 
+      // Validate output layout: if the cached layout doesn't match the
+      // expected layout for the current config, treat it as a miss.
+      // Pre-existing cache entries without these fields are also treated
+      // as misses.
+      const expectedLayout = await this.#getExpectedOutputLayout(
+        rootFile,
+        options?.scope ?? "contracts",
+      );
+
+      if (
+        cacheResult.artifactsDirectory === undefined ||
+        cacheResult.emitsTypeDeclarations === undefined ||
+        cacheResult.artifactsDirectory !== expectedLayout.artifactsDirectory ||
+        cacheResult.emitsTypeDeclarations !==
+          expectedLayout.emitsTypeDeclarations
+      ) {
+        rootFilesToCompile.add(rootFile);
+        continue;
+      }
+
       // If any of the emitted files are not present anymore, compile it
       const {
         artifactPaths,
@@ -576,13 +687,15 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       log(`Merging compilation jobs`);
 
       const mergedSubgraphsByConfig: Map<
-        SolcConfig,
+        SolidityCompilerConfig,
         DependencyGraphImplementation
       > = new Map();
 
-      // Note: This groups the subgraphs by solc config. It compares the configs
-      // based on reference, and not by deep equality. It misses some merging
-      // opportunities, but this is Hardhat v2's behavior and works well enough.
+      // Note: This groups the subgraphs by compiler config. It compares the
+      // configs based on reference, and not by deep equality. This is
+      // inherently type-aware: two configs with different types will always be
+      // different references. It misses some merging opportunities, but this is
+      // Hardhat v2's behavior and works well enough.
       for (const [config, subgraph] of subgraphsWithConfig) {
         const rootFile = getSingleRootFilePath(subgraph);
 
@@ -613,20 +726,30 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
 
     const compilationJobsPerFile = new Map<string, CompilationJob>();
-    for (const [solcConfig, subgraph] of subgraphsWithConfig) {
-      const solcLongVersion = solcVersionToLongVersion.get(solcConfig.version);
+    for (const [compilerConfig, subgraph] of subgraphsWithConfig) {
+      const compilerType = compilerConfig.type ?? "solc";
+      const longVersionMap =
+        solidityVersionToLongVersionPerCompilerType.get(compilerType);
 
       assertHardhatInvariant(
-        solcLongVersion !== undefined,
-        "solcLongVersion should not be undefined",
+        longVersionMap !== undefined,
+        `No long version map for compiler type ${compilerType}`,
+      );
+
+      const longVersion = longVersionMap.get(compilerConfig.version);
+
+      assertHardhatInvariant(
+        longVersion !== undefined,
+        "longVersion should not be undefined",
       );
 
       const runnableCompilationJob = new CompilationJobImplementation(
         subgraph,
-        solcConfig,
-        solcLongVersion,
+        compilerConfig,
+        longVersion,
         this.#hooks,
         sharedContentHashes,
+        toolVersions,
       );
 
       for (const [userSourceName, root] of subgraph.getRoots().entries()) {
@@ -677,19 +800,16 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
     const { buildProfile } = this.#getBuildProfile(options?.buildProfile);
 
-    const compiler = await getCompiler(
-      runnableCompilationJob.solcConfig.version,
-      {
-        preferWasm: resolvePreferWasm(
-          runnableCompilationJob.solcConfig,
-          buildProfile.preferWasm,
-        ),
-        compilerPath: runnableCompilationJob.solcConfig.path,
-      },
+    const compiler = await this.#hooks.runHandlerChain(
+      "solidity",
+      "getCompiler",
+      [runnableCompilationJob.solcConfig],
+      async (_context, cfg) =>
+        getSolcCompilerForConfig(cfg, buildProfile.preferWasm),
     );
 
     log(
-      `Compiling ${numberOfRootFiles} root files and ${numberOfFiles - numberOfRootFiles} dependency files with solc ${runnableCompilationJob.solcConfig.version} using ${compiler.compilerPath}`,
+      `Compiling ${numberOfRootFiles} root files and ${numberOfFiles - numberOfRootFiles} dependency files with ${runnableCompilationJob.solcConfig.type ?? "solc"} ${runnableCompilationJob.solcConfig.version} using ${compiler.compilerPath}`,
     );
 
     assertHardhatInvariant(
@@ -751,6 +871,10 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
   ): Promise<EmitArtifactsResult> {
     const scope = options.scope ?? "contracts";
 
+    this.#ensureSplitCompilationModeIfTestsScope(scope);
+
+    const unified = !this.#options.solidityConfig.splitTestsCompilation;
+
     const artifactsPerFile = new Map<string, string[]>();
     const typeFilePaths = new Map<string, string>();
     const buildId = await runnableCompilationJob.getBuildId();
@@ -801,8 +925,15 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
       artifactsPerFile.set(formatRootPath(userSourceName, root), paths);
 
-      // Write the type declaration file, only for contracts
-      if (scope === "contracts") {
+      // In split mode, test roots are never part of a "contracts"-scoped pass,
+      // so the scope guard below is sufficient. In unified mode, both contract
+      // and test roots share the same pass, so we check individually.
+      const isTestRoot = unified
+        ? (await this.getScope(root.fsPath)) === "tests"
+        : false;
+
+      // Write the type declaration file for contract roots only.
+      if (scope === "contracts" && !isTestRoot) {
         const artifactsDeclarationFilePath = path.join(
           fileFolder,
           "artifacts.d.ts",
@@ -897,6 +1028,12 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
   }
 
   public async getArtifactsDirectory(scope: BuildScope): Promise<string> {
+    // In unified mode, both scopes point to the main artifacts directory
+    // because contract and test artifacts live together.
+    if (!this.#options.solidityConfig.splitTestsCompilation) {
+      return this.#options.artifactsPath;
+    }
+
     return scope === "contracts"
       ? this.#options.artifactsPath
       : path.join(this.#options.cachePath, "test-artifacts");
@@ -906,9 +1043,11 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     rootFilePaths: string[],
     options: { scope?: BuildScope } = {},
   ): Promise<void> {
-    log(`Cleaning up artifacts`);
-
     const scope = options.scope ?? "contracts";
+
+    this.#ensureSplitCompilationModeIfTestsScope(scope);
+
+    log(`Cleaning up artifacts`);
     const artifactsDirectory = await this.getArtifactsDirectory(scope);
 
     const userSourceNames = rootFilePaths.map((rootFilePath) => {
@@ -960,7 +1099,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
     // Get all the reachable build info files
     const buildInfoFiles = await getAllFilesMatching(buildInfosDir, (f) =>
-      f.startsWith(buildInfosDir),
+      f.startsWith(buildInfosDir + path.sep),
     );
 
     for (const buildInfoFile of buildInfoFiles) {
@@ -1016,8 +1155,10 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
   ): Promise<CompilerOutput> {
     const quiet = options?.quiet ?? false;
 
-    // We download the compiler for the build info as it may not be configured
-    // in the HH config, hence not downloaded with the other compilers
+    // Build info recompilation is always solc-only: build info files are
+    // produced by solc and must be recompiled with the same solc version.
+    // We bypass both downloadCompilers and getCompiler hooks — this is a
+    // self-contained solc replay path, not plugin-configurable compilation.
     await downloadSolcCompilers(new Set([buildInfo.solcVersion]), quiet);
 
     const compiler = await getCompiler(buildInfo.solcVersion, {
@@ -1034,20 +1175,17 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       return;
     }
 
-    await downloadSolcCompilers(this.#getAllCompilerVersions(), quiet);
+    const allSolidityCompilerConfigs = this.#getAllSolidityCompilerConfigs();
+    await this.#hooks.runParallelHandlers("solidity", "downloadCompilers", [
+      allSolidityCompilerConfigs,
+      quiet,
+    ]);
     this.#configuredCompilersDownloaded = true;
   }
 
-  #getAllCompilerVersions(): Set<string> {
-    return new Set(
-      Object.values(this.#options.solidityConfig.profiles)
-        .map((profile) => [
-          ...profile.compilers.map((compiler) => compiler.version),
-          ...Object.values(profile.overrides).map(
-            (override) => override.version,
-          ),
-        ])
-        .flat(1),
+  #getAllSolidityCompilerConfigs(): SolidityCompilerConfig[] {
+    return Object.values(this.#options.solidityConfig.profiles).flatMap(
+      (profile) => [...profile.compilers, ...Object.values(profile.overrides)],
     );
   }
 
@@ -1085,6 +1223,34 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     return `${error.type}: ${error.message}`.replace(/[:\s]*$/g, "").trim();
   }
 
+  async #getExpectedOutputLayout(
+    rootFilePath: string,
+    scope: BuildScope,
+  ): Promise<{ artifactsDirectory: string; emitsTypeDeclarations: boolean }> {
+    const artifactsDirectory = await this.getArtifactsDirectory(scope);
+
+    const unified = !this.#options.solidityConfig.splitTestsCompilation;
+
+    // In unified mode, test roots under contracts scope don't emit type
+    // declarations. In split mode, the scope alone determines this.
+    let emitsTypeDeclarations: boolean;
+    if (scope === "contracts") {
+      if (unified) {
+        const parsed = parseRootPath(rootFilePath);
+        const isTestRoot = isNpmParsedRootPath(parsed)
+          ? false
+          : (await this.getScope(parsed.fsPath)) === "tests";
+        emitsTypeDeclarations = !isTestRoot;
+      } else {
+        emitsTypeDeclarations = true;
+      }
+    } else {
+      emitsTypeDeclarations = false;
+    }
+
+    return { artifactsDirectory, emitsTypeDeclarations };
+  }
+
   async #cacheCompilationResult(
     indexedIndividualJobs: Map<string, CompilationJob>,
     result: CompilationResult,
@@ -1113,22 +1279,24 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
       const typeFilePath = emitArtifactsResult.typeFilePaths.get(rootFilePath);
 
-      // Type declaration file is not generated for solidity tests
-      assertHardhatInvariant(
-        scope === "tests" || typeFilePath !== undefined,
-        `No type file found on map for contract ${rootFilePath}`,
-      );
-
       const jobHash = await individualJob.getBuildId();
 
+      const expectedLayout = await this.#getExpectedOutputLayout(
+        rootFilePath,
+        scope,
+      );
+
       this.#compileCache[rootFilePath] = {
         jobHash,
         isolated,
+        compilerType: individualJob.solcConfig.type ?? "solc",
         artifactPaths,
         buildInfoPath: emitArtifactsResult.buildInfoPath,
         buildInfoOutputPath: emitArtifactsResult.buildInfoOutputPath,
         typeFilePath,
         wasm: result.compiler.isSolcJs,
+        artifactsDirectory: expectedLayout.artifactsDirectory,
+        emitsTypeDeclarations: expectedLayout.emitsTypeDeclarations,
       };
     }
   }
@@ -1208,16 +1376,21 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
 
     for (const job of runnableCompilationJobs) {
+      const compilerType = job.solcConfig.type ?? "solc";
       const solcVersion = job.solcConfig.version;
       const solcInput = await job.getSolcInput();
       const evmVersion =
         solcInput.settings.evmVersion ??
         `Check solc ${solcVersion}'s doc for its default evm version`;
 
-      let jobsPerVersion = jobsPerVersionAndEvmVersion.get(solcVersion);
+      // Group by compiler type + Solidity version to produce separate log
+      // lines for e.g. "solc 0.8.33" vs "solx 0.1.3 (Solidity 0.8.33)".
+      const groupKey = `${compilerType}#${solcVersion}`;
+
+      let jobsPerVersion = jobsPerVersionAndEvmVersion.get(groupKey);
       if (jobsPerVersion === undefined) {
         jobsPerVersion = new Map();
-        jobsPerVersionAndEvmVersion.set(solcVersion, jobsPerVersion);
+        jobsPerVersionAndEvmVersion.set(groupKey, jobsPerVersion);
       }
 
       let jobsPerEvmVersion = jobsPerVersion.get(evmVersion);
@@ -1229,10 +1402,11 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       jobsPerEvmVersion.push(job);
     }
 
-    for (const solcVersion of [...jobsPerVersionAndEvmVersion.keys()].sort()) {
+    for (const groupKey of [...jobsPerVersionAndEvmVersion.keys()].sort()) {
       /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion --
       This is a valid key, just sorted */
-      const jobsPerEvmVersion = jobsPerVersionAndEvmVersion.get(solcVersion)!;
+      const jobsPerEvmVersion = jobsPerVersionAndEvmVersion.get(groupKey)!;
+      const [compilerType, solidityVersion] = groupKey.split("#");
 
       for (const evmVersion of [...jobsPerEvmVersion.keys()].sort()) {
         /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion --
@@ -1244,18 +1418,42 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
           0,
         );
 
+        // For solc, the compiler version is the Solidity version.
+        // For other compilers, extract the compiler's own version from the
+        // longVersion stored on the compilation job, and show the Solidity
+        // version separately.
+        let compilerLabel: string;
+        if (compilerType === "solc") {
+          compilerLabel = `solc ${solidityVersion}`;
+        } else {
+          const longVersion = jobs[0].solcLongVersion;
+          const compilerVersion = longVersion.split("+")[0];
+          compilerLabel = `${compilerType} ${compilerVersion} (Solidity ${solidityVersion})`;
+        }
+
         console.log(
           chalk.bold(
             `Compiled ${rootFiles} Solidity ${pluralize(
               options.scope === "contracts" ? "file" : "test file",
               rootFiles,
-            )} with solc ${solcVersion}`,
+            )} with ${compilerLabel}`,
           ),
           `(evm target: ${evmVersion})`,
         );
       }
     }
   }
+
+  #ensureSplitCompilationModeIfTestsScope(scope: BuildScope = "contracts") {
+    if (
+      scope === "tests" &&
+      !this.#options.solidityConfig.splitTestsCompilation
+    ) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY.SPLIT_TESTS_COMPILATION_DISABLED,
+      );
+    }
+  }
 }
 
 function toForwardSlash(str: string): string {