Experimental feature: Compilation with pragma analysis

packages/compile-common/package.json

@@ -16,6 +16,7 @@
     "@truffle/contract-schema": "^3.3.4",
     "@types/fs-extra": "^8.1.0",
     "@types/mocha": "^5.2.7",
+    "@truffle/config": "^1.2.32",
     "typescript": "3.9.8"
   },
   "dependencies": {

packages/compile-common/src/profiler/profiler.ts

@@ -3,6 +3,7 @@ const debug = debugModule("compile-common:profiler");
 const findContracts = require("@truffle/contract-sources");
 const expect = require("@truffle/expect");
 
+import type TruffleConfig from "@truffle/config";
 import { updated } from "./updated";
 import { UnresolvedSource } from "./resolveAllSources";
 import { requiredSources, RequiredSourcesOptions } from "./requiredSources";
@@ -89,4 +90,24 @@ export class Profiler {
       allPaths
     });
   }
+
+  async requiredSourcesForSingleFile(options: TruffleConfig) {
+    expect.options(options, ["path", "base_path", "resolver"]);
+
+    const { resolver, path, base_path: basePath } = options;
+
+    const resolve = ({ filePath, importedFrom }: UnresolvedSource) =>
+      resolver.resolve(filePath, importedFrom);
+
+    const allPaths = convertToAbsolutePaths([path], basePath);
+    const updatedPaths = allPaths;
+
+    return await requiredSources({
+      resolve,
+      parseImports: this.config.parseImports,
+      shouldIncludePath: this.config.shouldIncludePath,
+      updatedPaths,
+      allPaths
+    });
+  }
 }

packages/compile-solidity/compileWithPragmaAnalysis.js

@@ -0,0 +1,142 @@
+const CompilerSupplier = require("./compilerSupplier");
+const Config = require("@truffle/config");
+const semver = require("semver");
+const Profiler = require("./profiler");
+const fse = require("fs-extra");
+const { run } = require("./run");
+const OS = require("os");
+const cloneDeep = require("lodash.clonedeep");
+
+const getSemverExpression = source => {
+  return source.match(/pragma solidity(.*);/)[1] ?
+    source.match(/pragma solidity(.*);/)[1].trim() :
+    undefined;
+};
+
+const getSemverExpressions = sources => {
+  return sources.map(source => getSemverExpression(source)).filter(expression => expression);
+};
+
+const validateSemverExpressions = semverExpressions => {
+  const { validRange } = semver;
+  for (const expression of semverExpressions) {
+    if (semver.validRange(expression) === null) {
+      const message = `Invalid semver expression (${expression}) found in` +
+        `one of your contract's imports.`;
+      throw new Error(message);
+    }
+  }
+};
+
+// takes an array of versions and an array of semver expressions
+// returns a version of the compiler or undefined if none can be found
+const findNewestSatisfyingVersion = ({ solcReleases, semverExpressions }) => {
+  // releases are ordered from newest to oldest
+  return solcReleases.find(version => {
+    return semverExpressions.every(expression =>
+      semver.satisfies(version, expression)
+    );
+  });
+};
+
+const throwCompilerVersionNotFound = ({ path, semverExpressions }) => {
+  const message =
+    `Could not find a single version of the Solidity compiler that ` +
+    `satisfies the following semver expressions obtained from your source ` +
+    `files' pragma statements: ${semverExpressions.join(" - ")}. ` +
+    `${OS.EOL}Please check the pragma statements for ${path} and its imports.`;
+  throw new Error(message);
+};
+
+const compileWithPragmaAnalysis = async ({ paths, options }) => {
+  const filteredPaths = paths.filter(
+    path => path.endsWith(".sol") || path.endsWith(".json")
+  );
+  if (filteredPaths.length === 0) {
+    return { compilations: [] };
+  }
+  const supplierOptions = {
+    events: options.events,
+    solcConfig: options.compilers.solc
+  };
+  const compilerSupplier = new CompilerSupplier(supplierOptions);
+  const { releases } = await compilerSupplier.getReleases();
+
+  // collect sources by the version of the Solidity compiler that they require
+  const versionsAndSources = {};
+  for (const path of filteredPaths) {
+    const source = (await options.resolver.resolve(path)).body;
+
+    const parserVersion = findNewestSatisfyingVersion({
+      solcReleases: releases,
+      semverExpressions: [getSemverExpression(source)]
+    });
+    if (!parserVersion) {
+      const m = `Could not find a pragma expression in ${path}. To use the ` +
+        `"pragma" compiler setting your contracts must contain a pragma ` +
+        `expression.`;
+      throw new Error(m);
+    }
+
+    // allSources is of the format { [filename]: string }
+    const { allSources } = await Profiler.requiredSourcesForSingleFile(
+      options.with({
+        path,
+        base_path: options.contracts_directory,
+        resolver: options.resolver,
+        compilers: {
+          solc: {
+            version: parserVersion
+          }
+        }
+      })
+    );
+
+    // get an array of all the semver expressions in the sources
+    const semverExpressions = await getSemverExpressions(
+      Object.values(allSources)
+    );
+
+    // this really just validates the expressions from the contracts' imports
+    // as it has already determined the parser version for each contract
+    validateSemverExpressions(semverExpressions);
+
+    const newestSatisfyingVersion = findNewestSatisfyingVersion({
+      solcReleases: releases,
+      semverExpressions
+    });
+    if (!newestSatisfyingVersion) {
+      throwCompilerVersionNotFound({
+        path,
+        semverExpressions
+      });
+    }
+
+    versionsAndSources[newestSatisfyingVersion] = {
+      ...versionsAndSources[newestSatisfyingVersion],
+      ...allSources
+    };
+  }
+
+  const compilations = [];
+  for (const compilerVersion in versionsAndSources) {
+    const compilationOptions = {
+      compilers: cloneDeep(options.compilers)
+    };
+    compilationOptions.compilers.solc.version = compilerVersion;
+
+    const config = Config.default().with(compilationOptions);
+    const compilation = await run(
+      versionsAndSources[compilerVersion],
+      config
+    );
+    if (compilation.contracts.length > 0) {
+      compilations.push(compilation);
+    }
+  }
+  return { compilations };
+};
+
+module.exports = {
+  compileWithPragmaAnalysis
+};

packages/compile-solidity/compilerSupplier/index.js

@@ -112,7 +112,9 @@ class CompilerSupplier {
           .filter(build => build["prerelease"])
           .map(build => build["longVersion"]);
 
-        const releases = Object.keys(list.releases);
+        const { rsort } = semver;
+        // ensure releases are listed in descending order
+        const releases = rsort(Object.keys(list.releases));
 
         return {
           prereleases: prereleases,

packages/compile-solidity/index.js

@@ -1,43 +1,13 @@
 const debug = require("debug")("compile");
 const path = require("path");
-const expect = require("@truffle/expect");
 const findContracts = require("@truffle/contract-sources");
 const Config = require("@truffle/config");
 const Profiler = require("./profiler");
 const CompilerSupplier = require("./compilerSupplier");
 const { run } = require("./run");
-
-const normalizeOptions = options => {
-  if (options.logger === undefined) options.logger = console;
-
-  expect.options(options, ["contracts_directory", "compilers"]);
-  expect.options(options.compilers, ["solc"]);
-
-  options.compilers.solc.settings.evmVersion =
-    options.compilers.solc.settings.evmVersion ||
-    options.compilers.solc.evmVersion;
-  options.compilers.solc.settings.optimizer =
-    options.compilers.solc.settings.optimizer ||
-    options.compilers.solc.optimizer ||
-    {};
-
-  // Grandfather in old solc config
-  if (options.solc) {
-    options.compilers.solc.settings.evmVersion = options.solc.evmVersion;
-    options.compilers.solc.settings.optimizer = options.solc.optimizer;
-  }
-
-  // Certain situations result in `{}` as a value for compilationTargets
-  // Previous implementations treated any value lacking `.length` as equivalent
-  // to `[]`
-  // (This also happens when run() is called from sources(), so
-  // compilationTargets is not passed)
-  if (!options.compilationTargets || !options.compilationTargets.length) {
-    options.compilationTargets = [];
-  }
-
-  return options;
-};
+const { normalizeOptions } = require("./normalizeOptions");
+const { compileWithPragmaAnalysis } = require("./compileWithPragmaAnalysis");
+const expect = require("@truffle/expect");
 
 const Compile = {
   // this takes an object with keys being the name and values being source
@@ -77,6 +47,10 @@ const Compile = {
 
   // this takes an array of paths and options
   async sourcesWithDependencies({ paths, options }) {
+    if (options.compilers.solc.version === "pragma") {
+      return this.sourcesWithPragmaAnalysis({ paths, options });
+    }
+
     options.logger = options.logger || console;
     options.contracts_directory = options.contracts_directory || process.cwd();
 
@@ -139,6 +113,10 @@ const Compile = {
       : { compilations: [] };
   },
 
+  async sourcesWithPragmaAnalysis({ paths, options }) {
+    return compileWithPragmaAnalysis({ paths, options });
+  },
+
   display(paths, options) {
     if (options.quiet !== true) {
       if (!Array.isArray(paths)) {

packages/compile-solidity/normalizeOptions.js

@@ -0,0 +1,37 @@
+const expect = require("@truffle/expect");
+
+const normalizeOptions = options => {
+  if (options.logger === undefined) options.logger = console;
+
+  expect.options(options, ["contracts_directory", "compilers"]);
+  expect.options(options.compilers, ["solc"]);
+
+  options.compilers.solc.settings.evmVersion =
+    options.compilers.solc.settings.evmVersion ||
+    options.compilers.solc.evmVersion;
+  options.compilers.solc.settings.optimizer =
+    options.compilers.solc.settings.optimizer ||
+    options.compilers.solc.optimizer ||
+    {};
+
+  // Grandfather in old solc config
+  if (options.solc) {
+    options.compilers.solc.settings.evmVersion = options.solc.evmVersion;
+    options.compilers.solc.settings.optimizer = options.solc.optimizer;
+  }
+
+  // Certain situations result in `{}` as a value for compilationTargets
+  // Previous implementations treated any value lacking `.length` as equivalent
+  // to `[]`
+  // (This also happens when run() is called from sources(), so
+  // compilationTargets is not passed)
+  if (!options.compilationTargets || !options.compilationTargets.length) {
+    options.compilationTargets = [];
+  }
+
+  return options;
+};
+
+module.exports = {
+  normalizeOptions
+};

packages/compile-solidity/package.json

@@ -19,6 +19,7 @@
     "@truffle/config": "^1.2.35",
     "@truffle/contract-sources": "^0.1.11",
     "@truffle/expect": "^0.0.15",
+    "lodash.clonedeep": "^4.5.0",
     "debug": "^4.3.1",
     "fs-extra": "^9.1.0",
     "ora": "^3.4.0",

packages/compile-solidity/profiler/index.js

@@ -26,5 +26,16 @@ module.exports = {
 
     // invoke profiler
     return await profiler.requiredSources(options);
+  },
+
+  requiredSourcesForSingleFile: async options => {
+    const parseImports = await loadParser(options);
+
+    const profiler = new Common.Profiler({
+      parseImports,
+      shouldIncludePath
+    });
+
+    return profiler.requiredSourcesForSingleFile(options);
   }
 };

packages/compile-solidity/scripts/test.sh

@@ -3,8 +3,8 @@
 set -o errexit
 
 if [ "$CI" = true ]; then
-  mocha ./test/** ./test/**/* --timeout 10000 $@
+  mocha ./test/** ./test/**/* --timeout 50000 $@
 else
   rm -rf ./node_modules/.cache/truffle
-  mocha ./test/** ./test/**/* --invert --grep native --timeout 10000 $@
+  mocha ./test/** ./test/**/* --invert --grep native --timeout 50000 $@
 fi