Merge pull request #528 from gpujs/524-coverage-compatibility

robertleeplummerjr · web-flow · commit c4f6a1b6877e · 2019-10-29T17:49:56.000-04:00
524 coverage compatibility
diff --git a/README.md b/README.md
@@ -154,6 +154,26 @@ Settings are an object used to create an instance of `GPU`.  Example: `new GPU(s
   * 'webgl2': Use the `WebGL2Kernel` for transpiling a kernel
   * 'headlessgl' **New in V2!**: Use the `HeadlessGLKernel` for transpiling a kernel
   * 'cpu': Use the `CPUKernel` for transpiling a kernel
+* `onIstanbulCoverageVariable`: For testing. Used for when coverage is inject into function values, and is desired to be preserved (`cpu` mode ONLY).
+  Use like this:
+  ```
+  const { getFileCoverageDataByName } = require('istanbul-spy');
+  const gpu = new GPU({
+    mode: 'cpu',
+    onIstanbulCoverageVariable: (name, kernel) => {
+      const data = getFileCoverageDataByName(name);
+      if (!data) {
+        throw new Error(`Could not find istanbul identifier ${name}`);
+      }
+      const { path } = getFileCoverageDataByName(name);
+      const variable = `const ${name} = __coverage__['${path}'];\n`;
+      if (!kernel.hasPrependString(variable)) {
+        kernel.prependString(variable);
+      }
+    }
+  });
+  ```
+* `removeIstanbulCoverage`: Boolean. For testing and code coverage. Removes istanbul artifacts that were injected at testing runtime.
 
 ## `gpu.createKernel` Settings
 Settings are an object used to create a `kernel` or `kernelMap`.  Example: `gpu.createKernel(settings)`
diff --git a/src/backend/cpu/function-node.js b/src/backend/cpu/function-node.js
@@ -466,6 +466,18 @@ class CPUFunctionNode extends FunctionNode {
             return retArr;
         }
         break;
+      case 'value.value[]': // istanbul coverage variable
+        if (this.removeIstanbulCoverage) {
+          return retArr;
+        }
+        retArr.push(`${mNode.object.object.name}.${mNode.object.property.name}[${mNode.property.value}]`);
+        return retArr;
+      case 'value.value[][]': // istanbul coverage variable
+        if (this.removeIstanbulCoverage) {
+          return retArr;
+        }
+        retArr.push(`${mNode.object.object.object.name}.${mNode.object.object.property.name}[${mNode.object.property.value}][${mNode.property.value}]`);
+        return retArr;
       case 'this.constants.value':
       case 'this.constants.value[]':
       case 'this.constants.value[][]':
diff --git a/src/backend/cpu/kernel.js b/src/backend/cpu/kernel.js
@@ -50,6 +50,7 @@ class CPUKernel extends Kernel {
     this._imageData = null;
     this._colorData = null;
     this._kernelString = null;
+    this._prependedString = [];
     this.thread = {
       x: 0,
       y: 0,
@@ -213,7 +214,7 @@ class CPUKernel extends Kernel {
         if (/^function/.test(fn)) return fn;
         kernelThreadString = fn;
         return false;
-      })
+      });
     } else {
       kernelThreadString = translatedSources.shift();
     }
@@ -222,6 +223,7 @@ class CPUKernel extends Kernel {
   const _this = this;
   ${ this._processConstants() }
   return (${ this.argumentNames.map(argumentName => 'user_' + argumentName).join(', ') }) => {
+    ${ this._prependedString.join('') }
     ${ this._processArguments() }
     ${ this.graphical ? this._graphicalKernelBody(kernelThreadString) : this._resultKernelBody(kernelThreadString) }
     ${ translatedSources.length > 0 ? translatedSources.join('\n') : '' }
@@ -520,6 +522,15 @@ class CPUKernel extends Kernel {
       this._colorData = new Uint8ClampedArray(width * height * 4);
     }
   }
+
+  prependString(value) {
+    if (this._kernelString) throw new Error('Kernel already built');
+    this._prependedString.push(value);
+  }
+
+  hasPrependString(value) {
+    return this._prependedString.indexOf(value) > -1;
+  }
 }
 
 module.exports = {
diff --git a/src/backend/function-builder.js b/src/backend/function-builder.js
@@ -36,6 +36,8 @@ class FunctionBuilder {
       dynamicArguments,
       dynamicOutput,
       warnVarUsage,
+      onIstanbulCoverageVariable,
+      removeIstanbulCoverage,
     } = kernel;
 
     const argumentTypes = new Array(kernelArguments.length);
@@ -123,6 +125,9 @@ class FunctionBuilder {
       triggerImplyArgumentType,
       triggerImplyArgumentBitRatio,
       onFunctionCall,
+      warnVarUsage,
+      onIstanbulCoverageVariable: onIstanbulCoverageVariable ? (name) => onIstanbulCoverageVariable(name, kernel) : null,
+      removeIstanbulCoverage,
       optimizeFloatMemory,
       precision,
       constants,
@@ -175,6 +180,8 @@ class FunctionBuilder {
         triggerImplyArgumentBitRatio,
         onFunctionCall,
         onNestedFunction,
+        onIstanbulCoverageVariable: onIstanbulCoverageVariable ? (name) => onIstanbulCoverageVariable(name, kernel) : null,
+        removeIstanbulCoverage,
       }));
     }
 
diff --git a/src/backend/function-node.js b/src/backend/function-node.js
@@ -62,6 +62,8 @@ class FunctionNode {
     this.strictTypingChecking = false;
     this.fixIntegerDivisionAccuracy = null;
     this.warnVarUsage = true;
+    this.onIstanbulCoverageVariable = null;
+    this.removeIstanbulCoverage = false;
 
     if (settings) {
       for (const p in settings) {
@@ -571,6 +573,8 @@ class FunctionNode {
           return null;
         case 'IfStatement':
           return this.getType(ast.consequent);
+        case 'SequenceExpression':
+          return this.getType(ast.expressions[ast.expressions.length - 1]);
         default:
           throw this.astErrorOutput(`Unhandled getType Type "${ ast.type }"`, ast);
     }
@@ -771,6 +775,8 @@ class FunctionNode {
           }
           return dependencies;
         }
+        case 'SequenceExpression':
+          return this.getDependencies(ast.expressions, dependencies, isNotSafe);
         default:
           throw this.astErrorOutput(`Unhandled type ${ ast.type } in getDependencies`, ast);
     }
@@ -827,6 +833,8 @@ class FunctionNode {
       'value[][][]',
       'value[][][][]',
       'value.value',
+      'value.value[]', // istanbul coverage
+      'value.value[][]', // istanbul coverage
       'value.thread.value',
       'this.thread.value',
       'this.output.value',
@@ -1144,12 +1152,28 @@ class FunctionNode {
   astThisExpression(ast, retArr) {
     return retArr;
   }
+  isIstanbulAST(ast) {
+    const variableSignature = this.getVariableSignature(ast);
+    return variableSignature === 'value.value[]' || variableSignature === 'value.value[][]';
+  }
   astSequenceExpression(sNode, retArr) {
-    for (let i = 0; i < sNode.expressions.length; i++) {
-      if (i > 0) {
-        retArr.push(',');
+    const { expressions } = sNode;
+    const sequenceResult = [];
+    for (let i = 0; i < expressions.length; i++) {
+      const expression = expressions[i];
+      if (this.removeIstanbulCoverage) {
+        if (expression.type === 'UpdateExpression' && this.isIstanbulAST(expression.argument)) {
+          continue;
+        }
       }
-      this.astGeneric(sNode.expressions, retArr);
+      const expressionResult = [];
+      this.astGeneric(expression, expressionResult);
+      sequenceResult.push(expressionResult.join(''));
+    }
+    if (sequenceResult.length > 1) {
+      retArr.push('(', sequenceResult.join(','), ')');
+    } else {
+      retArr.push(sequenceResult[0]);
     }
     return retArr;
   }
@@ -1185,6 +1209,12 @@ class FunctionNode {
    * @returns {Array} the append retArr
    */
   astUpdateExpression(uNode, retArr) {
+    if (this.removeIstanbulCoverage) {
+      const signature = this.getVariableSignature(uNode.argument);
+      if (this.isIstanbulAST(uNode.argument)) {
+        return retArr;
+      }
+    }
     if (uNode.prefix) {
       retArr.push(uNode.operator);
       this.astGeneric(uNode.argument, retArr);
@@ -1398,8 +1428,28 @@ class FunctionNode {
             signature: variableSignature,
               property: ast.property,
           };
-        default:
-          throw this.astErrorOutput('Unexpected expression', ast);
+        case 'value.value[]': // istanbul coverage
+          if (this.removeIstanbulCoverage) {
+            return { signature: variableSignature };
+          }
+          if (this.onIstanbulCoverageVariable) {
+            this.onIstanbulCoverageVariable(ast.object.object.name);
+            return {
+              signature: variableSignature
+            };
+          }
+          case 'value.value[][]': // istanbul coverage
+            if (this.removeIstanbulCoverage) {
+              return { signature: variableSignature };
+            }
+            if (this.onIstanbulCoverageVariable) {
+              this.onIstanbulCoverageVariable(ast.object.object.object.name);
+              return {
+                signature: variableSignature
+              };
+            }
+            default:
+              throw this.astErrorOutput('Unexpected expression', ast);
     }
   }
 
diff --git a/src/backend/function-tracer.js b/src/backend/function-tracer.js
@@ -124,6 +124,9 @@ class FunctionTracer {
       case 'ExpressionStatement':
         this.scan(ast.expression);
         break;
+      case 'SequenceExpression':
+        this.scan(ast.expressions);
+        break;
       case 'CallExpression':
         this.functionCalls.push({
           context: this.currentContext,
@@ -155,7 +158,6 @@ class FunctionTracer {
       case 'BreakStatement':
       case 'ContinueStatement':
         break;
-
       default:
         throw new Error(`unhandled type "${ast.type}"`);
     }
diff --git a/src/backend/kernel.js b/src/backend/kernel.js
@@ -200,6 +200,8 @@ class Kernel {
     this.strictIntegers = false;
     this.fixIntegerDivisionAccuracy = null;
     this.warnVarUsage = true;
+    this.onIstanbulCoverageVariable = null;
+    this.removeIstanbulCoverage = false;
   }
 
   /**
@@ -724,6 +726,23 @@ class Kernel {
     }
   }
 
+  /**
+   *
+   * @param {String} value
+   */
+  prependString(value) {
+    throw new Error(`"prependString" called on ${ this.constructor.name }`);
+  }
+
+  /**
+   *
+   * @param {String} value
+   * @return Boolean
+   */
+  hasPrependString(value) {
+    throw new Error(`"hasPrependString" called on ${ this.constructor.name }`);
+  }
+
   /**
    * @return {IJSON}
    */
diff --git a/src/backend/web-gl/function-node.js b/src/backend/web-gl/function-node.js
@@ -1144,8 +1144,13 @@ class WebGLFunctionNode extends FunctionNode {
           retArr.push(this.memberExpressionPropertyMarkup(property));
           retArr.push(']');
           return retArr;
-        default:
-          throw this.astErrorOutput('Unexpected expression', mNode);
+        case 'value.value[]':
+        case 'value.value[][]':
+          if (this.removeIstanbulCoverage) {
+            return retArr;
+          }
+          default:
+            throw this.astErrorOutput('Unexpected expression', mNode);
     }
 
     if (mNode.computed === false) {
diff --git a/src/backend/web-gl/kernel.js b/src/backend/web-gl/kernel.js
@@ -153,6 +153,7 @@ class WebGLKernel extends GLKernel {
     this.maxTexSize = null;
     this.switchingKernels = false;
     this.onRequestSwitchKernel = null;
+    this.removeIstanbulCoverage = true;
 
     this.mergeSettings(source.settings || settings);
 
diff --git a/src/gpu.js b/src/gpu.js
@@ -116,6 +116,8 @@ class GPU {
     this.functions = [];
     this.nativeFunctions = [];
     this.injectedNative = null;
+    this.onIstanbulCoverageVariable = settings.onIstanbulCoverageVariable || null;
+    this.removeIstanbulCoverage = settings.removeIstanbulCoverage || false;
     if (this.mode === 'dev') return;
     this.chooseKernel();
     // add functions from settings
@@ -306,6 +308,8 @@ class GPU {
         validate,
         warnVarUsage: kernel.warnVarUsage,
         returnType: kernel.returnType,
+        onIstanbulCoverageVariable: kernel.onIstanbulCoverageVariable,
+        removeIstanbulCoverage: kernel.removeIstanbulCoverage,
         onRequestFallback,
         onRequestSwitchKernel,
       });
@@ -324,6 +328,8 @@ class GPU {
       functions: this.functions,
       nativeFunctions: this.nativeFunctions,
       injectedNative: this.injectedNative,
+      onIstanbulCoverageVariable: this.onIstanbulCoverageVariable,
+      removeIstanbulCoverage: this.removeIstanbulCoverage,
       gpu: this,
       validate,
       onRequestFallback,
diff --git a/src/index.d.ts b/src/index.d.ts
@@ -46,6 +46,8 @@ export interface IGPUSettings {
   context?: object;
   functions?: KernelFunction[];
   nativeFunctions?: INativeFunctionList;
+  onIstanbulCoverageVariable?: (value: string, kernel: Kernel) => void;
+  removeIstanbulCoverage?: boolean;
   // format: 'Float32Array' | 'Float16Array' | 'Float' // WE WANT THIS!
 }
 
@@ -112,6 +114,8 @@ export abstract class Kernel {
   plugins: IPlugin[];
   useLegacyEncoder: boolean;
   getPixels(flip?: boolean): Uint8ClampedArray[];
+  prependString(value: string): void;
+  hasPrependString(value: string): boolean;
   constructor(kernel: KernelFunction|IJSON, settings?: IDirectKernelSettings);
   build(
     arg1?: KernelVariable,
@@ -413,6 +417,9 @@ export interface IFunctionSettings {
 
   useLegacyEncoder?: boolean;
   ast?: any;
+
+  onIstanbulCoverageVariable?(name: string): void;
+  removeIstanbulCoverage?: boolean;
 }
 
 export interface ISubKernel {
diff --git a/test/all.html b/test/all.html
@@ -71,6 +71,7 @@
 <script type="module" src="features/infinity.js"></script>
 <script type="module" src="features/inject-native.js"></script>
 <script type="module" src="features/input.js"></script>
+<script type="module" src="features/istanbul.js"></script>
 <script type="module" src="features/json.js"></script>
 <script type="module" src="features/legacy-encoder.js"></script>
 <script type="module" src="features/loops.js"></script>
diff --git a/test/features/istanbul.js b/test/features/istanbul.js
diff --git a/test/internal/function-tracer.js b/test/internal/function-tracer.js
diff --git a/test/internal/math.random.js b/test/internal/math.random.js
diff --git a/test/internal/overloading.js b/test/internal/overloading.js
