Merge pull request #7904 from NomicFoundation/suppress-pragma-license-warnings

Suppress pragma+license warning in Solidity test files

Author: ChristopherDedominici

.changeset/many-deers-shout.md

@@ -0,0 +1,5 @@
+---
+"hardhat": patch
+---
+
+Suppressed pragma and license warnings in Solidity test files ([7894](https://github.com/NomicFoundation/hardhat/issues/7894)).

v-next/hardhat/src/internal/builtin-plugins/solidity/build-system/build-system.ts

@@ -74,24 +74,10 @@ import {
   parseRootPath,
 } from "./root-paths-utils.js";
 import { SolcConfigSelector } from "./solc-config-selection.js";
+import { shouldSuppressWarning } from "./warning-suppression.js";
 
 const log = debug("hardhat:core:solidity:build-system");
 
-// Compiler warnings to suppress from build output.
-// Each rule specifies a warning message and the source file it applies to.
-// This allows suppressing known warnings from internal files (e.g., console.sol)
-// while still showing the same warning type from user code.
-export const SUPPRESSED_WARNINGS: Array<{
-  message: string;
-  sourceFile: string;
-}> = [
-  {
-    message:
-      "Natspec memory-safe-assembly special comment for inline assembly is deprecated and scheduled for removal. Use the memory-safe block annotation instead.",
-    sourceFile: path.normalize("hardhat/console.sol"),
-  },
-];
-
 interface CompilationResult {
   compilationJob: CompilationJob;
   compilerOutput: CompilerOutput;
@@ -1155,9 +1141,10 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
   #shouldSuppressWarning(error: CompilerOutputError): boolean {
     const msg = error.formattedMessage ?? error.message;
-
-    return SUPPRESSED_WARNINGS.some(
-      (rule) => msg.includes(rule.message) && msg.includes(rule.sourceFile),
+    return shouldSuppressWarning(
+      msg,
+      this.#options.solidityTestsPath,
+      this.#options.projectRoot,
     );
   }
 

v-next/hardhat/src/internal/builtin-plugins/solidity/build-system/warning-suppression.ts

@@ -0,0 +1,97 @@
+import path from "node:path";
+
+// Compiler warnings to suppress from build output.
+// Supports two types of suppression rules:
+//
+// 1. scope: 'specific-file' - Suppress warnings from specific file paths
+//    - Use this to suppress known warnings from internal/library files (e.g., console.sol)
+//    - The same warning type will still be shown for user code
+//
+// 2. scope: 'test-files' - Suppress warnings from all test files
+//    - Test files are identified as:
+//      * Files ending in .t.sol (e.g., Counter.t.sol)
+//      * Files inside test/contracts/ directory
+//        (e.g., test/contracts/Example.sol)
+//    - Use this for warnings that are acceptable in test code but not in production code
+//      (e.g., missing SPDX license identifiers or pragma statements)
+export const SUPPRESSED_WARNINGS: Array<
+  | {
+      message: string;
+      scope: "specific-file";
+      filePath: string;
+    }
+  | {
+      message: string;
+      scope: "test-files";
+    }
+> = [
+  {
+    message:
+      "Natspec memory-safe-assembly special comment for inline assembly is deprecated and scheduled for removal. Use the memory-safe block annotation instead.",
+    scope: "specific-file",
+    // Normalize to handle different OS path separators
+    filePath: path.normalize("hardhat/console.sol"),
+  },
+  {
+    message: "SPDX license identifier not provided",
+    scope: "test-files",
+  },
+  {
+    message: "Source file does not specify required compiler version",
+    scope: "test-files",
+  },
+];
+
+/**
+ * Determines if a compiler warning should be suppressed based on the suppression rules.
+ *
+ * @param errorMessage - The formatted error message from the compiler
+ * @param absoluteSolidityTestsPath - Absolute path to the Solidity test directory
+ * @param absoluteProjectRoot - Absolute path to the project root
+ * @returns true if the warning should be suppressed, false otherwise
+ */
+export function shouldSuppressWarning(
+  errorMessage: string,
+  absoluteSolidityTestsPath: string,
+  absoluteProjectRoot: string,
+): boolean {
+  // Compute relative path from project root to test directory.
+  // Example:
+  // absoluteSolidityTestsPath: /workspaces/hardhat-4/v-next/example-project/test/contracts
+  // absoluteProjectRoot:       /workspaces/hardhat-4/v-next/example-project
+  // relativeTestPath:          test/contracts/ - note the addition of the `/`
+  // to avoid partial matches, e.g.: test/contractsUtils/
+  const relativeTestPath = path.join(
+    path.relative(absoluteProjectRoot, absoluteSolidityTestsPath),
+    "/",
+  );
+
+  return SUPPRESSED_WARNINGS.some((rule) => {
+    if (!errorMessage.includes(rule.message)) {
+      return false;
+    }
+
+    if (rule.scope === "specific-file") {
+      return errorMessage.includes(rule.filePath);
+    }
+
+    // Check if the message contains a path to a test file
+    // Test files are identified by:
+    // - Ending in .t.sol (e.g., Counter.t.sol)
+    // - Being inside the configured Solidity test directory
+
+    if (/\.t\.sol(:|$|\s)/.test(errorMessage)) {
+      return true;
+    }
+
+    // Extract file path from error message
+    // Format: "Warning: message\n  --> path/to/file.sol:line:column:"
+    const pathMatches = errorMessage.match(/-->\s+([^\s:]+\.sol)/);
+
+    if (pathMatches !== null) {
+      return pathMatches[1].includes(relativeTestPath);
+    }
+
+    return false;
+  });
+}

v-next/hardhat/test/internal/builtin-plugins/solidity/build-system/integration/warning-filtering.ts

@@ -3,10 +3,17 @@ import type { HardhatUserConfig } from "../../../../../../src/config.js";
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 
-import { SUPPRESSED_WARNINGS } from "../../../../../../src/internal/builtin-plugins/solidity/build-system/build-system.js";
+import { SUPPRESSED_WARNINGS } from "../../../../../../src/internal/builtin-plugins/solidity/build-system/warning-suppression.js";
 import { useTestProjectTemplate } from "../resolver/helpers.js";
 
+//
+// Integration smoke tests - full coverage is provided by
+// unit tests in warning-suppression.ts
+//
+
 const NATSPEC_MEMORY_SAFE_WARNING = SUPPRESSED_WARNINGS[0].message;
+const SPDX_WARNING = SUPPRESSED_WARNINGS[1].message;
+const PRAGMA_WARNING = SUPPRESSED_WARNINGS[2].message;
 
 // Project with the warning in a regular contract file (not console.sol)
 const projectWithNatspecWarningInRegularFile = {
@@ -44,6 +51,36 @@ library console {
   },
 };
 
+// Project with missing SPDX/pragma in a .t.sol test file (should suppress warnings)
+const projectWithMissingSpdxPragmaInTestFile = {
+  name: "missing-spdx-pragma-test-file",
+  version: "1.0.0",
+  files: {
+    "contracts/Counter.t.sol": `contract CounterTest {
+  function testIncrement() public {
+    // test code
+  }
+}
+`,
+  },
+};
+
+// Project with missing SPDX/pragma in a regular contract (should show warnings)
+const projectWithMissingSpdxPragmaInRegularFile = {
+  name: "missing-spdx-pragma-test",
+  version: "1.0.0",
+  files: {
+    "contracts/Counter.sol": `contract Counter {
+  uint256 public count;
+
+  function increment() public {
+    count += 1;
+  }
+}
+`,
+  },
+};
+
 const solidity0833Config: HardhatUserConfig = {
   solidity: {
     profiles: {
@@ -56,49 +93,62 @@ const solidity0833Config: HardhatUserConfig = {
 
 const noop = () => {};
 
-describe("build system - warning filtering", function () {
-  it("should NOT filter out the deprecated natspec warning from regular files", async (t) => {
-    const consoleWarnMock = t.mock.method(console, "warn", noop);
-
-    await using project = await useTestProjectTemplate(
-      projectWithNatspecWarningInRegularFile,
-    );
-
-    const hre = await project.getHRE(solidity0833Config);
-
-    await hre.tasks.getTask("build").run({ force: true });
+const testScenarios = [
+  {
+    name: "should NOT filter out the deprecated natspec warning from regular files",
+    project: projectWithNatspecWarningInRegularFile,
+    warnings: [NATSPEC_MEMORY_SAFE_WARNING],
+    shouldSuppress: false,
+  },
+  {
+    name: "should filter out the deprecated natspec warning from console.sol",
+    project: projectWithNatspecWarningInConsole,
+    warnings: [NATSPEC_MEMORY_SAFE_WARNING],
+    shouldSuppress: true,
+  },
+  {
+    name: "should filter out SPDX/pragma warnings from .t.sol test files (test-files scope)",
+    project: projectWithMissingSpdxPragmaInTestFile,
+    warnings: [SPDX_WARNING, PRAGMA_WARNING],
+    shouldSuppress: true,
+  },
+  {
+    name: "should NOT filter out SPDX/pragma warnings from regular contracts",
+    project: projectWithMissingSpdxPragmaInRegularFile,
+    warnings: [SPDX_WARNING, PRAGMA_WARNING],
+    shouldSuppress: false,
+  },
+];
 
-    // Check that the natspec warning WAS printed to console.warn
-    const warningWasShown = consoleWarnMock.mock.calls.some((call) => {
-      const message = String(call.arguments[0] ?? "");
-      return message.includes(NATSPEC_MEMORY_SAFE_WARNING);
+describe("build system - warning filtering", function () {
+  for (const scenario of testScenarios) {
+    it(scenario.name, async (t) => {
+      const consoleWarnMock = t.mock.method(console, "warn", noop);
+
+      await using project = await useTestProjectTemplate(scenario.project);
+
+      const hre = await project.getHRE(solidity0833Config);
+
+      await hre.tasks.getTask("build").run({ force: true });
+
+      for (const warning of scenario.warnings) {
+        const warningWasShown = consoleWarnMock.mock.calls.some((call) => {
+          const message = String(call.arguments[0] ?? "");
+          return message.includes(warning);
+        });
+
+        if (scenario.shouldSuppress) {
+          assert.ok(
+            !warningWasShown,
+            `Expected warning "${warning}" to be suppressed, but it was shown`,
+          );
+        } else {
+          assert.ok(
+            warningWasShown,
+            `Expected warning "${warning}" to be shown, but it was suppressed`,
+          );
+        }
+      }
     });
-
-    assert.ok(
-      warningWasShown,
-      "Expected natspec memory-safe-assembly warning to be shown for regular files",
-    );
-  });
-
-  it("should filter out the deprecated natspec warning from console.sol", async (t) => {
-    const consoleWarnMock = t.mock.method(console, "warn", noop);
-
-    await using project = await useTestProjectTemplate(
-      projectWithNatspecWarningInConsole,
-    );
-
-    const hre = await project.getHRE(solidity0833Config);
-
-    await hre.tasks.getTask("build").run({ force: true });
-
-    // Check that the natspec warning was NOT printed to console.warn
-    for (const call of consoleWarnMock.mock.calls) {
-      const message = String(call.arguments[0] ?? "");
-
-      assert.ok(
-        !message.includes(NATSPEC_MEMORY_SAFE_WARNING),
-        `Expected natspec memory-safe-assembly warning to be filtered out for console.sol, but found: ${message}`,
-      );
-    }
-  });
+  }
 });