as-test 1.1.1 → 1.1.3

package/transform/lib/coverage.js

@@ -2,12 +2,6 @@ import { BlockStatement, ExpressionStatement, Node, } from "assemblyscript/dist/
 import { RangeTransform } from "./range.js";
 import { isStdlib, SimpleParser } from "./util.js";
 import { Visitor } from "./visitor.js";
-var CoverType;
-(function (CoverType) {
-    CoverType[CoverType["Function"] = 0] = "Function";
-    CoverType[CoverType["Expression"] = 1] = "Expression";
-    CoverType[CoverType["Block"] = 2] = "Block";
-})(CoverType || (CoverType = {}));
 const COVERAGE_IGNORED_CALLS = new Set([
     "beforeAll",
     "afterAll",
@@ -50,13 +44,106 @@ class CoverPoint {
     hash = "";
     line = 0;
     column = 0;
-    type;
+    type = "Expression";
     executed = false;
+    parentHash = "";
+    scopeKind = "";
+    scopeName = "";
+    depth = 0;
 }
 export class CoverageTransform extends Visitor {
     mustImport = false;
     points = new Map();
     globalStatements = [];
+    scopeStack = [];
+    getCurrentScope() {
+        return this.scopeStack.length
+            ? this.scopeStack[this.scopeStack.length - 1]
+            : null;
+    }
+    withScope(point, callback) {
+        this.scopeStack.push(point);
+        try {
+            callback();
+        }
+        finally {
+            this.scopeStack.pop();
+        }
+    }
+    assignParentMetadata(point) {
+        const currentScope = this.getCurrentScope();
+        if (!currentScope)
+            return;
+        point.parentHash = currentScope.hash;
+        point.scopeKind = currentScope.scopeKind;
+        point.scopeName = currentScope.scopeName;
+        point.depth = currentScope.depth + 1;
+    }
+    assignScopeMetadata(point, scopeKind, scopeName = null) {
+        point.scopeKind = scopeKind;
+        point.scopeName = scopeName ?? "";
+    }
+    createFunctionPoint(path, node, scopeKind, scopeName = null) {
+        const funcLc = getLineCol(node);
+        const point = new CoverPoint();
+        point.line = funcLc?.line;
+        point.column = funcLc?.column;
+        point.file = path;
+        point.type = scopeKind;
+        this.assignParentMetadata(point);
+        this.assignScopeMetadata(point, scopeKind, scopeName);
+        point.hash = hash(point);
+        return point;
+    }
+    createPoint(path, node, type) {
+        const lc = getLineCol(node);
+        const point = new CoverPoint();
+        point.line = lc?.line;
+        point.column = lc?.column;
+        point.file = path;
+        point.type = type;
+        this.assignParentMetadata(point);
+        point.hash = hash(point);
+        return point;
+    }
+    instrumentStatementBody(path, node, type) {
+        const point = this.createPoint(path, node, type);
+        const replacer = new RangeTransform(node);
+        const registerStmt = createRegisterStatement(point);
+        replacer.visit(registerStmt);
+        const coverStmt = createCoverStatement(point.hash, node);
+        replacer.visit(coverStmt);
+        this.globalStatements.push(registerStmt);
+        if (node.kind == 31) {
+            const block = node;
+            block.statements.unshift(coverStmt);
+            return block;
+        }
+        const coverBlock = Node.createBlockStatement([coverStmt], node.range);
+        replacer.visit(coverBlock);
+        coverBlock.statements.push(node);
+        return coverBlock;
+    }
+    isAssignmentOperator(operator) {
+        switch (operator) {
+            case 101:
+            case 102:
+            case 103:
+            case 104:
+            case 105:
+            case 106:
+            case 107:
+            case 108:
+            case 109:
+            case 110:
+            case 111:
+            case 112:
+            case 113:
+                return true;
+            default:
+                return false;
+        }
+    }
     visitCallExpression(node) {
         const callName = getCallName(node);
         if (callName && COVERAGE_IGNORED_CALLS.has(callName)) {
@@ -89,7 +176,8 @@ export class CoverageTransform extends Visitor {
                 point.line = rightLc?.line;
                 point.column = rightLc?.column;
                 point.file = path;
-                point.type = CoverType.Expression;
+                point.type = "LogicalBranch";
+                this.assignParentMetadata(point);
                 point.hash = hash(point);
                 const replacer = new RangeTransform(node);
                 const registerStmt = createRegisterStatement(point);
@@ -100,10 +188,25 @@ export class CoverageTransform extends Visitor {
                 this.globalStatements.push(registerStmt);
                 break;
             }
+            default: {
+                if (!this.isAssignmentOperator(node.operator))
+                    break;
+                const right = node.right;
+                if (isBuiltinCallExpression(right))
+                    break;
+                const point = this.createPoint(path, right, "Assignment");
+                const replacer = new RangeTransform(node);
+                const registerStmt = createRegisterStatement(point);
+                replacer.visit(registerStmt);
+                const coverExpression = createCoverExpression(point.hash, right, node);
+                replacer.visit(coverExpression);
+                node.right = coverExpression;
+                this.globalStatements.push(registerStmt);
+                break;
+            }
         }
     }
     visitMethodDeclaration(node) {
-        super.visitMethodDeclaration(node);
         if (node.visited)
             return;
         node.visited = true;
@@ -112,13 +215,9 @@ export class CoverageTransform extends Visitor {
                 return;
             node.body.visited = true;
             const path = node.range.source.normalizedPath;
-            const funcLc = getLineCol(node);
-            const point = new CoverPoint();
-            point.line = funcLc?.line;
-            point.column = funcLc?.column;
-            point.file = path;
-            point.type = CoverType.Function;
-            point.hash = hash(point);
+            const methodName = getNodeName(node.name);
+            const scopeKind = methodName == "constructor" ? "Constructor" : "Method";
+            const point = this.createFunctionPoint(path, node, scopeKind, methodName);
             const replacer = new RangeTransform(node);
             const registerStmt = createRegisterStatement(point);
             replacer.visit(registerStmt);
@@ -127,6 +226,13 @@ export class CoverageTransform extends Visitor {
             const bodyBlock = node.body;
             bodyBlock.statements.unshift(coverStmt);
             this.globalStatements.push(registerStmt);
+            this.withScope(point, () => {
+                this.visit(node.name, node);
+                this.visit(node.typeParameters, node);
+                this.visit(node.signature, node);
+                this.visit(node.decorators, node);
+                this.visit(bodyBlock.statements, bodyBlock);
+            });
         }
     }
     visitParameter(node) {
@@ -146,7 +252,8 @@ export class CoverageTransform extends Visitor {
             point.line = paramLc?.line;
             point.column = paramLc?.column;
             point.file = path;
-            point.type = CoverType.Expression;
+            point.type = "DefaultValue";
+            this.assignParentMetadata(point);
             point.hash = hash(point);
             const replacer = new RangeTransform(node);
             const registerStmt = createRegisterStatement(point);
@@ -158,7 +265,6 @@ export class CoverageTransform extends Visitor {
         }
     }
     visitFunctionDeclaration(node, isDefault) {
-        super.visitFunctionDeclaration(node, isDefault);
         if (node.visited)
             return;
         node.visited = true;
@@ -167,13 +273,7 @@ export class CoverageTransform extends Visitor {
                 return;
             node.body.visited = true;
             const path = node.range.source.normalizedPath;
-            const funcLc = getLineCol(node);
-            const point = new CoverPoint();
-            point.line = funcLc?.line;
-            point.column = funcLc?.column;
-            point.file = path;
-            point.type = CoverType.Function;
-            point.hash = hash(point);
+            const point = this.createFunctionPoint(path, node, "Function", node.name?.text ?? null);
             const replacer = new RangeTransform(node);
             const registerStmt = createRegisterStatement(point);
             replacer.visit(registerStmt);
@@ -202,6 +302,18 @@ export class CoverageTransform extends Visitor {
                     const bodyBlock = node.body;
                     bodyBlock.statements.unshift(coverStmt);
                 }
+                this.withScope(point, () => {
+                    this.visit(node.name, node);
+                    this.visit(node.decorators, node);
+                    this.visit(node.typeParameters, node);
+                    this.visit(node.signature, node);
+                    if (node.body instanceof BlockStatement) {
+                        this.visit(node.body.statements, node.body);
+                    }
+                    else {
+                        this.visit(node.body, node);
+                    }
+                });
             }
         }
     }
@@ -214,43 +326,17 @@ export class CoverageTransform extends Visitor {
         const ifTrue = node.ifTrue;
         const ifFalse = node.ifFalse;
         const path = node.range.source.normalizedPath;
-        if (ifTrue.kind !== 31 && !isBuiltinStatement(ifTrue)) {
-            const trueLc = getLineCol(ifTrue);
-            const point = new CoverPoint();
-            point.line = trueLc?.line;
-            point.column = trueLc?.column;
-            point.file = path;
-            point.type = CoverType.Expression;
-            point.hash = hash(point);
-            const replacer = new RangeTransform(ifTrue);
-            const registerStmt = createRegisterStatement(point);
-            replacer.visit(registerStmt);
-            const coverStmt = Node.createBlockStatement([createCoverStatement(point.hash, ifTrue)], ifTrue.range);
-            replacer.visit(coverStmt);
-            coverStmt.statements.push(ifTrue);
-            node.ifTrue = coverStmt;
-            this.globalStatements.push(registerStmt);
+        if (ifTrue &&
+            ifTrue.kind !== 31 &&
+            !isBuiltinStatement(ifTrue)) {
+            node.ifTrue = this.instrumentStatementBody(path, ifTrue, "IfBranch");
             visitIfTrue = true;
             visitIfFalse = !!ifFalse;
         }
         if (ifFalse &&
             ifFalse.kind !== 31 &&
             !isBuiltinStatement(ifFalse)) {
-            const falseLc = getLineCol(ifFalse);
-            const point = new CoverPoint();
-            point.line = falseLc?.line;
-            point.column = falseLc?.column;
-            point.file = path;
-            point.type = CoverType.Expression;
-            point.hash = hash(point);
-            const replacer = new RangeTransform(ifFalse);
-            const registerStmt = createRegisterStatement(point);
-            replacer.visit(registerStmt);
-            const coverStmt = Node.createBlockStatement([createCoverStatement(point.hash, ifFalse)], ifFalse.range);
-            replacer.visit(coverStmt);
-            coverStmt.statements.push(ifFalse);
-            node.ifFalse = coverStmt;
-            this.globalStatements.push(registerStmt);
+            node.ifFalse = this.instrumentStatementBody(path, ifFalse, "IfBranch");
             visitIfTrue = true;
             visitIfFalse = true;
         }
@@ -287,7 +373,8 @@ export class CoverageTransform extends Visitor {
                 point.line = trueLc?.line;
                 point.column = trueLc?.column;
                 point.file = path;
-                point.type = CoverType.Expression;
+                point.type = "Ternary";
+                this.assignParentMetadata(point);
                 point.hash = hash(point);
                 const replacer = new RangeTransform(trueExpression);
                 const registerStmt = createRegisterStatement(point);
@@ -305,7 +392,8 @@ export class CoverageTransform extends Visitor {
                 point.line = falseLc?.line;
                 point.column = falseLc?.column;
                 point.file = path;
-                point.type = CoverType.Expression;
+                point.type = "Ternary";
+                this.assignParentMetadata(point);
                 point.hash = hash(point);
                 const replacer = new RangeTransform(falseExpression);
                 const registerStmt = createRegisterStatement(point);
@@ -317,6 +405,72 @@ export class CoverageTransform extends Visitor {
             }
         }
     }
+    visitForStatement(node) {
+        if (node.visited)
+            return;
+        node.visited = true;
+        const path = node.range.source.normalizedPath;
+        node.body = this.instrumentStatementBody(path, node.body, "Loop");
+        super.visitForStatement(node);
+    }
+    visitForOfStatement(node) {
+        if (node.visited)
+            return;
+        node.visited = true;
+        const path = node.range.source.normalizedPath;
+        node.body = this.instrumentStatementBody(path, node.body, "Loop");
+        super.visitForOfStatement(node);
+    }
+    visitWhileStatement(node) {
+        if (node.visited)
+            return;
+        node.visited = true;
+        const path = node.range.source.normalizedPath;
+        node.body = this.instrumentStatementBody(path, node.body, "Loop");
+        super.visitWhileStatement(node);
+    }
+    visitDoStatement(node) {
+        if (node.visited)
+            return;
+        node.visited = true;
+        const path = node.range.source.normalizedPath;
+        node.body = this.instrumentStatementBody(path, node.body, "Loop");
+        super.visitDoStatement(node);
+    }
+    visitReturnStatement(node) {
+        if (node.visited)
+            return;
+        node.visited = true;
+        super.visitReturnStatement(node);
+        if (!node.value || isBuiltinCallExpression(node.value))
+            return;
+        const path = node.range.source.normalizedPath;
+        const point = this.createPoint(path, node.value, "Return");
+        const replacer = new RangeTransform(node);
+        const registerStmt = createRegisterStatement(point);
+        replacer.visit(registerStmt);
+        const coverExpression = createCoverExpression(point.hash, node.value, node);
+        replacer.visit(coverExpression);
+        node.value = coverExpression;
+        this.globalStatements.push(registerStmt);
+    }
+    visitThrowStatement(node) {
+        if (node.visited)
+            return;
+        node.visited = true;
+        super.visitThrowStatement(node);
+        if (!node.value || isBuiltinCallExpression(node.value))
+            return;
+        const path = node.range.source.normalizedPath;
+        const point = this.createPoint(path, node.value, "Throw");
+        const replacer = new RangeTransform(node);
+        const registerStmt = createRegisterStatement(point);
+        replacer.visit(registerStmt);
+        const coverExpression = createCoverExpression(point.hash, node.value, node);
+        replacer.visit(coverExpression);
+        node.value = coverExpression;
+        this.globalStatements.push(registerStmt);
+    }
     visitSwitchCase(node) {
         if (node.visited)
             return;
@@ -327,7 +481,8 @@ export class CoverageTransform extends Visitor {
         point.line = caseLc?.line;
         point.column = caseLc?.column;
         point.file = path;
-        point.type = CoverType.Block;
+        point.type = "SwitchCase";
+        this.assignParentMetadata(point);
         point.hash = hash(point);
         const replacer = new RangeTransform(node);
         const registerStmt = createRegisterStatement(point);
@@ -352,7 +507,8 @@ export class CoverageTransform extends Visitor {
         point.line = blockLc?.line;
         point.column = blockLc?.column;
         point.file = path;
-        point.type = CoverType.Block;
+        point.type = "Block";
+        this.assignParentMetadata(point);
         point.hash = hash(point);
         const replacer = new RangeTransform(node);
         const registerStmt = createRegisterStatement(point);
@@ -411,6 +567,11 @@ function getExpressionName(node) {
             return null;
     }
 }
+function getNodeName(node) {
+    if (!node)
+        return null;
+    return getExpressionName(node);
+}
 function djb2Hash(str) {
     const points = Array.from(str);
     let h = 5381;
@@ -442,7 +603,7 @@ function getLineCol(node) {
     };
 }
 function createRegisterStatement(point) {
-    return SimpleParser.parseTopLevelStatement(`__REGISTER_RAW(${asStringLiteral(point.file)}, ${asStringLiteral(point.hash)}, ${point.line}, ${point.column}, ${asStringLiteral(coverTypeToString(point.type))})`);
+    return SimpleParser.parseTopLevelStatement(`__REGISTER_RAW(${asStringLiteral(point.file)}, ${asStringLiteral(point.hash)}, ${point.line}, ${point.column}, ${asStringLiteral(point.type)}, ${asStringLiteral(point.parentHash)}, ${asStringLiteral(point.scopeKind)}, ${asStringLiteral(point.scopeName)}, ${point.depth})`);
 }
 function createCoverStatement(hashValue, ref) {
     return Node.createExpressionStatement(createCoverCallExpression(hashValue, ref));
@@ -453,16 +614,6 @@ function createCoverExpression(hashValue, replacement, ref) {
 function createCoverCallExpression(hashValue, ref) {
     return Node.createCallExpression(Node.createIdentifierExpression("__COVER", ref.range), null, [Node.createStringLiteralExpression(hashValue, ref.range)], ref.range);
 }
-function coverTypeToString(type) {
-    switch (type) {
-        case CoverType.Function:
-            return "Function";
-        case CoverType.Expression:
-            return "Expression";
-        default:
-            return "Block";
-    }
-}
 function asStringLiteral(value) {
     return JSON.stringify(value);
 }