hardhat 3.2.0 → 3.4.0

package/dist/src/internal/builtin-plugins/solidity/build-system/build-system.js

@@ -9,7 +9,9 @@ import chalk from "chalk";
 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, getBuildInfo, getBuildInfoOutput, getContractArtifact, getDuplicatedContractNamesDeclarationFile, } from "./artifacts.js";
 import { loadCache, saveCache } from "./cache.js";
 import { CompilationJobImplementation } from "./compilation-job.js";
@@ -21,11 +23,10 @@ import { SolcConfigSelector } from "./solc-config-selection.js";
 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, buildProfilePreferWasm) {
-    return solcConfig.preferWasm ?? buildProfilePreferWasm;
+export function isSolcSolidityCompilerConfig(config) {
+    return config.type === undefined || config.type === "solc";
 }
 // Compiler warnings to suppress from build output.
 // Each rule specifies a warning message and the source file it applies to.
@@ -60,25 +61,43 @@ export class SolidityBuildSystemImplementation {
         this.#options = options;
     }
     async getScope(fsPath) {
-        if (fsPath.startsWith(this.#options.solidityTestsPath) &&
+        if (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";
+                }
             }
         }
         return "contracts";
     }
     async getRootFilePaths(options = {}) {
         const scope = options.scope ?? "contracts";
+        const unified = !this.#options.solidityConfig.splitTestsCompilation;
+        this.#ensureSplitCompilationModeIfTestsScope(scope);
         switch (scope) {
-            case "contracts":
-                const localFilesToCompile = (await Promise.all(this.#options.soliditySourcesPaths.map((dir) => getAllFilesMatching(dir, (f) => f.endsWith(".sol") && !f.endsWith(".t.sol"))))).flat(1);
+            case "contracts": {
+                const localContractFiles = (await Promise.all(this.#options.soliditySourcesPaths.map((dir) => getAllFilesMatching(dir, (f) => f.endsWith(".sol") && !f.endsWith(".t.sol"))))).flat(1);
                 const npmFilesToBuild = this.#options.solidityConfig.npmFilesToBuild.map(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) => f.endsWith(".sol")),
                     ...this.#options.soliditySourcesPaths.map(async (dir) => {
@@ -89,32 +108,34 @@ export class SolidityBuildSystemImplementation {
                 // the tests.solidity paths and the sources paths
                 rootFilePaths = Array.from(new Set(rootFilePaths));
                 return rootFilePaths;
+            }
         }
     }
     isSuccessfulBuildResult(buildResult) {
         return buildResult instanceof Map;
     }
-    async build(rootFilePaths, _options) {
-        return this.#hooks.runHandlerChain("solidity", "build", [rootFilePaths, _options], async (_context, nextRootFilePaths, nextOptions) => this.#build(nextRootFilePaths, nextOptions));
+    async build(rootFilePaths, options) {
+        this.#ensureSplitCompilationModeIfTestsScope(options?.scope);
+        return this.#hooks.runHandlerChain("solidity", "build", [rootFilePaths, options], async (_context, nextRootFilePaths, nextOptions) => this.#build(nextRootFilePaths, nextOptions));
     }
-    async #build(rootFilePaths, _options) {
-        const options = {
+    async #build(rootFilePaths, options) {
+        const resolvedOptions = {
             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);
-        const { buildProfile } = this.#getBuildProfile(options.buildProfile);
-        const compilationJobsResult = await this.getCompilationJobs(rootFilePaths, options);
+        await this.#downloadConfiguredCompilers(resolvedOptions.quiet);
+        const { buildProfile } = this.#getBuildProfile(resolvedOptions.buildProfile);
+        const compilationJobsResult = await this.getCompilationJobs(rootFilePaths, resolvedOptions);
         if (!compilationJobsResult.success) {
             return compilationJobsResult;
         }
         const spinner = createSpinner({
-            text: `Compiling your Solidity ${options.scope}...`,
+            text: `Compiling your Solidity ${resolvedOptions.scope}...`,
             enabled: true,
         });
         spinner.start();
@@ -127,14 +148,14 @@ export class SolidityBuildSystemImplementation {
             // internally in each compilation job
             await Promise.all(runnableCompilationJobs.map(async (runnableCompilationJob) => runnableCompilationJob.getBuildId()));
             const results = await pMap(runnableCompilationJobs, async (runnableCompilationJob) => {
-                const { output, compiler } = await this.runCompilationJob(runnableCompilationJob, options);
+                const { output, compiler } = await this.runCompilationJob(runnableCompilationJob, resolvedOptions);
                 return {
                     compilationJob: runnableCompilationJob,
                     compilerOutput: output,
                     compiler,
                 };
             }, {
-                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,
@@ -145,11 +166,11 @@ export class SolidityBuildSystemImplementation {
             if (isSuccessfulBuild) {
                 log("Emitting artifacts of successful build");
                 await Promise.all(results.map(async (compilationResult) => {
-                    const emitArtifactsResult = await this.emitArtifacts(compilationResult.compilationJob, compilationResult.compilerOutput, options);
+                    const emitArtifactsResult = await this.emitArtifacts(compilationResult.compilationJob, compilationResult.compilerOutput, resolvedOptions);
                     const { artifactsPerFile } = emitArtifactsResult;
                     contractArtifactsGeneratedByCompilationJob.set(compilationResult.compilationJob, artifactsPerFile);
                     // Cache the results
-                    await this.#cacheCompilationResult(indexedIndividualJobs, compilationResult, emitArtifactsResult, buildProfile.isolated, options.scope);
+                    await this.#cacheCompilationResult(indexedIndividualJobs, compilationResult, emitArtifactsResult, buildProfile.isolated, resolvedOptions.scope);
                 }));
                 await saveCache(this.#options.cachePath, this.#compileCache);
             }
@@ -188,10 +209,10 @@ export class SolidityBuildSystemImplementation {
                     contractArtifactsGenerated: cacheHitInfo.artifactPaths,
                 });
             }
-            if (!options.quiet) {
+            if (!resolvedOptions.quiet) {
                 if (isSuccessfulBuild) {
                     await this.#printCompilationResult(runnableCompilationJobs, {
-                        scope: options.scope,
+                        scope: resolvedOptions.scope,
                     });
                 }
             }
@@ -202,11 +223,16 @@ export class SolidityBuildSystemImplementation {
         }
     }
     async getCompilationJobs(rootFilePaths, options) {
+        this.#ensureSplitCompilationModeIfTestsScope(options?.scope);
         await this.#downloadConfiguredCompilers(options?.quiet);
         const dependencyGraph = await buildDependencyGraph(rootFilePaths.toSorted(), // We sort them to have a deterministic order
         this.#options.projectRoot, readSourceFileFactory(this.#hooks), this.#hooks);
         const { buildProfileName, buildProfile } = this.#getBuildProfile(options?.buildProfile);
         log(`Using build profile ${buildProfileName}`);
+        let toolVersions;
+        if (buildProfile.toolVersionsInBuildInfo === true) {
+            toolVersions = { hardhat: await getHardhatVersion() };
+        }
         const solcConfigSelector = new SolcConfigSelector(buildProfileName, buildProfile);
         let subgraphsWithConfig = [];
         for (const [rootFile, resolvedFile] of dependencyGraph.getRoots()) {
@@ -219,27 +245,40 @@ export class SolidityBuildSystemImplementation {
             subgraphsWithConfig.push([configOrError.config, subgraph]);
         }
         // get longVersion and isWasm from the compiler for each version
-        const solcVersionToLongVersion = new Map();
-        const versionIsWasm = new Map();
-        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();
+        const versionIsWasmPerCompilerType = new Map();
+        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);
             }
         }
         // build job for each root file. At this point subgraphsWithConfig are 1 root file each
         const indexedIndividualJobs = new Map();
         const sharedContentHashes = new Map();
         await Promise.all(subgraphsWithConfig.map(async ([config, subgraph]) => {
-            const solcLongVersion = solcVersionToLongVersion.get(config.version);
-            assertHardhatInvariant(solcLongVersion !== undefined, "solcLongVersion should not be undefined");
-            const individualJob = new CompilationJobImplementation(subgraph, config, solcLongVersion, this.#hooks, sharedContentHashes);
+            const compilerType = config.type ?? "solc";
+            const longVersionMap = solidityVersionToLongVersionPerCompilerType.get(compilerType);
+            assertHardhatInvariant(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, longVersion, this.#hooks, sharedContentHashes, toolVersions);
             await individualJob.getBuildId(); // precompute
             indexedIndividualJobs.set(getSingleRootFilePath(subgraph), individualJob);
         }));
@@ -252,17 +291,34 @@ export class SolidityBuildSystemImplementation {
         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, `Version ${compilationJob.solcConfig.version} not present in isWasm map`);
             // If there's no cache for the root file, or the compilation job changed, or using force flag, or isolated mode changed, compile it
             if (options?.force === true ||
                 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, buildInfoPath, buildInfoOutputPath, typeFilePath, } = cacheResult;
             for (const outputFilePath of [
@@ -294,9 +350,11 @@ export class SolidityBuildSystemImplementation {
             // non-isolated mode
             log(`Merging compilation jobs`);
             const mergedSubgraphsByConfig = 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);
                 // Skip root files with cache hit (should not recompile)
@@ -321,10 +379,13 @@ export class SolidityBuildSystemImplementation {
             });
         }
         const compilationJobsPerFile = new Map();
-        for (const [solcConfig, subgraph] of subgraphsWithConfig) {
-            const solcLongVersion = solcVersionToLongVersion.get(solcConfig.version);
-            assertHardhatInvariant(solcLongVersion !== undefined, "solcLongVersion should not be undefined");
-            const runnableCompilationJob = new CompilationJobImplementation(subgraph, solcConfig, solcLongVersion, this.#hooks, sharedContentHashes);
+        for (const [compilerConfig, subgraph] of subgraphsWithConfig) {
+            const compilerType = compilerConfig.type ?? "solc";
+            const longVersionMap = solidityVersionToLongVersionPerCompilerType.get(compilerType);
+            assertHardhatInvariant(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, compilerConfig, longVersion, this.#hooks, sharedContentHashes, toolVersions);
             for (const [userSourceName, root] of subgraph.getRoots().entries()) {
                 compilationJobsPerFile.set(formatRootPath(userSourceName, root), runnableCompilationJob);
             }
@@ -353,11 +414,8 @@ export class SolidityBuildSystemImplementation {
         }
         const numberOfRootFiles = runnableCompilationJob.dependencyGraph.getRoots().size;
         const { buildProfile } = this.#getBuildProfile(options?.buildProfile);
-        const compiler = await getCompiler(runnableCompilationJob.solcConfig.version, {
-            preferWasm: resolvePreferWasm(runnableCompilationJob.solcConfig, buildProfile.preferWasm),
-            compilerPath: runnableCompilationJob.solcConfig.path,
-        });
-        log(`Compiling ${numberOfRootFiles} root files and ${numberOfFiles - numberOfRootFiles} dependency files with solc ${runnableCompilationJob.solcConfig.version} using ${compiler.compilerPath}`);
+        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 ${runnableCompilationJob.solcConfig.type ?? "solc"} ${runnableCompilationJob.solcConfig.version} using ${compiler.compilerPath}`);
         assertHardhatInvariant(runnableCompilationJob.solcLongVersion === compiler.longVersion, "The long version of the compiler should match the long version of the compilation job");
         const input = await runnableCompilationJob.getSolcInput();
         const output = await this.#hooks.runHandlerChain("solidity", "invokeSolc", [compiler, input, runnableCompilationJob.solcConfig], async (_context, nextCompiler, nextSolcInput) => {
@@ -386,6 +444,8 @@ export class SolidityBuildSystemImplementation {
     }
     async emitArtifacts(runnableCompilationJob, compilerOutput, options = {}) {
         const scope = options.scope ?? "contracts";
+        this.#ensureSplitCompilationModeIfTestsScope(scope);
+        const unified = !this.#options.solidityConfig.splitTestsCompilation;
         const artifactsPerFile = new Map();
         const typeFilePaths = new Map();
         const buildId = await runnableCompilationJob.getBuildId();
@@ -414,8 +474,14 @@ export class SolidityBuildSystemImplementation {
                 }
             }
             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");
                 typeFilePaths.set(formatRootPath(userSourceName, root), artifactsDeclarationFilePath);
                 const artifactsDeclarationFile = getArtifactsDeclarationFile(artifacts);
@@ -469,13 +535,19 @@ export class SolidityBuildSystemImplementation {
         };
     }
     async getArtifactsDirectory(scope) {
+        // 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");
     }
     async cleanupArtifacts(rootFilePaths, options = {}) {
-        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) => {
             const parsed = parseRootPath(rootFilePath);
@@ -501,7 +573,7 @@ export class SolidityBuildSystemImplementation {
         }));
         const reachableBuildInfoIdsSet = new Set(reachableBuildInfoIds.filter((id) => id !== undefined));
         // Get all the reachable build info files
-        const buildInfoFiles = await getAllFilesMatching(buildInfosDir, (f) => f.startsWith(buildInfosDir));
+        const buildInfoFiles = await getAllFilesMatching(buildInfosDir, (f) => f.startsWith(buildInfosDir + path.sep));
         for (const buildInfoFile of buildInfoFiles) {
             const basename = path.basename(buildInfoFile);
             const id = basename.substring(0, basename.indexOf("."));
@@ -530,8 +602,10 @@ export class SolidityBuildSystemImplementation {
     }
     async compileBuildInfo(buildInfo, options) {
         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, {
             preferWasm: false,
@@ -544,16 +618,15 @@ export class SolidityBuildSystemImplementation {
         if (this.#configuredCompilersDownloaded) {
             return;
         }
-        await downloadSolcCompilers(this.#getAllCompilerVersions(), quiet);
+        const allSolidityCompilerConfigs = this.#getAllSolidityCompilerConfigs();
+        await this.#hooks.runParallelHandlers("solidity", "downloadCompilers", [
+            allSolidityCompilerConfigs,
+            quiet,
+        ]);
         this.#configuredCompilersDownloaded = true;
     }
-    #getAllCompilerVersions() {
-        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() {
+        return Object.values(this.#options.solidityConfig.profiles).flatMap((profile) => [...profile.compilers, ...Object.values(profile.overrides)]);
     }
     #isConsoleLogError(error) {
         const message = error.message;
@@ -580,6 +653,29 @@ export class SolidityBuildSystemImplementation {
         // and then trim just in case a blank space was left
         return `${error.type}: ${error.message}`.replace(/[:\s]*$/g, "").trim();
     }
+    async #getExpectedOutputLayout(rootFilePath, scope) {
+        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;
+        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, result, emitArtifactsResult, isolated, scope) {
         for (const [userSourceName, root] of result.compilationJob.dependencyGraph
             .getRoots()
@@ -590,17 +686,19 @@ export class SolidityBuildSystemImplementation {
             const artifactPaths = emitArtifactsResult.artifactsPerFile.get(rootFilePath);
             assertHardhatInvariant(artifactPaths !== undefined, `No artifacts found on map for ${rootFilePath}`);
             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,
             };
         }
     }
@@ -647,14 +745,18 @@ export class SolidityBuildSystemImplementation {
             return;
         }
         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);
             if (jobsPerEvmVersion === undefined) {
@@ -663,19 +765,39 @@ export class SolidityBuildSystemImplementation {
             }
             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 --
                 This is a valid key, just sorted */
                 const jobs = jobsPerEvmVersion.get(evmVersion);
                 const rootFiles = jobs.reduce((count, job) => count + job.dependencyGraph.getRoots().size, 0);
-                console.log(chalk.bold(`Compiled ${rootFiles} Solidity ${pluralize(options.scope === "contracts" ? "file" : "test file", rootFiles)} with solc ${solcVersion}`), `(evm target: ${evmVersion})`);
+                // 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;
+                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 ${compilerLabel}`), `(evm target: ${evmVersion})`);
             }
         }
     }
+    #ensureSplitCompilationModeIfTestsScope(scope = "contracts") {
+        if (scope === "tests" &&
+            !this.#options.solidityConfig.splitTestsCompilation) {
+            throw new HardhatError(HardhatError.ERRORS.CORE.SOLIDITY.SPLIT_TESTS_COMPILATION_DISABLED);
+        }
+    }
 }
 function toForwardSlash(str) {
     return str.split(/[\\\/]/).join(path.posix.sep);