as-test 0.5.1 → 0.5.3

package/transform/lib/coverage.js

@@ -12,7 +12,36 @@ const COVERAGE_IGNORED_CALLS = new Set([
     "beforeAll",
     "afterAll",
     "mockFn",
+    "unmockFn",
     "mockImport",
+    "unmockImport",
+    "snapshotImport",
+    "restoreImport",
+]);
+const COVERAGE_IGNORED_BUILTINS = new Set([
+    "alignof",
+    "changetype",
+    "idof",
+    "isArray",
+    "isArrayLike",
+    "isBoolean",
+    "isConstant",
+    "isDefined",
+    "isFloat",
+    "isFunction",
+    "isInteger",
+    "isManaged",
+    "isNullable",
+    "isReference",
+    "isSigned",
+    "isString",
+    "isUnsigned",
+    "load",
+    "nameof",
+    "offsetof",
+    "sizeof",
+    "store",
+    "unchecked",
 ]);
 class CoverPoint {
     file = "";
@@ -40,6 +69,7 @@ export class CoverageTransform extends Visitor {
         }
         super.visitCallExpression(node);
     }
+    visitDecoratorNode(_node, _ref) { }
     visitBinaryExpression(node) {
         super.visitBinaryExpression(node);
         if (node.visited)
@@ -50,6 +80,8 @@ export class CoverageTransform extends Visitor {
             case 98:
             case 97: {
                 const right = node.right;
+                if (isBuiltinCallExpression(right))
+                    break;
                 const rightLc = getLineCol(node);
                 const point = new CoverPoint();
                 point.line = rightLc?.line;
@@ -58,18 +90,10 @@ export class CoverageTransform extends Visitor {
                 point.type = CoverType.Expression;
                 point.hash = hash(point);
                 const replacer = new RangeTransform(node);
-                const registerStmt = SimpleParser.parseTopLevelStatement(`__REGISTER({
-                        file: "${point.file}",
-                        hash: "${point.hash}",
-                        line: ${point.line},
-                        column: ${point.column},
-                        type: "Expression",
-                        executed: false
-                    });`);
+                const registerStmt = createRegisterStatement(point);
                 replacer.visit(registerStmt);
-                const coverExpression = SimpleParser.parseExpression(`(__COVER("${point.hash}"), $$REPLACE_ME)`);
+                const coverExpression = createCoverExpression(point.hash, right, node);
                 replacer.visit(coverExpression);
-                coverExpression.expression.expressions[1] = right;
                 node.right = coverExpression;
                 this.globalStatements.push(registerStmt);
                 break;
@@ -94,16 +118,9 @@ export class CoverageTransform extends Visitor {
             point.type = CoverType.Function;
             point.hash = hash(point);
             const replacer = new RangeTransform(node);
-            const registerStmt = SimpleParser.parseTopLevelStatement(`__REGISTER({
-                    file: "${point.file}",
-                    hash: "${point.hash}",
-                    line: ${point.line},
-                    column: ${point.column},
-                    type: "Function",
-                    executed: false
-                })`);
+            const registerStmt = createRegisterStatement(point);
             replacer.visit(registerStmt);
-            const coverStmt = SimpleParser.parseStatement(`__COVER("${point.hash}")`, true);
+            const coverStmt = createCoverStatement(point.hash, node);
             replacer.visit(coverStmt);
             const bodyBlock = node.body;
             bodyBlock.statements.unshift(coverStmt);
@@ -120,6 +137,8 @@ export class CoverageTransform extends Visitor {
                 return;
             node.initializer.visited = true;
             super.visitParameter(node);
+            if (isBuiltinCallExpression(node.initializer))
+                return;
             const paramLc = getLineCol(node.initializer);
             const point = new CoverPoint();
             point.line = paramLc?.line;
@@ -128,19 +147,10 @@ export class CoverageTransform extends Visitor {
             point.type = CoverType.Expression;
             point.hash = hash(point);
             const replacer = new RangeTransform(node);
-            const registerStmt = SimpleParser.parseTopLevelStatement(`__REGISTER({
-                    file: "${point.file}",
-                    hash: "${point.hash}",
-                    line: ${point.line},
-                    column: ${point.column},
-                    type: "Expression",
-                    executed: false
-                })`);
+            const registerStmt = createRegisterStatement(point);
             replacer.visit(registerStmt);
-            const coverExpression = SimpleParser.parseExpression(`(__COVER("${point.hash}"), $$REPLACE_ME)`);
+            const coverExpression = createCoverExpression(point.hash, node.initializer, node);
             replacer.visit(coverExpression);
-            coverExpression.expression.expressions[1] =
-                node.initializer;
             node.initializer = coverExpression;
             this.globalStatements.push(registerStmt);
         }
@@ -163,14 +173,7 @@ export class CoverageTransform extends Visitor {
             point.type = CoverType.Function;
             point.hash = hash(point);
             const replacer = new RangeTransform(node);
-            const registerStmt = SimpleParser.parseTopLevelStatement(`__REGISTER({
-                    file: "${point.file}",
-                    hash: "${point.hash}",
-                    line: ${point.line},
-                    column: ${point.column},
-                    type: "Function",
-                    executed: false
-                })`);
+            const registerStmt = createRegisterStatement(point);
             replacer.visit(registerStmt);
             this.globalStatements.push(registerStmt);
             if (node.body.kind === 35) {
@@ -186,7 +189,7 @@ export class CoverageTransform extends Visitor {
                 node.body = body;
             }
             else {
-                const coverStmt = SimpleParser.parseStatement(`__COVER("${point.hash}")`, true);
+                const coverStmt = createCoverStatement(point.hash, node);
                 replacer.visit(coverStmt);
                 if (node.body instanceof BlockStatement) {
                     node.body.statements.unshift(coverStmt);
@@ -209,7 +212,7 @@ export class CoverageTransform extends Visitor {
         const ifTrue = node.ifTrue;
         const ifFalse = node.ifFalse;
         const path = node.range.source.normalizedPath;
-        if (ifTrue.kind !== 30) {
+        if (ifTrue.kind !== 30 && !isBuiltinStatement(ifTrue)) {
             const trueLc = getLineCol(ifTrue);
             const point = new CoverPoint();
             point.line = trueLc?.line;
@@ -218,16 +221,9 @@ export class CoverageTransform extends Visitor {
             point.type = CoverType.Expression;
             point.hash = hash(point);
             const replacer = new RangeTransform(ifTrue);
-            const registerStmt = SimpleParser.parseTopLevelStatement(`__REGISTER({
-                    file: "${point.file}",
-                    hash: "${point.hash}",
-                    line: ${point.line},
-                    column: ${point.column},
-                    type: "Expression",
-                    executed: false
-                })`);
+            const registerStmt = createRegisterStatement(point);
             replacer.visit(registerStmt);
-            const coverStmt = SimpleParser.parseStatement(`{__COVER("${point.hash}")};`, true);
+            const coverStmt = Node.createBlockStatement([createCoverStatement(point.hash, ifTrue)], ifTrue.range);
             replacer.visit(coverStmt);
             coverStmt.statements.push(ifTrue);
             node.ifTrue = coverStmt;
@@ -235,7 +231,9 @@ export class CoverageTransform extends Visitor {
             visitIfTrue = true;
             visitIfFalse = !!ifFalse;
         }
-        if (ifFalse && ifFalse.kind !== 30) {
+        if (ifFalse &&
+            ifFalse.kind !== 30 &&
+            !isBuiltinStatement(ifFalse)) {
             const falseLc = getLineCol(ifFalse);
             const point = new CoverPoint();
             point.line = falseLc?.line;
@@ -243,17 +241,10 @@ export class CoverageTransform extends Visitor {
             point.file = path;
             point.type = CoverType.Expression;
             point.hash = hash(point);
-            const replacer = new RangeTransform(ifTrue);
-            const registerStmt = SimpleParser.parseTopLevelStatement(`__REGISTER({
-                    file: "${point.file}",
-                    hash: "${point.hash}",
-                    line: ${point.line},
-                    column: ${point.column},
-                    type: "Expression",
-                    executed: false
-                })`);
+            const replacer = new RangeTransform(ifFalse);
+            const registerStmt = createRegisterStatement(point);
             replacer.visit(registerStmt);
-            const coverStmt = SimpleParser.parseStatement(`{__COVER("${point.hash}")};`, true);
+            const coverStmt = Node.createBlockStatement([createCoverStatement(point.hash, ifFalse)], ifFalse.range);
             replacer.visit(coverStmt);
             coverStmt.statements.push(ifFalse);
             node.ifFalse = coverStmt;
@@ -288,54 +279,40 @@ export class CoverageTransform extends Visitor {
         const falseExpression = node.ifElse;
         const path = node.range.source.normalizedPath;
         {
-            const trueLc = getLineCol(trueExpression);
-            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(trueExpression);
-            const registerStmt = SimpleParser.parseTopLevelStatement(`__REGISTER({
-                    file: "${point.file}",
-                    hash: "${point.hash}",
-                    line: ${point.line},
-                    column: ${point.column},
-                    type: "Expression",
-                    executed: false
-                })`);
-            replacer.visit(registerStmt);
-            const coverExpression = SimpleParser.parseExpression(`(__COVER("${point.hash}"), $$REPLACE_ME)`);
-            replacer.visit(coverExpression);
-            coverExpression.expression.expressions[1] =
-                trueExpression;
-            node.ifThen = coverExpression;
-            this.globalStatements.push(registerStmt);
+            if (!isBuiltinCallExpression(trueExpression)) {
+                const trueLc = getLineCol(trueExpression);
+                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(trueExpression);
+                const registerStmt = createRegisterStatement(point);
+                replacer.visit(registerStmt);
+                const coverExpression = createCoverExpression(point.hash, trueExpression, trueExpression);
+                replacer.visit(coverExpression);
+                node.ifThen = coverExpression;
+                this.globalStatements.push(registerStmt);
+            }
         }
         {
-            const falseLc = getLineCol(falseExpression);
-            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(falseExpression);
-            const registerStmt = SimpleParser.parseTopLevelStatement(`__REGISTER({
-                    file: "${point.file}",
-                    hash: "${point.hash}",
-                    line: ${point.line},
-                    column: ${point.column},
-                    type: "Expression",
-                    executed: false
-                })`);
-            replacer.visit(registerStmt);
-            const coverExpression = SimpleParser.parseExpression(`(__COVER("${point.hash}"), $$REPLACE_ME)`);
-            replacer.visit(coverExpression);
-            coverExpression.expression.expressions[1] =
-                falseExpression;
-            node.ifElse = coverExpression;
-            this.globalStatements.push(registerStmt);
+            if (!isBuiltinCallExpression(falseExpression)) {
+                const falseLc = getLineCol(falseExpression);
+                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(falseExpression);
+                const registerStmt = createRegisterStatement(point);
+                replacer.visit(registerStmt);
+                const coverExpression = createCoverExpression(point.hash, falseExpression, falseExpression);
+                replacer.visit(coverExpression);
+                node.ifElse = coverExpression;
+                this.globalStatements.push(registerStmt);
+            }
         }
     }
     visitSwitchCase(node) {
@@ -351,16 +328,9 @@ export class CoverageTransform extends Visitor {
         point.type = CoverType.Block;
         point.hash = hash(point);
         const replacer = new RangeTransform(node);
-        const registerStmt = SimpleParser.parseTopLevelStatement(`__REGISTER({
-                file: "${point.file}",
-                hash: "${point.hash}",
-                line: ${point.line},
-                column: ${point.column},
-                type: "Block",
-                executed: false
-            })`);
+        const registerStmt = createRegisterStatement(point);
         replacer.visit(registerStmt);
-        const coverStmt = SimpleParser.parseStatement(`__COVER("${point.hash}")`);
+        const coverStmt = createCoverStatement(point.hash, node);
         replacer.visit(coverStmt);
         this.globalStatements.push(registerStmt);
         super.visitSwitchCase(node);
@@ -383,16 +353,9 @@ export class CoverageTransform extends Visitor {
         point.type = CoverType.Block;
         point.hash = hash(point);
         const replacer = new RangeTransform(node);
-        const registerStmt = SimpleParser.parseTopLevelStatement(`__REGISTER({
-                file: "${point.file}",
-                hash: "${point.hash}",
-                line: ${point.line},
-                column: ${point.column},
-                type: "Block",
-                executed: false
-            })`);
+        const registerStmt = createRegisterStatement(point);
         replacer.visit(registerStmt);
-        const coverStmt = SimpleParser.parseStatement(`__COVER("${point.hash}")`);
+        const coverStmt = createCoverStatement(point.hash, node);
         replacer.visit(coverStmt);
         this.globalStatements.push(registerStmt);
         super.visitBlockStatement(node);
@@ -411,6 +374,29 @@ export class CoverageTransform extends Visitor {
 function getCallName(node) {
     return getExpressionName(node.expression);
 }
+function isBuiltinStatement(node) {
+    if (node.kind !== 38)
+        return false;
+    return isBuiltinCallExpression(node.expression);
+}
+function isBuiltinCallExpression(node) {
+    const unwrapped = unwrapParenthesized(node);
+    if (unwrapped.kind !== 9)
+        return false;
+    const call = unwrapped;
+    const expression = unwrapParenthesized(call.expression);
+    if (expression.kind !== 6)
+        return false;
+    const name = expression.text;
+    return COVERAGE_IGNORED_BUILTINS.has(name);
+}
+function unwrapParenthesized(node) {
+    let current = node;
+    while (current.kind === 20) {
+        current = current.expression;
+    }
+    return current;
+}
 function getExpressionName(node) {
     switch (node.kind) {
         case 6:
@@ -453,6 +439,31 @@ function getLineCol(node) {
         column: node.range.source.columnAt(),
     };
 }
+function createRegisterStatement(point) {
+    return SimpleParser.parseTopLevelStatement(`__REGISTER_RAW(${asStringLiteral(point.file)}, ${asStringLiteral(point.hash)}, ${point.line}, ${point.column}, ${asStringLiteral(coverTypeToString(point.type))})`);
+}
+function createCoverStatement(hashValue, ref) {
+    return Node.createExpressionStatement(createCoverCallExpression(hashValue, ref));
+}
+function createCoverExpression(hashValue, replacement, ref) {
+    return Node.createParenthesizedExpression(Node.createCommaExpression([createCoverCallExpression(hashValue, ref), replacement], ref.range), ref.range);
+}
+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);
+}
 function isConcreteSourceBlock(node) {
     const source = node.range.source;
     const start = node.range.start;

package/transform/lib/index.js

@@ -8,9 +8,9 @@ import { isStdlib } from "./util.js";
 export default class Transformer extends Transform {
     afterParse(parser) {
         const mock = new MockTransform();
-        const coverage = new CoverageTransform();
         const location = new LocationTransform();
         const log = new LogTransform(parser);
+        const coverage = isCoverageEnabled() ? new CoverageTransform() : null;
         const sources = parser.sources
             .filter((source) => !isStdlib(source))
             .sort((_a, _b) => {
@@ -27,19 +27,31 @@ export default class Transformer extends Transform {
             }
         });
         const entryFile = sources.find((v) => v.sourceKind == 1).simplePath;
+        const mockedImportTargets = collectMockImportTargets(sources);
+        for (const target of mockedImportTargets) {
+            mock.importMocked.add(target);
+        }
         for (const source of sources) {
+            const sourceInfo = analyzeSourceText(source.text);
             const shouldInjectRunCall = source.sourceKind == 1 &&
-                shouldAutoInjectRun(source.text);
+                sourceInfo.hasSuiteCalls &&
+                !sourceInfo.hasRunCall;
             const node = Node.createVariableStatement(null, [
                 Node.createVariableDeclaration(Node.createIdentifierExpression("ENTRY_FILE", source.range), null, 8, null, Node.createStringLiteralExpression(entryFile + ".ts", source.range), source.range),
             ], source.range);
             source.statements.unshift(node);
             mock.visit(source);
-            coverage.visit(source);
-            location.visit(source);
-            log.visit(source);
+            if (coverage) {
+                coverage.visit(source);
+            }
+            if (sourceInfo.hasExpectCall) {
+                location.visit(source);
+            }
+            if (sourceInfo.hasLogCall) {
+                log.visit(source);
+            }
             if (shouldInjectRunCall) {
-                const runImportPath = detectRunImportPath(source.text);
+                const runImportPath = sourceInfo.runImportPath;
                 let runCall = "run();";
                 if (runImportPath) {
                     const autoImport = new Tokenizer(new Source(0, source.normalizedPath, `import { run as __as_test_auto_run } from "${runImportPath}";`));
@@ -52,31 +64,51 @@ export default class Transformer extends Transform {
                 source.statements.push(parser.parseTopLevelStatement(autoCall));
                 parser.currentSource = source;
             }
-            if (coverage.globalStatements.length) {
+            if (coverage && coverage.globalStatements.length) {
                 source.statements.unshift(...coverage.globalStatements);
-                const tokenizer = new Tokenizer(new Source(0, source.normalizedPath, 'import { __REGISTER, __COVER } from "as-test/assembly/coverage";'));
+                const tokenizer = new Tokenizer(new Source(0, source.normalizedPath, 'import { __REGISTER_RAW, __COVER } from "as-test/assembly/coverage";'));
                 parser.currentSource = tokenizer.source;
                 source.statements.unshift(parser.parseTopLevelStatement(tokenizer));
                 parser.currentSource = source;
+                coverage.globalStatements = [];
             }
         }
-        coverage.globalStatements = [];
+        if (coverage) {
+            coverage.globalStatements = [];
+        }
     }
 }
-function shouldAutoInjectRun(sourceText) {
-    const text = stripComments(sourceText);
-    const hasSuiteCalls = /\b(?:describe|test|it)\s*\(/.test(text);
-    if (!hasSuiteCalls)
-        return false;
-    const runAlias = detectRunAlias(text);
-    if (runAlias && new RegExp(`\\b${escapeRegex(runAlias)}\\s*\\(`).test(text)) {
-        return false;
+function collectMockImportTargets(sources) {
+    const out = new Set();
+    const pattern = /\bmockImport\s*\(\s*["']([^"']+)["']/g;
+    for (const source of sources) {
+        const text = stripComments(source.text);
+        for (const match of text.matchAll(pattern)) {
+            const target = (match[1] ?? "").trim();
+            if (!target.length)
+                continue;
+            out.add(target);
+        }
     }
-    const hasRunCall = /\brun\s*\(/.test(text);
-    return !hasRunCall;
+    return out;
 }
-function detectRunImportPath(sourceText) {
+function analyzeSourceText(sourceText) {
     const text = stripComments(sourceText);
+    const runImportPath = detectRunImportPath(text);
+    const runAlias = detectRunAlias(text);
+    const hasRunCall = runAlias
+        ? new RegExp(`\\b${escapeRegex(runAlias)}\\s*\\(`).test(text)
+        : /\brun\s*\(/.test(text);
+    return {
+        hasSuiteCalls: /\b(?:describe|test|it)\s*\(/.test(text),
+        hasRunCall,
+        runImportPath,
+        hasMockCalls: /\b(?:mockFn|unmockFn|mockImport|unmockImport)\s*\(/.test(text),
+        hasLogCall: /\blog\s*\(/.test(text),
+        hasExpectCall: /\bexpect\s*\(/.test(text),
+    };
+}
+function detectRunImportPath(text) {
     const imports = text.matchAll(/import\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/g);
     for (const match of imports) {
         const specifiers = match[1] ?? "";
@@ -88,8 +120,7 @@ function detectRunImportPath(sourceText) {
     }
     return null;
 }
-function detectRunAlias(sourceText) {
-    const text = stripComments(sourceText);
+function detectRunAlias(text) {
     const imports = text.matchAll(/import\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/g);
     for (const match of imports) {
         const specifiers = match[1] ?? "";
@@ -103,7 +134,7 @@ function detectRunAlias(sourceText) {
     return null;
 }
 function looksLikeAsTestImport(specifiers) {
-    return /\b(?:describe|test|it|expect|beforeAll|afterAll|beforeEach|afterEach|mockFn|mockImport|log|run)\b/.test(specifiers);
+    return /\b(?:describe|test|it|expect|beforeAll|afterAll|beforeEach|afterEach|mockFn|unmockFn|mockImport|unmockImport|snapshotImport|restoreImport|log|run)\b/.test(specifiers);
 }
 function stripComments(sourceText) {
     return sourceText.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
@@ -111,4 +142,7 @@ function stripComments(sourceText) {
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function isCoverageEnabled() {
+    return process.env.AS_TEST_COVERAGE_ENABLED !== "0";
+}
 //# sourceMappingURL=index.js.map

package/transform/lib/log.js

@@ -1,7 +1,6 @@
 import { Node, Source, Tokenizer, } from "assemblyscript/dist/assemblyscript.js";
 import { Visitor } from "./visitor.js";
 import { toString } from "./util.js";
-const LOG_VALUE_FN = "__as_test_log_value";
 const LOG_CALL_FN = "__as_test_log_call";
 const LOG_ENABLED_IMPORT = "__as_test_log_is_enabled_internal";
 const LOG_SERIALIZED_IMPORT = "__as_test_log_serialized_internal";
@@ -11,7 +10,6 @@ export class LogTransform extends Visitor {
     activeSource = null;
     touchedSource = null;
     hasLogCalls = false;
-    classNames = [];
     constructor(parser) {
         super();
         this.parser = parser;
@@ -22,7 +20,6 @@ export class LogTransform extends Visitor {
         this.activeSource = node;
         this.touchedSource = node;
         this.hasLogCalls = false;
-        this.classNames = [];
         super.visitSource(node);
         if (!this.hasLogCalls) {
             this.activeSource = null;
@@ -34,18 +31,7 @@ export class LogTransform extends Visitor {
         this.parser.currentSource = tokenizer.source;
         node.statements.unshift(this.parser.parseTopLevelStatement(tokenizer));
         this.parser.currentSource = node;
-        const jsonTokenizer = new Tokenizer(new Source(0, node.normalizedPath, `import { JSON } from "json-as";`));
-        this.parser.currentSource = jsonTokenizer.source;
-        node.statements.unshift(this.parser.parseTopLevelStatement(jsonTokenizer));
-        this.parser.currentSource = node;
-        const classFallbackLines = this.classNames
-            .map((className) => `if (idof<nonnull<T>>() == idof<${className}>()) return JSON.stringify<${className}>(changetype<${className}>(value));`)
-            .join(" ");
-        const genericTokenizer = new Tokenizer(new Source(0, node.normalizedPath, `function ${LOG_VALUE_FN}<T>(value: T): string { const formatted = ${LOG_DEFAULT_IMPORT}<T>(value); if (formatted != "none") return formatted; if (isReference<T>()) { ${classFallbackLines} } return formatted; }`));
-        this.parser.currentSource = genericTokenizer.source;
-        node.statements.push(this.parser.parseTopLevelStatement(genericTokenizer));
-        this.parser.currentSource = node;
-        const callTokenizer = new Tokenizer(new Source(0, node.normalizedPath, `function ${LOG_CALL_FN}<T>(value: T): void { if (!${LOG_ENABLED_IMPORT}()) return; ${LOG_SERIALIZED_IMPORT}(${LOG_VALUE_FN}(value)); }`));
+        const callTokenizer = new Tokenizer(new Source(0, node.normalizedPath, `function ${LOG_CALL_FN}<T>(value: T): void { if (!${LOG_ENABLED_IMPORT}()) return; ${LOG_SERIALIZED_IMPORT}(${LOG_DEFAULT_IMPORT}<T>(value)); }`));
         this.parser.currentSource = callTokenizer.source;
         node.statements.push(this.parser.parseTopLevelStatement(callTokenizer));
         this.parser.currentSource = node;
@@ -65,34 +51,11 @@ export class LogTransform extends Visitor {
         node.args[0] = arg;
         this.hasLogCalls = true;
     }
-    visitClassDeclaration(node, isDefault = false) {
-        super.visitClassDeclaration(node, isDefault);
-        if (!this.activeSource || this.touchedSource !== this.activeSource)
-            return;
-        if (!node.name)
-            return;
-        if (node.flags & 32768)
-            return;
-        if (node.decorators?.some((decorator) => isDecoratorNamed(decorator, "json")))
-            return;
-        if (node.decorators?.some((decorator) => isDecoratorNamed(decorator, "unmanaged")))
-            return;
-        const className = node.name.text;
-        if (!this.classNames.includes(className)) {
-            this.classNames.push(className);
-        }
-        const decorators = node.decorators ? [...node.decorators] : [];
-        decorators.unshift(Node.createDecorator(Node.createIdentifierExpression("json", node.range), [], node.range));
-        node.decorators = decorators;
-    }
 }
 function isUserSource(source) {
     return (source.sourceKind === 0 ||
         source.sourceKind === 1);
 }
-function isDecoratorNamed(node, name) {
-    return toString(node.name) === name;
-}
 function detectAsTestImportPath(sourceText) {
     const text = stripComments(sourceText);
     const imports = text.matchAll(/import\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/g);
@@ -110,7 +73,7 @@ function detectAsTestImportPath(sourceText) {
 function looksLikeAsTestImport(specifiers, modulePath) {
     if (modulePath === "as-test" || modulePath.endsWith("/as-test"))
         return true;
-    return /\b(?:describe|test|it|expect|beforeAll|afterAll|beforeEach|afterEach|mockFn|mockImport|log|run)\b/.test(specifiers);
+    return /\b(?:describe|test|it|expect|beforeAll|afterAll|beforeEach|afterEach|mockFn|unmockFn|mockImport|unmockImport|snapshotImport|restoreImport|log|run)\b/.test(specifiers);
 }
 function stripComments(sourceText) {
     return sourceText.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");