Enable coverage when viaIR compiler flag is true

.circleci/config.yml

@@ -12,11 +12,9 @@ step_install_nvm: &step_install_nvm
       set +e
       export NVM_DIR="/opt/circleci/.nvm"
       [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
-      nvm install v14.19.0
-      nvm alias default v14.19.0
+      nvm install v18
       echo 'export NVM_DIR="/opt/circleci/.nvm"' >> $BASH_ENV
       echo "[ -s \"$NVM_DIR/nvm.sh\" ] && . \"$NVM_DIR/nvm.sh\"" >> $BASH_ENV
-
 jobs:
   unit-test:
     docker:
@@ -32,9 +30,13 @@ jobs:
           command: |
             yarn
       - run:
-          name: Run tests
+          name: Tests ( optimizer.enabled=false )
           command: |
             npm run test:ci
+      - run:
+          name: Tests ( viaIR=true )
+          command: |
+            npm run test:ci:viaIR
       - run:
           name: Upload coverage
           command: |

lib/api.js

@@ -54,6 +54,7 @@ class API {
     this.istanbulFolder = config.istanbulFolder || false;
     this.istanbulReporter = config.istanbulReporter || ['html', 'lcov', 'text', 'json'];
 
+    this.viaIR = config.viaIR;
     this.solcOptimizerDetails = config.solcOptimizerDetails;
 
     this.setLoggingLevel(config.silent);
@@ -176,7 +177,7 @@ class API {
   // Hardhat
   async attachToHardhatVM(provider){
     const self = this;
-    this.collector = new DataCollector(this.instrumenter.instrumentationData);
+    this.collector = new DataCollector(this.instrumenter.instrumentationData, this.viaIR);
 
     if ('init' in provider) {
       // Newer versions of Hardhat initialize the provider lazily, so we need to

lib/collector.js

@@ -3,12 +3,31 @@
  * coverage map constructed by the Instrumenter.
  */
 class DataCollector {
-  constructor(instrumentationData={}){
+  constructor(instrumentationData={}, viaIR){
     this.instrumentationData = instrumentationData;
 
     this.validOpcodes = {
       "PUSH1": true,
+      "DUP1": viaIR,
+      "DUP2": viaIR,
+      "DUP3": viaIR,
+      "DUP4": viaIR,
+      "DUP5": viaIR,
+      "DUP6": viaIR,
+      "DUP7": viaIR,
+      "DUP8": viaIR,
+      "DUP9": viaIR,
+      "DUP10": viaIR,
+      "DUP11": viaIR,
+      "DUP12": viaIR,
+      "DUP13": viaIR,
+      "DUP14": viaIR,
+      "DUP15": viaIR,
+      "DUP16": viaIR,
     }
+
+    this.lastHash = null;
+    this.viaIR = viaIR;
   }
 
   /**
@@ -46,7 +65,26 @@ class DataCollector {
     hash = this._normalizeHash(hash);
 
     if(this.instrumentationData[hash]){
-      this.instrumentationData[hash].hits++;
+      // abi.encode (used to circumvent viaIR) sometimes puts the hash on the stack twice
+      if (this.lastHash !== hash) {
+        this.lastHash = hash;
+        this.instrumentationData[hash].hits++
+      }
+      return;
+    }
+
+    // Detect and recover from viaIR mangled hashes by left-padding single `0`
+    if(this.viaIR && hash.length === 18) {
+      hash = hash.slice(2);
+      hash = '0' + hash;
+      hash = hash.slice(0,16);
+      hash = '0x' + hash;
+      if(this.instrumentationData[hash]){
+        if (this.lastHash !== hash) {
+          this.lastHash = hash;
+          this.instrumentationData[hash].hits++
+        }
+      }
     }
   }
 
@@ -56,10 +94,14 @@ class DataCollector {
    * but prevents left-padding shorter irrelevant hashes
    *
    * @param  {String} hash  data hash from evm stack.
-   * @return {String}       0x prefixed hash of length 66.
+   * @return {String}       0x prefixed hash of length 18.
    */
   _normalizeHash(hash){
-    if (hash.length < 18 && hash.length > 11){
+    // viaIR sometimes right-pads the hashes out to 32 bytes
+    // but it doesn't preserve leading zeroes when it does this
+    if (this.viaIR && hash.length >= 18) {
+      hash = hash.slice(0,18);
+    } else if (hash.length < 18 && hash.length > 11){
       hash = hash.slice(2);
       while(hash.length < 16) hash = '0' + hash;
       hash = '0x' + hash

lib/injector.js

@@ -1,7 +1,8 @@
 const web3Utils = require("web3-utils");
 
 class Injector {
-  constructor(){
+  constructor(viaIR){
+    this.viaIR = viaIR;
     this.hashCounter = 0;
     this.modifierCounter = 0;
     this.modifiers = {};
@@ -23,7 +24,9 @@ class Injector {
       case 'modifier':
         return ` ${this._getModifierIdentifier(id)} `;
       default:
-        return `${this._getDefaultMethodIdentifier(id)}(${hash}); /* ${type} */ \n`;
+        return (this.viaIR)
+          ? `${this._getAbiEncodeStatementHash(hash)} /* ${type} */ \n`
+          : `${this._getDefaultMethodIdentifier(id)}(${hash}); /* ${type} */ \n`;
     }
   }
 
@@ -51,6 +54,16 @@ class Injector {
     return `c_mod${web3Utils.keccak256(id).slice(2,10)}`
   }
 
+  // Way to get hash on the stack with viaIR (which seems to ignore abi.encode builtin)
+  // Tested with v0.8.17, v0.8.24
+    _getAbiEncodeStatementHash(hash){
+    return `abi.encode(${hash}); `
+  }
+
+  _getAbiEncodeStatementVar(hash){
+    return `abi.encode(c__${hash}); `
+  }
+
   _getInjectionComponents(contract, injectionPoint, id, type){
     const { start, end } = this._split(contract, injectionPoint);
     const hash = this._getHash(id)
@@ -73,7 +86,10 @@ class Injector {
   _getDefaultMethodDefinition(id){
     const hash = web3Utils.keccak256(id).slice(2,10);
     const method = this._getDefaultMethodIdentifier(id);
-    return `\nfunction ${method}(bytes8 c__${hash}) internal pure {}\n`;
+
+    return (this.viaIR)
+      ? ``
+      : `\nfunction ${method}(bytes8 c__${hash}) internal pure {}\n`;
   }
 
   /**
@@ -85,7 +101,11 @@ class Injector {
   _getFileScopedHashMethodDefinition(id, contract){
     const hash = web3Utils.keccak256(id).slice(2,10);
     const method = this._getDefaultMethodIdentifier(id);
-    return `\nfunction ${method}(bytes8 c__${hash}) pure {}\n`;
+    const abi = this._getAbiEncodeStatementVar(hash);
+
+    return (this.viaIR)
+      ? `\nfunction ${method}(bytes8 c__${hash}) pure { ${abi} }\n`
+      : `\nfunction ${method}(bytes8 c__${hash}) pure {}\n`;
   }
 
   /**
@@ -97,7 +117,11 @@ class Injector {
   _getTrueMethodDefinition(id){
     const hash = web3Utils.keccak256(id).slice(2,10);
     const method = this._getTrueMethodIdentifier(id);
-    return `function ${method}(bytes8 c__${hash}) internal pure returns (bool){ return true; }\n`;
+    const abi = this._getAbiEncodeStatementVar(hash);
+
+    return (this.viaIR)
+      ? `function ${method}(bytes8 c__${hash}) internal pure returns (bool){ ${abi} return true; }\n`
+      : `function ${method}(bytes8 c__${hash}) internal pure returns (bool){ return true; }\n`;
   }
 
   /**
@@ -110,7 +134,11 @@ class Injector {
   _getFileScopeTrueMethodDefinition(id){
     const hash = web3Utils.keccak256(id).slice(2,10);
     const method = this._getTrueMethodIdentifier(id);
-    return `function ${method}(bytes8 c__${hash}) pure returns (bool){ return true; }\n`;
+    const abi = this._getAbiEncodeStatementVar(hash);
+
+    return (this.viaIR)
+      ? `function ${method}(bytes8 c__${hash}) pure returns (bool){ ${abi} return true; }\n`
+      : `function ${method}(bytes8 c__${hash}) pure returns (bool){ return true; }\n`;
   }
 
   /**
@@ -122,7 +150,11 @@ class Injector {
   _getFalseMethodDefinition(id){
     const hash = web3Utils.keccak256(id).slice(2,10);
     const method = this._getFalseMethodIdentifier(id);
-    return `function ${method}(bytes8 c__${hash}) internal pure returns (bool){ return false; }\n`;
+    const abi = this._getAbiEncodeStatementVar(hash);
+
+    return (this.viaIR)
+      ? `function ${method}(bytes8 c__${hash}) internal pure returns (bool){ ${abi} return false; }\n`
+      : `function ${method}(bytes8 c__${hash}) internal pure returns (bool){ return false; }\n`;
   }
 
   /**
@@ -135,7 +167,11 @@ class Injector {
   _getFileScopedFalseMethodDefinition(id){
     const hash = web3Utils.keccak256(id).slice(2,10);
     const method = this._getFalseMethodIdentifier(id);
-    return `function ${method}(bytes8 c__${hash}) pure returns (bool){ return false; }\n`;
+    const abi = this._getAbiEncodeStatementVar(hash);
+
+    return (this.viaIR)
+      ? `function ${method}(bytes8 c__${hash}) pure returns (bool){ ${abi} return false; }\n`
+      : `function ${method}(bytes8 c__${hash}) pure returns (bool){ return false; }\n`;
   }
 
   _getModifierDefinitions(contractId, instrumentation){

lib/instrumenter.js

@@ -14,7 +14,7 @@ class Instrumenter {
 
   constructor(config={}){
     this.instrumentationData = {};
-    this.injector = new Injector();
+    this.injector = new Injector(config.viaIR);
     this.modifierWhitelist = config.modifierWhitelist || [];
     this.enabled = {
       statements: (config.measureStatementCoverage === false) ? false : true,

package.json

@@ -12,7 +12,10 @@
   "scripts": {
     "test:unit": "./scripts/unit.sh",
     "test:integration": "./scripts/integration.sh",
-    "test:ci": "./scripts/ci.sh"
+    "test:ci": "./scripts/ci.sh",
+    "test:uint:viaIR": "VIA_IR=true ./scripts/unit.sh",
+    "test:integration:viaIR": "VIA_IR=true ./scripts/integration.sh",
+    "test:ci:viaIR": "VIA_IR=true ./scripts/ci.sh"
   },
   "homepage": "https://github.com/sc-forks/solidity-coverage",
   "repository": {

plugins/hardhat.plugin.js

@@ -54,11 +54,14 @@ subtask(TASK_COMPILE_SOLIDITY_GET_COMPILATION_JOB_FOR_FILE).setAction(async (_,
     }
     // Unset useLiteralContent due to solc metadata size restriction
     settings.metadata.useLiteralContent = false;
-    // Override optimizer settings for all compilers
-    settings.optimizer.enabled = false;
 
-    // This is fixes a stack too deep bug in ABIEncoderV2
-    // Experimental because not sure this works as expected across versions....
+    // Beginning with v0.8.7, we let the optimizer run if viaIR is true and
+    // instrument using `abi.encode(bytes8 covHash)`. Otherwise turn the optimizer off.
+    if (!settings.viaIR) settings.optimizer.enabled = false;
+
+    // This sometimes fixed a stack-too-deep bug in ABIEncoderV2 for coverage plugin versions up to 0.8.6
+    // Although issue should be fixed in 0.8.7, am leaving this option in because it may still be necessary
+    // to configure optimizer details in some cases.
     if (configureYulOptimizer) {
       if (optimizerDetails === undefined) {
         settings.optimizer.details = {

plugins/resources/nomiclabs.utils.js

@@ -36,6 +36,10 @@ function normalizeConfig(config, args={}){
     ? sources = path.join(config.paths.sources, args.sources)
     : sources = config.paths.sources;
 
+  if (config.solidity && config.solidity.compilers.length) {
+    config.viaIR = isUsingViaIR(config.solidity);
+  }
+
   config.workingDir = config.paths.root;
   config.contractsDir = sources;
   config.testDir = config.paths.tests;
@@ -55,6 +59,23 @@ function normalizeConfig(config, args={}){
   return config;
 }
 
+function isUsingViaIR(solidity) {
+
+  for (compiler of solidity.compilers) {
+    if (compiler.settings && compiler.settings.viaIR) {
+      return true;
+    }
+  }
+  if (solidity.overrides) {
+    for (key of Object.keys(solidity.overrides)){
+      if (solidity.overrides[key].settings && solidity.overrides[key].settings.viaIR) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 async function setupHardhatNetwork(env, api, ui){
   const hardhatPackage = require('hardhat/package.json');
   const { createProvider } = require("hardhat/internal/core/providers/construction");

plugins/resources/plugin.utils.js

@@ -227,7 +227,9 @@ function loadSolcoverJS(config={}){
     coverageConfig = {};
   }
 
-  // Truffle writes to coverage config
+  // viaIR is eval'd in `nomiclab.utils.normalizeConfig`
+  coverageConfig.viaIR = config.viaIR;
+
   coverageConfig.log = log;
   coverageConfig.cwd = config.workingDir;
   coverageConfig.originalContractsDir = config.contractsDir;

scripts/ci.sh

@@ -1,6 +1,12 @@
 #!/usr/bin/env bash
 
-SILENT=true node --max-old-space-size=4096 \
+# Toggles optimizer on/off
+VIAR_IR=$VIA_IR
+
+# Minimize integration test output
+SILENT=true
+
+node --max-old-space-size=4096 \
   ./node_modules/.bin/nyc \
     --reporter=lcov \
     --exclude '**/sc_temp/**' \

scripts/integration.sh

@@ -1,5 +1,8 @@
 #!/usr/bin/env bash
 
+# Toggles optimizer on/off
+VIA_IR=$VIA_IR
+
 node --max-old-space-size=4096 \
   ./node_modules/.bin/nyc \
     --exclude '**/sc_temp/**' \

scripts/unit.sh

@@ -1,5 +1,8 @@
 #!/usr/bin/env bash
 
+# Toggles optimizer on/off
+VIAR_IR=$VIA_IR
+
 node --max-old-space-size=4096 \
   ./node_modules/.bin/nyc \
     --exclude '**/sc_temp/**' \

scripts/zeppelin.sh

@@ -8,6 +8,7 @@ set -o errexit
 # Get rid of any caches
 sudo rm -rf node_modules
 echo "NVM CURRENT >>>>>" && nvm current
+nvm use 18
 
 # Use PR env variables (for forks) or fallback on local if PR not available
 SED_REGEX="s/git@github.com:/https:\/\/github.com\//"

test/integration/standard.js

@@ -348,6 +348,31 @@ describe('Hardhat Plugin: standard use cases', function() {
     verify.lineCoverage(expected);
   })
 
+  it('detects viaIR when specified in config overrides only', async function(){
+    mock.installFullProject('overrides-viaIR');
+    mock.hardhatSetupEnv(this);
+
+    await this.env.run("coverage");
+
+    const expected = [
+      {
+        file: mock.pathToContract(hardhatConfig, 'ContractOverA2.sol'),
+        pct: 33.33
+      },
+      {
+        file: mock.pathToContract(hardhatConfig, 'ContractOverB2.sol'),
+        pct: 100,
+      },
+      {
+        file: mock.pathToContract(hardhatConfig, 'ContractOverC2.sol'),
+        pct: 100,
+      },
+
+    ];
+
+    verify.lineCoverage(expected);
+  })
+
   it('locates .coverage_contracts correctly when dir is subfolder', async function(){
     mock.installFullProject('contract-subfolders');
     mock.hardhatSetupEnv(this);