jsii 5.9.36-dev.0 → 5.9.36

package/lib/transforms/deprecation-warnings.js

@@ -11,61 +11,38 @@ const WARNING_FUNCTION_NAME = 'print';
 const PARAMETER_NAME = 'p';
 const FOR_LOOP_ITEM_NAME = 'o';
 const NAMESPACE = 'jsiiDeprecationWarnings';
-const LOCAL_ENUM_NAMESPACE = 'ns';
 const VISITED_OBJECTS_SET_NAME = 'visitedObjects';
 const DEPRECATION_ERROR = 'DeprecationError';
 const GET_PROPERTY_DESCRIPTOR = 'getPropertyDescriptor';
+const VALIDATORS_OBJ = 'VALIDATORS';
 class DeprecationWarningsInjector {
-    constructor(typeChecker) {
+    constructor(typeChecker, typeTracker) {
         this.typeChecker = typeChecker;
+        this.typeTracker = typeTracker;
         this.transformers = {
             before: [],
         };
+        this.shouldRenderValidatorCache = {};
+        this.validatorCacheSeenSet = new Set();
     }
     process(assembly, projectInfo) {
         const projectRoot = projectInfo.projectRoot;
-        const functionDeclarations = [];
+        const validationFunctions = [];
         const types = assembly.types ?? {};
         for (const type of Object.values(types)) {
-            const statements = [];
-            let isEmpty = true;
-            // This will add the parameter to the set of visited objects, to prevent infinite recursion
-            statements.push(ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(VISITED_OBJECTS_SET_NAME), 'add'), undefined, [ts.factory.createIdentifier(PARAMETER_NAME)])));
-            const tryStatements = [];
-            if (spec.isDeprecated(type) && spec.isEnumType(type)) {
-                // The type is deprecated
-                tryStatements.push(createWarningFunctionCall(type.fqn, type.docs?.deprecated));
-                isEmpty = false;
-            }
-            if (spec.isEnumType(type) && type.locationInModule?.filename) {
-                tryStatements.push(createEnumRequireStatement(type.locationInModule?.filename));
-                tryStatements.push(createDuplicateEnumValuesCheck(type));
-                for (const member of Object.values(type.members ?? [])) {
-                    if (spec.isDeprecated(member)) {
-                        // The enum member is deprecated
-                        const condition = ts.factory.createBinaryExpression(ts.factory.createIdentifier(PARAMETER_NAME), ts.SyntaxKind.EqualsEqualsEqualsToken, ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(LOCAL_ENUM_NAMESPACE), type.name), member.name));
-                        tryStatements.push(createWarningFunctionCall(`${type.fqn}#${member.name}`, member.docs?.deprecated, condition));
-                        isEmpty = false;
-                    }
-                }
-            }
-            else if (spec.isInterfaceType(type) && type.datatype) {
-                const { statementsByProp, excludedProps } = processInterfaceType(type, types, assembly, projectInfo, undefined, undefined);
-                for (const [name, statement] of statementsByProp.entries()) {
-                    if (!excludedProps.has(name)) {
-                        tryStatements.push(statement);
-                        isEmpty = false;
-                    }
-                }
+            const fnStatements = this.generateTypeValidation(type, assembly, projectInfo, types);
+            if (fnStatements.length === 0) {
+                continue;
             }
-            statements.push(ts.factory.createTryStatement(ts.factory.createBlock(tryStatements), undefined, ts.factory.createBlock([
-                ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(VISITED_OBJECTS_SET_NAME), 'delete'), undefined, [ts.factory.createIdentifier(PARAMETER_NAME)])),
-            ])));
             const paramValue = ts.factory.createParameterDeclaration(undefined, undefined, PARAMETER_NAME);
             const functionName = fnName(type.fqn);
-            const functionDeclaration = ts.factory.createFunctionDeclaration(undefined, undefined, ts.factory.createIdentifier(functionName), [], [paramValue], undefined, createFunctionBlock(isEmpty ? [] : statements));
-            functionDeclarations.push(functionDeclaration);
+            const functionExpr = ts.factory.createFunctionExpression(undefined, undefined, ts.factory.createIdentifier(functionName), [], [paramValue], undefined, createFunctionBlock(fnStatements));
+            validationFunctions.push(ts.factory.createPropertyAssignment(functionName, functionExpr));
         }
+        const fileStatements = [];
+        fileStatements.push(ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration(VALIDATORS_OBJ, undefined, undefined, ts.factory.createObjectLiteralExpression(validationFunctions)),
+        ], ts.NodeFlags.Const)));
         this.transformers = {
             before: [
                 (context) => {
@@ -74,7 +51,7 @@ class DeprecationWarningsInjector {
                 },
             ],
         };
-        generateWarningsFile(projectRoot, functionDeclarations);
+        generateWarningsFile(projectRoot, fileStatements);
     }
     get customTransformers() {
         return this.transformers;
@@ -89,58 +66,199 @@ class DeprecationWarningsInjector {
         }
         return result;
     }
-}
-exports.DeprecationWarningsInjector = DeprecationWarningsInjector;
-function processInterfaceType(type, types, assembly, projectInfo, statementsByProp = new Map(), excludedProps = new Set()) {
-    for (const prop of Object.values(type.properties ?? {})) {
-        const fqn = `${type.fqn}#${prop.name}`;
-        if (spec.isDeprecated(prop) || spec.isDeprecated(type)) {
-            // If the property individually is deprecated, or the entire type is deprecated
-            const deprecatedDocs = prop.docs?.deprecated ?? type.docs?.deprecated;
-            const statement = createWarningFunctionCall(fqn, deprecatedDocs, ts.factory.createBinaryExpression(ts.factory.createStringLiteral(prop.name), ts.SyntaxKind.InKeyword, ts.factory.createIdentifier(PARAMETER_NAME)), undefined);
-            statementsByProp.set(prop.name, statement);
+    /**
+     * Whether the validator for the given type should be rendered
+     *
+     * A validator should be rendered if:
+     *
+     * - It contains any deprecated members (base case).
+     * - It references any other types whose validators should be rendered.
+     * - It inherits from other types whose validators should be rendered.
+     * - It references types that reference this type (recursive types).
+     * - It references types from another assembly.
+     *
+     * For the last one we technically return `true`, indicating that a validator
+     * *should* be rendered, but when we get to rendering no statements are
+     * actually produced and the validator function is never rendered. This was
+     * pre-existing behavior that I didn't change because introducing calls into
+     * other assemblies out of the blue introduces risk.
+     */
+    shouldRenderValidator(type, assembly) {
+        if (this.shouldRenderValidatorCache[type.fqn] !== undefined) {
+            return this.shouldRenderValidatorCache[type.fqn];
+        }
+        if (type.fqn === '@scope/jsii-calc-base.TypeToContainVeryBaseProps') {
+            debugger;
+        }
+        if (this.validatorCacheSeenSet.has(type.fqn)) {
+            // To be safe we need to say this is true.
+            return true;
         }
-        else {
-            /* If a prop is not deprecated, we don't want to generate a warning for it,
-               even if another property with the same name is deprecated in another
-               super-interface. */
-            excludedProps.add(prop.name);
+        if (!type.fqn.startsWith(`${assembly.name}.`)) {
+            // Foreign type, always check
+            return true;
         }
-        if (spec.isNamedTypeReference(prop.type) && Object.keys(types).includes(prop.type.fqn)) {
-            const functionName = importedFunctionName(prop.type.fqn, assembly, projectInfo);
-            if (functionName) {
-                const statement = createTypeHandlerCall(functionName, `${PARAMETER_NAME}.${prop.name}`);
-                statementsByProp.set(`${prop.name}_`, statement);
+        this.validatorCacheSeenSet.add(type.fqn);
+        this.shouldRenderValidatorCache[type.fqn] = calculate.call(this);
+        this.validatorCacheSeenSet.delete(type.fqn);
+        return this.shouldRenderValidatorCache[type.fqn];
+        function calculate() {
+            if (spec.isDeprecated(type)) {
+                return true;
             }
+            if (spec.isEnumType(type)) {
+                return (type.members ?? []).some(spec.isDeprecated);
+            }
+            if (spec.isInterfaceType(type) && type.datatype) {
+                for (const prop of type.properties ?? []) {
+                    if (spec.isDeprecated(prop)) {
+                        return true;
+                    }
+                    const typesToInspect = spec.isCollectionTypeReference(prop.type)
+                        ? [prop.type.collection.elementtype]
+                        : spec.isUnionTypeReference(prop.type)
+                            ? prop.type.union.types
+                            : [prop.type];
+                    for (const typeToInspect of typesToInspect) {
+                        if (!spec.isNamedTypeReference(typeToInspect)) {
+                            continue;
+                        }
+                        // Is from a different assembly?
+                        const typeObj = findType2(typeToInspect.fqn, assembly);
+                        if (typeObj === 'other-assembly') {
+                            return true;
+                        }
+                        if (this.shouldRenderValidator(typeObj, assembly)) {
+                            return true;
+                        }
+                    }
+                }
+                for (const interfaceName of type.interfaces ?? []) {
+                    const typeObj = findType2(interfaceName, assembly);
+                    if (typeObj === 'other-assembly') {
+                        return true;
+                    }
+                    if (this.shouldRenderValidator(typeObj, assembly)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+    }
+    generateTypeValidation(type, assembly, projectInfo, types) {
+        if (!this.shouldRenderValidator(type, assembly)) {
+            return [];
         }
-        else if (spec.isCollectionTypeReference(prop.type) &&
-            spec.isNamedTypeReference(prop.type.collection.elementtype)) {
-            const functionName = importedFunctionName(prop.type.collection.elementtype.fqn, assembly, projectInfo);
-            if (functionName) {
-                const statement = createTypeHandlerCall(functionName, `${PARAMETER_NAME}.${prop.name}`, prop.type.collection.kind);
-                statementsByProp.set(`${prop.name}_`, statement);
+        const statements = [];
+        let isEmpty = true;
+        // This will add the parameter to the set of visited objects, to prevent infinite recursion
+        statements.push(ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(VISITED_OBJECTS_SET_NAME), 'add'), undefined, [ts.factory.createIdentifier(PARAMETER_NAME)])));
+        const tryStatements = [];
+        if (spec.isDeprecated(type) && spec.isEnumType(type)) {
+            // The type is deprecated
+            tryStatements.push(createWarningFunctionCall(type.fqn, type.docs?.deprecated));
+            isEmpty = false;
+        }
+        if (spec.isEnumType(type) && type.locationInModule?.filename) {
+            // Check for deprecated enum members
+            //
+            // We need to compare to the value of the deprecated enum. We can do that in one of 2 ways:
+            //
+            // - Compare against `require('./actual-file').EnumType.SOME_ENUM_MEMBER`
+            // - Look up the enum member value and compare against `'some-enum-member'`.
+            //
+            // The first one introduces a circular dependency between this file and `actual-file.js`, so we
+            // will go with the second.
+            //
+            // One complication: two enum members can have the same value (shouldn't, but can!) where
+            // one symbolic name is deprecated but the other isn't. In that case we don't treat it as deprecated.
+            const memDecls = this.typeTracker.getEnumMembers(type.fqn);
+            const nonDeprecatedValues = new Set((type.members ?? [])
+                .filter((m) => !spec.isDeprecated(m))
+                .map((m) => this.typeChecker.getConstantValue(memDecls[m.name])));
+            const deprecatedMembers = (type.members ?? []).filter(spec.isDeprecated);
+            for (const member of deprecatedMembers) {
+                const constantValue = this.typeChecker.getConstantValue(memDecls[member.name]);
+                if (nonDeprecatedValues.has(constantValue)) {
+                    // Collission with non-deprecated enum member
+                    continue;
+                }
+                const condition = ts.factory.createBinaryExpression(ts.factory.createIdentifier(PARAMETER_NAME), ts.SyntaxKind.EqualsEqualsEqualsToken, typeof constantValue === 'string'
+                    ? ts.factory.createStringLiteral(constantValue)
+                    : ts.factory.createNumericLiteral(constantValue));
+                tryStatements.push(createWarningFunctionCall(`${type.fqn}#${member.name}`, member.docs?.deprecated, condition));
+                isEmpty = false;
             }
         }
-        else if (spec.isUnionTypeReference(prop.type) &&
-            spec.isNamedTypeReference(prop.type.union.types[0]) &&
-            Object.keys(types).includes(prop.type.union.types[0].fqn)) {
-            const functionName = importedFunctionName(prop.type.union.types[0].fqn, assembly, projectInfo);
-            if (functionName) {
-                const statement = createTypeHandlerCall(functionName, `${PARAMETER_NAME}.${prop.name}`);
-                statementsByProp.set(`${prop.name}_`, statement);
+        else if (spec.isInterfaceType(type) && type.datatype) {
+            const { statementsByProp, excludedProps } = this.processInterfaceType(type, types, assembly, projectInfo, undefined, undefined);
+            for (const [name, statement] of statementsByProp.entries()) {
+                if (!excludedProps.has(name)) {
+                    tryStatements.push(statement);
+                    isEmpty = false;
+                }
             }
         }
+        statements.push(ts.factory.createTryStatement(ts.factory.createBlock(tryStatements), undefined, ts.factory.createBlock([
+            ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(VISITED_OBJECTS_SET_NAME), 'delete'), undefined, [ts.factory.createIdentifier(PARAMETER_NAME)])),
+        ])));
+        return isEmpty ? [] : statements;
     }
-    // We also generate calls to all the supertypes
-    for (const interfaceName of type.interfaces ?? []) {
-        const assemblies = projectInfo.dependencyClosure.concat(assembly);
-        const superType = findType(interfaceName, assemblies);
-        if (superType.type) {
-            processInterfaceType(superType.type, types, assembly, projectInfo, statementsByProp, excludedProps);
+    processInterfaceType(type, types, assembly, projectInfo, statementsByProp = new Map(), excludedProps = new Set()) {
+        for (const prop of Object.values(type.properties ?? {})) {
+            const fqn = `${type.fqn}#${prop.name}`;
+            if (spec.isDeprecated(prop) || spec.isDeprecated(type)) {
+                // If the property individually is deprecated, or the entire type is deprecated
+                const deprecatedDocs = prop.docs?.deprecated ?? type.docs?.deprecated;
+                const statement = createWarningFunctionCall(fqn, deprecatedDocs, ts.factory.createBinaryExpression(ts.factory.createStringLiteral(prop.name), ts.SyntaxKind.InKeyword, ts.factory.createIdentifier(PARAMETER_NAME)), undefined);
+                statementsByProp.set(prop.name, statement);
+            }
+            else {
+                /* If a prop is not deprecated, we don't want to generate a warning for it,
+                  even if another property with the same name is deprecated in another
+                  super-interface. */
+                excludedProps.add(prop.name);
+            }
+            if (spec.isNamedTypeReference(prop.type) && Object.keys(types).includes(prop.type.fqn)) {
+                if (this.shouldRenderValidator(types[prop.type.fqn], assembly)) {
+                    const functionName = importedFunctionName(prop.type.fqn, assembly, projectInfo);
+                    if (functionName) {
+                        const statement = createTypeHandlerCall(functionName, `${PARAMETER_NAME}.${prop.name}`);
+                        statementsByProp.set(`${prop.name}_`, statement);
+                    }
+                }
+            }
+            else if (spec.isCollectionTypeReference(prop.type) &&
+                spec.isNamedTypeReference(prop.type.collection.elementtype)) {
+                const functionName = importedFunctionName(prop.type.collection.elementtype.fqn, assembly, projectInfo);
+                if (functionName) {
+                    const statement = createTypeHandlerCall(functionName, `${PARAMETER_NAME}.${prop.name}`, prop.type.collection.kind);
+                    statementsByProp.set(`${prop.name}_`, statement);
+                }
+            }
+            else if (spec.isUnionTypeReference(prop.type) &&
+                spec.isNamedTypeReference(prop.type.union.types[0]) &&
+                Object.keys(types).includes(prop.type.union.types[0].fqn)) {
+                const functionName = importedFunctionName(prop.type.union.types[0].fqn, assembly, projectInfo);
+                if (functionName) {
+                    const statement = createTypeHandlerCall(functionName, `${PARAMETER_NAME}.${prop.name}`);
+                    statementsByProp.set(`${prop.name}_`, statement);
+                }
+            }
         }
+        // We also generate calls to all the supertypes
+        for (const interfaceName of type.interfaces ?? []) {
+            const assemblies = projectInfo.dependencyClosure.concat(assembly);
+            const superType = findType(interfaceName, assemblies);
+            if (superType.type) {
+                this.processInterfaceType(superType.type, types, assembly, projectInfo, statementsByProp, excludedProps);
+            }
+        }
+        return { statementsByProp, excludedProps };
     }
-    return { statementsByProp, excludedProps };
 }
+exports.DeprecationWarningsInjector = DeprecationWarningsInjector;
 function fnName(fqn) {
     return fqn.replace(/[^\w\d]/g, '_');
 }
@@ -159,9 +277,7 @@ function createWarningFunctionCall(fqn, message = '', condition, includeNamespac
     ]));
     return condition ? ts.factory.createIfStatement(condition, mainStatement) : mainStatement;
 }
-function generateWarningsFile(projectRoot, functionDeclarations) {
-    const names = [...functionDeclarations].map((d) => d.name?.text).filter(Boolean);
-    const exportedSymbols = [WARNING_FUNCTION_NAME, GET_PROPERTY_DESCRIPTOR, DEPRECATION_ERROR, ...names].join(',');
+function generateWarningsFile(projectRoot, validatorStatements) {
     const functionText = `function ${WARNING_FUNCTION_NAME}(name, deprecationMessage) {
   const deprecated = process.env.JSII_DEPRECATED;
   const deprecationMode = ['warn', 'fail', 'quiet'].includes(deprecated) ? deprecated : 'warn';
@@ -202,11 +318,22 @@ class ${DEPRECATION_ERROR} extends Error {
   }
 }
 
-module.exports = {${exportedSymbols}}
+function nop() {
+}
+
+module.exports = new Proxy({}, {
+  get(target, prop, receiver) {
+    if (prop === '${WARNING_FUNCTION_NAME}') return ${WARNING_FUNCTION_NAME};
+    if (prop === '${GET_PROPERTY_DESCRIPTOR}') return ${GET_PROPERTY_DESCRIPTOR};
+    if (prop === '${DEPRECATION_ERROR}') return ${DEPRECATION_ERROR};
+
+    return ${VALIDATORS_OBJ}[prop] ?? nop;
+  },
+});
 `;
     const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
     const resultFile = ts.createSourceFile(path.join(projectRoot, exports.WARNINGSCODE_FILE_NAME), functionText, ts.ScriptTarget.Latest, false, ts.ScriptKind.JS);
-    const declarations = functionDeclarations.map((declaration) => printer.printNode(ts.EmitHint.Unspecified, declaration, resultFile));
+    const declarations = validatorStatements.map((st) => printer.printNode(ts.EmitHint.Unspecified, st, resultFile));
     const content = declarations.concat(printer.printFile(resultFile)).join('\n');
     fs.writeFileSync(path.join(projectRoot, exports.WARNINGSCODE_FILE_NAME), content);
 }
@@ -313,6 +440,17 @@ class Transformer {
         return statements;
     }
 }
+function findType2(fqn, assembly) {
+    // Is from a different assembly?
+    if (!fqn.startsWith(`${assembly.name}.`)) {
+        return 'other-assembly';
+    }
+    const type = (assembly.types ?? {})[fqn];
+    if (!type) {
+        throw new Error(`Could not find type in same assembly: ${fqn}`);
+    }
+    return type;
+}
 function createWarningStatementForElement(element, classType) {
     if (spec.isDeprecated(element)) {
         const elementName = element.name;
@@ -344,11 +482,6 @@ function insertStatements(block, newStatements) {
     result.splice(splicePoint(block.statements[0]), 0, ...newStatements);
     return ts.factory.createNodeArray(result);
 }
-function createEnumRequireStatement(typeLocation) {
-    const { ext } = path.parse(typeLocation);
-    const jsFileName = typeLocation.replace(ext, '.js');
-    return createRequireStatement(LOCAL_ENUM_NAMESPACE, `./${jsFileName}`);
-}
 function createRequireStatement(name, importPath) {
     return ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
         ts.factory.createVariableDeclaration(name, undefined, undefined, ts.factory.createCallExpression(ts.factory.createIdentifier('require'), undefined, [
@@ -393,28 +526,9 @@ function createTypeHandlerCall(functionName, parameter, collectionKind) {
         case spec.CollectionKind.Map:
             return ts.factory.createIfStatement(ts.factory.createBinaryExpression(ts.factory.createIdentifier(parameter), ts.SyntaxKind.ExclamationEqualsToken, ts.factory.createNull()), ts.factory.createForOfStatement(undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(FOR_LOOP_ITEM_NAME)], ts.NodeFlags.Const), ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), 'values'), undefined, [ts.factory.createIdentifier(parameter)]), createTypeHandlerCall(functionName, FOR_LOOP_ITEM_NAME)));
         case undefined:
-            return ts.factory.createIfStatement(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(VISITED_OBJECTS_SET_NAME), ts.factory.createIdentifier('has')), undefined, [ts.factory.createIdentifier(parameter)])), ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createIdentifier(functionName), undefined, [
-                ts.factory.createIdentifier(parameter),
-            ])));
+            return ts.factory.createIfStatement(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(VISITED_OBJECTS_SET_NAME), ts.factory.createIdentifier('has')), undefined, [ts.factory.createIdentifier(parameter)])), ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('module.exports'), functionName), undefined, [ts.factory.createIdentifier(parameter)])));
     }
 }
-/**
- * There is a chance an enum contains duplicates values with distinct keys,
- * with one of those keys being deprecated. This is a potential pattern to "rename" an enum.
- * In this case, we can't concretely determine if the deprecated member was used or not,
- * so in those cases we skip the warnings altogether, rather than erroneously warning for valid usage.
- * This create a statement to check if the enum value is a duplicate:
- *
- * if (Object.values(Foo).filter(x => x === p).length > 1) { return; }
- *
- * Note that we can't just check the assembly for these duplicates, due to:
- * https://github.com/aws/jsii/issues/2782
- */
-function createDuplicateEnumValuesCheck(type) {
-    return ts.factory.createIfStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), 'values'), undefined, [ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(LOCAL_ENUM_NAMESPACE), type.name)]), ts.factory.createIdentifier('filter')), undefined, [
-        ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'x')], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBinaryExpression(ts.factory.createIdentifier('x'), ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createIdentifier(PARAMETER_NAME))),
-    ]), ts.factory.createIdentifier('length')), ts.factory.createToken(ts.SyntaxKind.GreaterThanToken), ts.factory.createNumericLiteral('1')), ts.factory.createReturnStatement());
-}
 // We try-then-rethrow exceptions to avoid runtimes displaying an uncanny wall of text if the place
 // where the error was thrown is webpacked. For example, jest somehow manages to capture the throw
 // location and renders the source line (which may be the whole file) when bundled.