Update pragma check: validate by actually running the compiler (#5730)

Co-authored-by: Arr00 <13561405+arr00@users.noreply.github.com>

Author: Amxx

.github/workflows/checks.yml

@@ -41,8 +41,8 @@ jobs:
         run: npm run test
       - name: Check linearisation of the inheritance graph
         run: npm run test:inheritance
-      - name: Check pragma consistency between files
-        run: npm run test:pragma
+      - name: Check pragma validity
+        run: npm run test:pragma -- --concurrency 1
       - name: Check procedurally generated contracts are up-to-date
         run: npm run test:generation
       - name: Compare gas costs

package.json

@@ -28,7 +28,7 @@
     "test": ". scripts/set-max-old-space-size.sh && hardhat test",
     "test:generation": "scripts/checks/generation.sh",
     "test:inheritance": "scripts/checks/inheritance-ordering.js artifacts/build-info/*",
-    "test:pragma": "scripts/checks/pragma-consistency.js artifacts/build-info/*",
+    "test:pragma": "scripts/checks/pragma-validity.js artifacts/build-info/*",
     "gas-report": "env ENABLE_GAS_REPORT=true npm run test",
     "slither": "npm run clean && slither ."
   },

scripts/checks/pragma-consistency.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+const semver = require('semver');
+const pLimit = require('p-limit').default;
+
+const { hideBin } = require('yargs/helpers');
+const yargs = require('yargs/yargs');
+
+const getContractsMetadata = require('../get-contracts-metadata');
+const { compile } = require('../solc-versions');
+
+const {
+  argv: { pattern, skipPatterns, verbose, concurrency, _: artifacts },
+} = yargs(hideBin(process.argv))
+  .env('')
+  .options({
+    pattern: { alias: 'p', type: 'string', default: 'contracts/**/*.sol' },
+    skipPatterns: { alias: 's', type: 'string', default: 'contracts/mocks/**/*.sol' },
+    concurrency: { alias: 'c', type: 'number', default: 8 },
+    verbose: { alias: 'v', type: 'count' },
+  });
+
+const limit = pLimit(concurrency);
+Promise.all(
+  Object.entries(getContractsMetadata(pattern, skipPatterns, artifacts)).map(([source, { pragma }]) =>
+    limit(
+      (file, version) =>
+        compile(file, version).then(
+          () => {
+            verbose && console.log(`Compile ${file} using solc ${version}: ok`);
+          },
+          error => {
+            console.error(`Failed to compile ${file} using solc ${version}\n${error}`);
+            process.exitCode = 1;
+          },
+        ),
+      source,
+      semver.minVersion(pragma),
+    ),
+  ),
+).finally(() => {
+  if (!process.exitCode) {
+    console.log('All files can be compiled with the specified pragma.');
+  }
+});

scripts/checks/pragma-validity.js

@@ -0,0 +1,55 @@
+const fs = require('fs');
+const glob = require('glob');
+const match = require('micromatch');
+const path = require('path');
+const { findAll } = require('solidity-ast/utils');
+
+module.exports = function (
+  pattern = 'contracts/**/*.sol',
+  skipPatterns = ['contracts/mocks/**/*.sol'],
+  artifacts = [],
+) {
+  // Use available hardhat artifacts. They reliably identify pragmas and the contracts, libraries and interfaces
+  // definitions with minimal IO operations.
+  const metadata = Object.fromEntries(
+    artifacts.flatMap(artifact => {
+      const { output: solcOutput } = require(path.resolve(__dirname, '..', artifact));
+      return Object.keys(solcOutput.contracts)
+        .filter(source => match.all(source, pattern) && !match.any(source, skipPatterns))
+        .map(source => [
+          source,
+          {
+            pragma: Array.from(findAll('PragmaDirective', solcOutput.sources[source].ast))
+              .find(({ literals }) => literals.at(0) == 'solidity')
+              .literals.slice(1)
+              .join(''),
+            sources: Array.from(findAll('ImportDirective', solcOutput.sources[source].ast)).map(
+              ({ absolutePath }) => absolutePath,
+            ),
+            interface: Array.from(findAll('ContractDefinition', solcOutput.sources[source].ast)).every(
+              ({ contractKind }) => contractKind === 'interface',
+            ),
+          },
+        ]);
+    }),
+  );
+
+  // Artifacts are missing files that only include imports. We have a few of these in contracts/interfaces
+  // We add the missing metadata entries using the foundry artifacts
+  glob
+    .sync(pattern)
+    .filter(file => !match.any(file, skipPatterns) && !Object.hasOwn(metadata, file))
+    .forEach(file => {
+      const entries = glob.sync(`out/${path.basename(file)}/*`);
+      metadata[file] = {
+        pragma: fs.readFileSync(file, 'utf-8').match(/pragma solidity (?<pragma>[<>=^]*[0-9]+\.[0-9]+\.[0-9]+);/)
+          ?.groups.pragma,
+        sources: entries
+          .flatMap(entry => Object.keys(JSON.parse(fs.readFileSync(entry)).metadata.sources))
+          .filter(source => source !== file && match.all(source, pattern) && !match.any(source, skipPatterns)),
+        interface: entries.every(entry => path.basename(entry).match(/^I[A-Z]/)),
+      };
+    });
+
+  return metadata;
+};

scripts/get-contracts-metadata.js

@@ -0,0 +1,15 @@
+const { exec } = require('child_process');
+const semver = require('semver');
+const { range } = require('./helpers');
+
+module.exports = {
+  versions: ['0.4.26', '0.5.16', '0.6.12', '0.7.6', '0.8.30']
+    .map(semver.parse)
+    .flatMap(({ major, minor, patch }) => range(patch + 1).map(p => `${major}.${minor}.${p}`)),
+  compile: (source, version) =>
+    new Promise((resolve, reject) =>
+      exec(`forge build ${source} --use ${version} --out out/solc-${version}`, error =>
+        error ? reject(error) : resolve(),
+      ),
+    ),
+};