static-injector 4.0.1 → 5.0.0-alpha.0

package/transform/compiler/src/output/output_ast.js

@@ -1,1109 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NULL_EXPR = exports.CommaExpr = exports.LiteralMapExpr = exports.LiteralMapEntry = exports.LiteralArrayExpr = exports.ReadKeyExpr = exports.ReadPropExpr = exports.BinaryOperatorExpr = exports.UnaryOperatorExpr = exports.ArrowFunctionExpr = exports.FunctionExpr = exports.FnParam = exports.NotExpr = exports.DynamicImportExpr = exports.ConditionalExpr = exports.ExternalReference = exports.ExternalExpr = exports.LiteralPiece = exports.TemplateLiteralElement = exports.TemplateLiteral = exports.LiteralExpr = exports.InstantiateExpr = exports.InvokeFunctionExpr = exports.WritePropExpr = exports.WriteKeyExpr = exports.WriteVarExpr = exports.WrappedNodeExpr = exports.TypeofExpr = exports.ReadVarExpr = exports.Expression = exports.areAllEquivalent = exports.nullSafeIsEquivalent = exports.BinaryOperator = exports.UnaryOperator = exports.NONE_TYPE = exports.FUNCTION_TYPE = exports.STRING_TYPE = exports.NUMBER_TYPE = exports.INT_TYPE = exports.BOOL_TYPE = exports.INFERRED_TYPE = exports.DYNAMIC_TYPE = exports.TransplantedType = exports.MapType = exports.ArrayType = exports.ExpressionType = exports.BuiltinType = exports.BuiltinTypeName = exports.Type = exports.TypeModifier = void 0;
-exports.isNull = exports.literal = exports.ifStmt = exports.arrowFn = exports.fn = exports.not = exports.unary = exports.literalMap = exports.literalArr = exports.typeofExpr = exports.transplantedType = exports.expressionType = exports.importType = exports.importExpr = exports.variable = exports.jsDocComment = exports.leadingComment = exports.IfStmt = exports.ReturnStatement = exports.ExpressionStatement = exports.DeclareFunctionStmt = exports.DeclareVarStmt = exports.Statement = exports.JSDocComment = exports.LeadingComment = exports.StmtModifier = exports.TYPED_NULL_EXPR = void 0;
-//// Types
-var TypeModifier;
-(function (TypeModifier) {
-    TypeModifier[TypeModifier["None"] = 0] = "None";
-    TypeModifier[TypeModifier["Const"] = 1] = "Const";
-})(TypeModifier || (exports.TypeModifier = TypeModifier = {}));
-class Type {
-    modifiers;
-    constructor(modifiers = TypeModifier.None) {
-        this.modifiers = modifiers;
-    }
-    hasModifier(modifier) {
-        return (this.modifiers & modifier) !== 0;
-    }
-}
-exports.Type = Type;
-var BuiltinTypeName;
-(function (BuiltinTypeName) {
-    BuiltinTypeName[BuiltinTypeName["Dynamic"] = 0] = "Dynamic";
-    BuiltinTypeName[BuiltinTypeName["Bool"] = 1] = "Bool";
-    BuiltinTypeName[BuiltinTypeName["String"] = 2] = "String";
-    BuiltinTypeName[BuiltinTypeName["Int"] = 3] = "Int";
-    BuiltinTypeName[BuiltinTypeName["Number"] = 4] = "Number";
-    BuiltinTypeName[BuiltinTypeName["Function"] = 5] = "Function";
-    BuiltinTypeName[BuiltinTypeName["Inferred"] = 6] = "Inferred";
-    BuiltinTypeName[BuiltinTypeName["None"] = 7] = "None";
-})(BuiltinTypeName || (exports.BuiltinTypeName = BuiltinTypeName = {}));
-class BuiltinType extends Type {
-    name;
-    constructor(name, modifiers) {
-        super(modifiers);
-        this.name = name;
-    }
-    visitType(visitor, context) {
-        return visitor.visitBuiltinType(this, context);
-    }
-}
-exports.BuiltinType = BuiltinType;
-class ExpressionType extends Type {
-    value;
-    typeParams;
-    constructor(value, modifiers, typeParams = null) {
-        super(modifiers);
-        this.value = value;
-        this.typeParams = typeParams;
-    }
-    visitType(visitor, context) {
-        return visitor.visitExpressionType(this, context);
-    }
-}
-exports.ExpressionType = ExpressionType;
-class ArrayType extends Type {
-    of;
-    constructor(of, modifiers) {
-        super(modifiers);
-        this.of = of;
-    }
-    visitType(visitor, context) {
-        return visitor.visitArrayType(this, context);
-    }
-}
-exports.ArrayType = ArrayType;
-class MapType extends Type {
-    valueType;
-    constructor(valueType, modifiers) {
-        super(modifiers);
-        this.valueType = valueType || null;
-    }
-    visitType(visitor, context) {
-        return visitor.visitMapType(this, context);
-    }
-}
-exports.MapType = MapType;
-class TransplantedType extends Type {
-    type;
-    constructor(type, modifiers) {
-        super(modifiers);
-        this.type = type;
-    }
-    visitType(visitor, context) {
-        return visitor.visitTransplantedType(this, context);
-    }
-}
-exports.TransplantedType = TransplantedType;
-exports.DYNAMIC_TYPE = new BuiltinType(BuiltinTypeName.Dynamic);
-exports.INFERRED_TYPE = new BuiltinType(BuiltinTypeName.Inferred);
-exports.BOOL_TYPE = new BuiltinType(BuiltinTypeName.Bool);
-exports.INT_TYPE = new BuiltinType(BuiltinTypeName.Int);
-exports.NUMBER_TYPE = new BuiltinType(BuiltinTypeName.Number);
-exports.STRING_TYPE = new BuiltinType(BuiltinTypeName.String);
-exports.FUNCTION_TYPE = new BuiltinType(BuiltinTypeName.Function);
-exports.NONE_TYPE = new BuiltinType(BuiltinTypeName.None);
-///// Expressions
-var UnaryOperator;
-(function (UnaryOperator) {
-    UnaryOperator[UnaryOperator["Minus"] = 0] = "Minus";
-    UnaryOperator[UnaryOperator["Plus"] = 1] = "Plus";
-})(UnaryOperator || (exports.UnaryOperator = UnaryOperator = {}));
-var BinaryOperator;
-(function (BinaryOperator) {
-    BinaryOperator[BinaryOperator["Equals"] = 0] = "Equals";
-    BinaryOperator[BinaryOperator["NotEquals"] = 1] = "NotEquals";
-    BinaryOperator[BinaryOperator["Identical"] = 2] = "Identical";
-    BinaryOperator[BinaryOperator["NotIdentical"] = 3] = "NotIdentical";
-    BinaryOperator[BinaryOperator["Minus"] = 4] = "Minus";
-    BinaryOperator[BinaryOperator["Plus"] = 5] = "Plus";
-    BinaryOperator[BinaryOperator["Divide"] = 6] = "Divide";
-    BinaryOperator[BinaryOperator["Multiply"] = 7] = "Multiply";
-    BinaryOperator[BinaryOperator["Modulo"] = 8] = "Modulo";
-    BinaryOperator[BinaryOperator["And"] = 9] = "And";
-    BinaryOperator[BinaryOperator["Or"] = 10] = "Or";
-    BinaryOperator[BinaryOperator["BitwiseOr"] = 11] = "BitwiseOr";
-    BinaryOperator[BinaryOperator["BitwiseAnd"] = 12] = "BitwiseAnd";
-    BinaryOperator[BinaryOperator["Lower"] = 13] = "Lower";
-    BinaryOperator[BinaryOperator["LowerEquals"] = 14] = "LowerEquals";
-    BinaryOperator[BinaryOperator["Bigger"] = 15] = "Bigger";
-    BinaryOperator[BinaryOperator["BiggerEquals"] = 16] = "BiggerEquals";
-    BinaryOperator[BinaryOperator["NullishCoalesce"] = 17] = "NullishCoalesce";
-})(BinaryOperator || (exports.BinaryOperator = BinaryOperator = {}));
-function nullSafeIsEquivalent(base, other) {
-    if (base == null || other == null) {
-        return base == other;
-    }
-    return base.isEquivalent(other);
-}
-exports.nullSafeIsEquivalent = nullSafeIsEquivalent;
-function areAllEquivalentPredicate(base, other, equivalentPredicate) {
-    const len = base.length;
-    if (len !== other.length) {
-        return false;
-    }
-    for (let i = 0; i < len; i++) {
-        if (!equivalentPredicate(base[i], other[i])) {
-            return false;
-        }
-    }
-    return true;
-}
-function areAllEquivalent(base, other) {
-    return areAllEquivalentPredicate(base, other, (baseElement, otherElement) => baseElement.isEquivalent(otherElement));
-}
-exports.areAllEquivalent = areAllEquivalent;
-class Expression {
-    type;
-    sourceSpan;
-    constructor(type, sourceSpan) {
-        this.type = type || null;
-        this.sourceSpan = sourceSpan || null;
-    }
-    prop(name, sourceSpan) {
-        return new ReadPropExpr(this, name, null, sourceSpan);
-    }
-    key(index, type, sourceSpan) {
-        return new ReadKeyExpr(this, index, type, sourceSpan);
-    }
-    callFn(params, sourceSpan, pure) {
-        return new InvokeFunctionExpr(this, params, null, sourceSpan, pure);
-    }
-    bitwiseOr(rhs, sourceSpan, parens = true) {
-        return new BinaryOperatorExpr(BinaryOperator.BitwiseOr, this, rhs, null, sourceSpan, parens);
-    }
-    toStmt() {
-        return new ExpressionStatement(this, null);
-    }
-}
-exports.Expression = Expression;
-class ReadVarExpr extends Expression {
-    name;
-    constructor(name, type, sourceSpan) {
-        super(type, sourceSpan);
-        this.name = name;
-    }
-    isEquivalent(e) {
-        return e instanceof ReadVarExpr && this.name === e.name;
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitReadVarExpr(this, context);
-    }
-    clone() {
-        return new ReadVarExpr(this.name, this.type, this.sourceSpan);
-    }
-    set(value) {
-        return new WriteVarExpr(this.name, value, null, this.sourceSpan);
-    }
-}
-exports.ReadVarExpr = ReadVarExpr;
-class TypeofExpr extends Expression {
-    expr;
-    constructor(expr, type, sourceSpan) {
-        super(type, sourceSpan);
-        this.expr = expr;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitTypeofExpr(this, context);
-    }
-    isEquivalent(e) {
-        return e instanceof TypeofExpr && e.expr.isEquivalent(this.expr);
-    }
-    isConstant() {
-        return this.expr.isConstant();
-    }
-    clone() {
-        return new TypeofExpr(this.expr.clone());
-    }
-}
-exports.TypeofExpr = TypeofExpr;
-class WrappedNodeExpr extends Expression {
-    node;
-    constructor(node, type, sourceSpan) {
-        super(type, sourceSpan);
-        this.node = node;
-    }
-    isEquivalent(e) {
-        return e instanceof WrappedNodeExpr && this.node === e.node;
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitWrappedNodeExpr(this, context);
-    }
-    clone() {
-        return new WrappedNodeExpr(this.node, this.type, this.sourceSpan);
-    }
-}
-exports.WrappedNodeExpr = WrappedNodeExpr;
-class WriteVarExpr extends Expression {
-    name;
-    value;
-    constructor(name, value, type, sourceSpan) {
-        super(type || value.type, sourceSpan);
-        this.name = name;
-        this.value = value;
-    }
-    isEquivalent(e) {
-        return (e instanceof WriteVarExpr &&
-            this.name === e.name &&
-            this.value.isEquivalent(e.value));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitWriteVarExpr(this, context);
-    }
-    clone() {
-        return new WriteVarExpr(this.name, this.value.clone(), this.type, this.sourceSpan);
-    }
-    toDeclStmt(type, modifiers) {
-        return new DeclareVarStmt(this.name, this.value, type, modifiers, this.sourceSpan);
-    }
-    toConstDecl() {
-        return this.toDeclStmt(exports.INFERRED_TYPE, StmtModifier.Final);
-    }
-}
-exports.WriteVarExpr = WriteVarExpr;
-class WriteKeyExpr extends Expression {
-    receiver;
-    index;
-    value;
-    constructor(receiver, index, value, type, sourceSpan) {
-        super(type || value.type, sourceSpan);
-        this.receiver = receiver;
-        this.index = index;
-        this.value = value;
-    }
-    isEquivalent(e) {
-        return (e instanceof WriteKeyExpr &&
-            this.receiver.isEquivalent(e.receiver) &&
-            this.index.isEquivalent(e.index) &&
-            this.value.isEquivalent(e.value));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitWriteKeyExpr(this, context);
-    }
-    clone() {
-        return new WriteKeyExpr(this.receiver.clone(), this.index.clone(), this.value.clone(), this.type, this.sourceSpan);
-    }
-}
-exports.WriteKeyExpr = WriteKeyExpr;
-class WritePropExpr extends Expression {
-    receiver;
-    name;
-    value;
-    constructor(receiver, name, value, type, sourceSpan) {
-        super(type || value.type, sourceSpan);
-        this.receiver = receiver;
-        this.name = name;
-        this.value = value;
-    }
-    isEquivalent(e) {
-        return (e instanceof WritePropExpr &&
-            this.receiver.isEquivalent(e.receiver) &&
-            this.name === e.name &&
-            this.value.isEquivalent(e.value));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitWritePropExpr(this, context);
-    }
-    clone() {
-        return new WritePropExpr(this.receiver.clone(), this.name, this.value.clone(), this.type, this.sourceSpan);
-    }
-}
-exports.WritePropExpr = WritePropExpr;
-class InvokeFunctionExpr extends Expression {
-    fn;
-    args;
-    pure;
-    constructor(fn, args, type, sourceSpan, pure = false) {
-        super(type, sourceSpan);
-        this.fn = fn;
-        this.args = args;
-        this.pure = pure;
-    }
-    // An alias for fn, which allows other logic to handle calls and property reads together.
-    get receiver() {
-        return this.fn;
-    }
-    isEquivalent(e) {
-        return (e instanceof InvokeFunctionExpr &&
-            this.fn.isEquivalent(e.fn) &&
-            areAllEquivalent(this.args, e.args) &&
-            this.pure === e.pure);
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitInvokeFunctionExpr(this, context);
-    }
-    clone() {
-        return new InvokeFunctionExpr(this.fn.clone(), this.args.map((arg) => arg.clone()), this.type, this.sourceSpan, this.pure);
-    }
-}
-exports.InvokeFunctionExpr = InvokeFunctionExpr;
-class InstantiateExpr extends Expression {
-    classExpr;
-    args;
-    constructor(classExpr, args, type, sourceSpan) {
-        super(type, sourceSpan);
-        this.classExpr = classExpr;
-        this.args = args;
-    }
-    isEquivalent(e) {
-        return (e instanceof InstantiateExpr &&
-            this.classExpr.isEquivalent(e.classExpr) &&
-            areAllEquivalent(this.args, e.args));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitInstantiateExpr(this, context);
-    }
-    clone() {
-        return new InstantiateExpr(this.classExpr.clone(), this.args.map((arg) => arg.clone()), this.type, this.sourceSpan);
-    }
-}
-exports.InstantiateExpr = InstantiateExpr;
-class LiteralExpr extends Expression {
-    value;
-    constructor(value, type, sourceSpan) {
-        super(type, sourceSpan);
-        this.value = value;
-    }
-    isEquivalent(e) {
-        return e instanceof LiteralExpr && this.value === e.value;
-    }
-    isConstant() {
-        return true;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitLiteralExpr(this, context);
-    }
-    clone() {
-        return new LiteralExpr(this.value, this.type, this.sourceSpan);
-    }
-}
-exports.LiteralExpr = LiteralExpr;
-class TemplateLiteral {
-    elements;
-    expressions;
-    constructor(elements, expressions) {
-        this.elements = elements;
-        this.expressions = expressions;
-    }
-    clone() {
-        return new TemplateLiteral(this.elements.map((el) => el.clone()), this.expressions.map((expr) => expr.clone()));
-    }
-}
-exports.TemplateLiteral = TemplateLiteral;
-class TemplateLiteralElement {
-    text;
-    sourceSpan;
-    rawText;
-    constructor(text, sourceSpan, rawText) {
-        this.text = text;
-        this.sourceSpan = sourceSpan;
-        // If `rawText` is not provided, try to extract the raw string from its
-        // associated `sourceSpan`. If that is also not available, "fake" the raw
-        // string instead by escaping the following control sequences:
-        // - "\" would otherwise indicate that the next character is a control character.
-        // - "`" and "${" are template string control sequences that would otherwise prematurely
-        // indicate the end of the template literal element.
-        this.rawText =
-            rawText ??
-                sourceSpan?.toString() ??
-                escapeForTemplateLiteral(escapeSlashes(text));
-    }
-    clone() {
-        return new TemplateLiteralElement(this.text, this.sourceSpan, this.rawText);
-    }
-}
-exports.TemplateLiteralElement = TemplateLiteralElement;
-class LiteralPiece {
-    text;
-    sourceSpan;
-    constructor(text, sourceSpan) {
-        this.text = text;
-        this.sourceSpan = sourceSpan;
-    }
-}
-exports.LiteralPiece = LiteralPiece;
-const escapeSlashes = (str) => str.replace(/\\/g, '\\\\');
-const escapeStartingColon = (str) => str.replace(/^:/, '\\:');
-const escapeColons = (str) => str.replace(/:/g, '\\:');
-const escapeForTemplateLiteral = (str) => str.replace(/`/g, '\\`').replace(/\${/g, '$\\{');
-/**
- * Creates a `{cooked, raw}` object from the `metaBlock` and `messagePart`.
- *
- * The `raw` text must have various character sequences escaped:
- * * "\" would otherwise indicate that the next character is a control character.
- * * "`" and "${" are template string control sequences that would otherwise prematurely indicate
- *   the end of a message part.
- * * ":" inside a metablock would prematurely indicate the end of the metablock.
- * * ":" at the start of a messagePart with no metablock would erroneously indicate the start of a
- *   metablock.
- *
- * @param metaBlock Any metadata that should be prepended to the string
- * @param messagePart The message part of the string
- */
-function createCookedRawString(metaBlock, messagePart, range) {
-    if (metaBlock === '') {
-        return {
-            cooked: messagePart,
-            raw: escapeForTemplateLiteral(escapeStartingColon(escapeSlashes(messagePart))),
-            range,
-        };
-    }
-    else {
-        return {
-            cooked: `:${metaBlock}:${messagePart}`,
-            raw: escapeForTemplateLiteral(`:${escapeColons(escapeSlashes(metaBlock))}:${escapeSlashes(messagePart)}`),
-            range,
-        };
-    }
-}
-class ExternalExpr extends Expression {
-    value;
-    typeParams;
-    constructor(value, type, typeParams = null, sourceSpan) {
-        super(type, sourceSpan);
-        this.value = value;
-        this.typeParams = typeParams;
-    }
-    isEquivalent(e) {
-        return (e instanceof ExternalExpr &&
-            this.value.name === e.value.name &&
-            this.value.moduleName === e.value.moduleName &&
-            this.value.runtime === e.value.runtime);
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitExternalExpr(this, context);
-    }
-    clone() {
-        return new ExternalExpr(this.value, this.type, this.typeParams, this.sourceSpan);
-    }
-}
-exports.ExternalExpr = ExternalExpr;
-class ExternalReference {
-    moduleName;
-    name;
-    runtime;
-    constructor(moduleName, name, runtime) {
-        this.moduleName = moduleName;
-        this.name = name;
-        this.runtime = runtime;
-    }
-}
-exports.ExternalReference = ExternalReference;
-class ConditionalExpr extends Expression {
-    condition;
-    falseCase;
-    trueCase;
-    constructor(condition, trueCase, falseCase = null, type, sourceSpan) {
-        super(type || trueCase.type, sourceSpan);
-        this.condition = condition;
-        this.falseCase = falseCase;
-        this.trueCase = trueCase;
-    }
-    isEquivalent(e) {
-        return (e instanceof ConditionalExpr &&
-            this.condition.isEquivalent(e.condition) &&
-            this.trueCase.isEquivalent(e.trueCase) &&
-            nullSafeIsEquivalent(this.falseCase, e.falseCase));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitConditionalExpr(this, context);
-    }
-    clone() {
-        return new ConditionalExpr(this.condition.clone(), this.trueCase.clone(), this.falseCase?.clone(), this.type, this.sourceSpan);
-    }
-}
-exports.ConditionalExpr = ConditionalExpr;
-class DynamicImportExpr extends Expression {
-    url;
-    constructor(url, sourceSpan) {
-        super(null, sourceSpan);
-        this.url = url;
-    }
-    isEquivalent(e) {
-        return e instanceof DynamicImportExpr && this.url === e.url;
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitDynamicImportExpr(this, context);
-    }
-    clone() {
-        return new DynamicImportExpr(this.url, this.sourceSpan);
-    }
-}
-exports.DynamicImportExpr = DynamicImportExpr;
-class NotExpr extends Expression {
-    condition;
-    constructor(condition, sourceSpan) {
-        super(exports.BOOL_TYPE, sourceSpan);
-        this.condition = condition;
-    }
-    isEquivalent(e) {
-        return e instanceof NotExpr && this.condition.isEquivalent(e.condition);
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitNotExpr(this, context);
-    }
-    clone() {
-        return new NotExpr(this.condition.clone(), this.sourceSpan);
-    }
-}
-exports.NotExpr = NotExpr;
-class FnParam {
-    name;
-    type;
-    constructor(name, type = null) {
-        this.name = name;
-        this.type = type;
-    }
-    isEquivalent(param) {
-        return this.name === param.name;
-    }
-    clone() {
-        return new FnParam(this.name, this.type);
-    }
-}
-exports.FnParam = FnParam;
-class FunctionExpr extends Expression {
-    params;
-    statements;
-    name;
-    constructor(params, statements, type, sourceSpan, name) {
-        super(type, sourceSpan);
-        this.params = params;
-        this.statements = statements;
-        this.name = name;
-    }
-    isEquivalent(e) {
-        return ((e instanceof FunctionExpr || e instanceof DeclareFunctionStmt) &&
-            areAllEquivalent(this.params, e.params) &&
-            areAllEquivalent(this.statements, e.statements));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitFunctionExpr(this, context);
-    }
-    toDeclStmt(name, modifiers) {
-        return new DeclareFunctionStmt(name, this.params, this.statements, this.type, modifiers, this.sourceSpan);
-    }
-    clone() {
-        // TODO: Should we deep clone statements?
-        return new FunctionExpr(this.params.map((p) => p.clone()), this.statements, this.type, this.sourceSpan, this.name);
-    }
-}
-exports.FunctionExpr = FunctionExpr;
-class ArrowFunctionExpr extends Expression {
-    params;
-    body;
-    // Note that `body: Expression` represents `() => expr` whereas
-    // `body: Statement[]` represents `() => { expr }`.
-    constructor(params, body, type, sourceSpan) {
-        super(type, sourceSpan);
-        this.params = params;
-        this.body = body;
-    }
-    isEquivalent(e) {
-        if (!(e instanceof ArrowFunctionExpr) ||
-            !areAllEquivalent(this.params, e.params)) {
-            return false;
-        }
-        if (this.body instanceof Expression && e.body instanceof Expression) {
-            return this.body.isEquivalent(e.body);
-        }
-        if (Array.isArray(this.body) && Array.isArray(e.body)) {
-            return areAllEquivalent(this.body, e.body);
-        }
-        return false;
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitArrowFunctionExpr(this, context);
-    }
-    clone() {
-        // TODO: Should we deep clone statements?
-        return new ArrowFunctionExpr(this.params.map((p) => p.clone()), Array.isArray(this.body) ? this.body : this.body.clone(), this.type, this.sourceSpan);
-    }
-    toDeclStmt(name, modifiers) {
-        return new DeclareVarStmt(name, this, exports.INFERRED_TYPE, modifiers, this.sourceSpan);
-    }
-}
-exports.ArrowFunctionExpr = ArrowFunctionExpr;
-class UnaryOperatorExpr extends Expression {
-    operator;
-    expr;
-    parens;
-    constructor(operator, expr, type, sourceSpan, parens = true) {
-        super(type || exports.NUMBER_TYPE, sourceSpan);
-        this.operator = operator;
-        this.expr = expr;
-        this.parens = parens;
-    }
-    isEquivalent(e) {
-        return (e instanceof UnaryOperatorExpr &&
-            this.operator === e.operator &&
-            this.expr.isEquivalent(e.expr));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitUnaryOperatorExpr(this, context);
-    }
-    clone() {
-        return new UnaryOperatorExpr(this.operator, this.expr.clone(), this.type, this.sourceSpan, this.parens);
-    }
-}
-exports.UnaryOperatorExpr = UnaryOperatorExpr;
-class BinaryOperatorExpr extends Expression {
-    operator;
-    rhs;
-    parens;
-    lhs;
-    constructor(operator, lhs, rhs, type, sourceSpan, parens = true) {
-        super(type || lhs.type, sourceSpan);
-        this.operator = operator;
-        this.rhs = rhs;
-        this.parens = parens;
-        this.lhs = lhs;
-    }
-    isEquivalent(e) {
-        return (e instanceof BinaryOperatorExpr &&
-            this.operator === e.operator &&
-            this.lhs.isEquivalent(e.lhs) &&
-            this.rhs.isEquivalent(e.rhs));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitBinaryOperatorExpr(this, context);
-    }
-    clone() {
-        return new BinaryOperatorExpr(this.operator, this.lhs.clone(), this.rhs.clone(), this.type, this.sourceSpan, this.parens);
-    }
-}
-exports.BinaryOperatorExpr = BinaryOperatorExpr;
-class ReadPropExpr extends Expression {
-    receiver;
-    name;
-    constructor(receiver, name, type, sourceSpan) {
-        super(type, sourceSpan);
-        this.receiver = receiver;
-        this.name = name;
-    }
-    // An alias for name, which allows other logic to handle property reads and keyed reads together.
-    get index() {
-        return this.name;
-    }
-    isEquivalent(e) {
-        return (e instanceof ReadPropExpr &&
-            this.receiver.isEquivalent(e.receiver) &&
-            this.name === e.name);
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitReadPropExpr(this, context);
-    }
-    set(value) {
-        return new WritePropExpr(this.receiver, this.name, value, null, this.sourceSpan);
-    }
-    clone() {
-        return new ReadPropExpr(this.receiver.clone(), this.name, this.type, this.sourceSpan);
-    }
-}
-exports.ReadPropExpr = ReadPropExpr;
-class ReadKeyExpr extends Expression {
-    receiver;
-    index;
-    constructor(receiver, index, type, sourceSpan) {
-        super(type, sourceSpan);
-        this.receiver = receiver;
-        this.index = index;
-    }
-    isEquivalent(e) {
-        return (e instanceof ReadKeyExpr &&
-            this.receiver.isEquivalent(e.receiver) &&
-            this.index.isEquivalent(e.index));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitReadKeyExpr(this, context);
-    }
-    set(value) {
-        return new WriteKeyExpr(this.receiver, this.index, value, null, this.sourceSpan);
-    }
-    clone() {
-        return new ReadKeyExpr(this.receiver.clone(), this.index.clone(), this.type, this.sourceSpan);
-    }
-}
-exports.ReadKeyExpr = ReadKeyExpr;
-class LiteralArrayExpr extends Expression {
-    entries;
-    constructor(entries, type, sourceSpan) {
-        super(type, sourceSpan);
-        this.entries = entries;
-    }
-    isConstant() {
-        return this.entries.every((e) => e.isConstant());
-    }
-    isEquivalent(e) {
-        return (e instanceof LiteralArrayExpr && areAllEquivalent(this.entries, e.entries));
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitLiteralArrayExpr(this, context);
-    }
-    clone() {
-        return new LiteralArrayExpr(this.entries.map((e) => e.clone()), this.type, this.sourceSpan);
-    }
-}
-exports.LiteralArrayExpr = LiteralArrayExpr;
-class LiteralMapEntry {
-    key;
-    value;
-    quoted;
-    constructor(key, value, quoted) {
-        this.key = key;
-        this.value = value;
-        this.quoted = quoted;
-    }
-    isEquivalent(e) {
-        return this.key === e.key && this.value.isEquivalent(e.value);
-    }
-    clone() {
-        return new LiteralMapEntry(this.key, this.value.clone(), this.quoted);
-    }
-}
-exports.LiteralMapEntry = LiteralMapEntry;
-class LiteralMapExpr extends Expression {
-    entries;
-    valueType = null;
-    constructor(entries, type, sourceSpan) {
-        super(type, sourceSpan);
-        this.entries = entries;
-        if (type) {
-            this.valueType = type.valueType;
-        }
-    }
-    isEquivalent(e) {
-        return (e instanceof LiteralMapExpr && areAllEquivalent(this.entries, e.entries));
-    }
-    isConstant() {
-        return this.entries.every((e) => e.value.isConstant());
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitLiteralMapExpr(this, context);
-    }
-    clone() {
-        const entriesClone = this.entries.map((entry) => entry.clone());
-        return new LiteralMapExpr(entriesClone, this.type, this.sourceSpan);
-    }
-}
-exports.LiteralMapExpr = LiteralMapExpr;
-class CommaExpr extends Expression {
-    parts;
-    constructor(parts, sourceSpan) {
-        super(parts[parts.length - 1].type, sourceSpan);
-        this.parts = parts;
-    }
-    isEquivalent(e) {
-        return e instanceof CommaExpr && areAllEquivalent(this.parts, e.parts);
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitCommaExpr(this, context);
-    }
-    clone() {
-        return new CommaExpr(this.parts.map((p) => p.clone()));
-    }
-}
-exports.CommaExpr = CommaExpr;
-exports.NULL_EXPR = new LiteralExpr(null, null, null);
-exports.TYPED_NULL_EXPR = new LiteralExpr(null, exports.INFERRED_TYPE, null);
-//// Statements
-var StmtModifier;
-(function (StmtModifier) {
-    StmtModifier[StmtModifier["None"] = 0] = "None";
-    StmtModifier[StmtModifier["Final"] = 1] = "Final";
-    StmtModifier[StmtModifier["Private"] = 2] = "Private";
-    StmtModifier[StmtModifier["Exported"] = 4] = "Exported";
-    StmtModifier[StmtModifier["Static"] = 8] = "Static";
-})(StmtModifier || (exports.StmtModifier = StmtModifier = {}));
-class LeadingComment {
-    text;
-    multiline;
-    trailingNewline;
-    constructor(text, multiline, trailingNewline) {
-        this.text = text;
-        this.multiline = multiline;
-        this.trailingNewline = trailingNewline;
-    }
-    toString() {
-        return this.multiline ? ` ${this.text} ` : this.text;
-    }
-}
-exports.LeadingComment = LeadingComment;
-class JSDocComment extends LeadingComment {
-    tags;
-    constructor(tags) {
-        super('', /* multiline */ true, /* trailingNewline */ true);
-        this.tags = tags;
-    }
-    toString() {
-        return serializeTags(this.tags);
-    }
-}
-exports.JSDocComment = JSDocComment;
-class Statement {
-    modifiers;
-    sourceSpan;
-    leadingComments;
-    constructor(modifiers = StmtModifier.None, sourceSpan = null, leadingComments) {
-        this.modifiers = modifiers;
-        this.sourceSpan = sourceSpan;
-        this.leadingComments = leadingComments;
-    }
-    hasModifier(modifier) {
-        return (this.modifiers & modifier) !== 0;
-    }
-    addLeadingComment(leadingComment) {
-        this.leadingComments = this.leadingComments ?? [];
-        this.leadingComments.push(leadingComment);
-    }
-}
-exports.Statement = Statement;
-class DeclareVarStmt extends Statement {
-    name;
-    value;
-    type;
-    constructor(name, value, type, modifiers, sourceSpan, leadingComments) {
-        super(modifiers, sourceSpan, leadingComments);
-        this.name = name;
-        this.value = value;
-        this.type = type || (value && value.type) || null;
-    }
-    isEquivalent(stmt) {
-        return (stmt instanceof DeclareVarStmt &&
-            this.name === stmt.name &&
-            (this.value
-                ? !!stmt.value && this.value.isEquivalent(stmt.value)
-                : !stmt.value));
-    }
-    visitStatement(visitor, context) {
-        return visitor.visitDeclareVarStmt(this, context);
-    }
-}
-exports.DeclareVarStmt = DeclareVarStmt;
-class DeclareFunctionStmt extends Statement {
-    name;
-    params;
-    statements;
-    type;
-    constructor(name, params, statements, type, modifiers, sourceSpan, leadingComments) {
-        super(modifiers, sourceSpan, leadingComments);
-        this.name = name;
-        this.params = params;
-        this.statements = statements;
-        this.type = type || null;
-    }
-    isEquivalent(stmt) {
-        return (stmt instanceof DeclareFunctionStmt &&
-            areAllEquivalent(this.params, stmt.params) &&
-            areAllEquivalent(this.statements, stmt.statements));
-    }
-    visitStatement(visitor, context) {
-        return visitor.visitDeclareFunctionStmt(this, context);
-    }
-}
-exports.DeclareFunctionStmt = DeclareFunctionStmt;
-class ExpressionStatement extends Statement {
-    expr;
-    constructor(expr, sourceSpan, leadingComments) {
-        super(StmtModifier.None, sourceSpan, leadingComments);
-        this.expr = expr;
-    }
-    isEquivalent(stmt) {
-        return (stmt instanceof ExpressionStatement && this.expr.isEquivalent(stmt.expr));
-    }
-    visitStatement(visitor, context) {
-        return visitor.visitExpressionStmt(this, context);
-    }
-}
-exports.ExpressionStatement = ExpressionStatement;
-class ReturnStatement extends Statement {
-    value;
-    constructor(value, sourceSpan = null, leadingComments) {
-        super(StmtModifier.None, sourceSpan, leadingComments);
-        this.value = value;
-    }
-    isEquivalent(stmt) {
-        return (stmt instanceof ReturnStatement && this.value.isEquivalent(stmt.value));
-    }
-    visitStatement(visitor, context) {
-        return visitor.visitReturnStmt(this, context);
-    }
-}
-exports.ReturnStatement = ReturnStatement;
-class IfStmt extends Statement {
-    condition;
-    trueCase;
-    falseCase;
-    constructor(condition, trueCase, falseCase = [], sourceSpan, leadingComments) {
-        super(StmtModifier.None, sourceSpan, leadingComments);
-        this.condition = condition;
-        this.trueCase = trueCase;
-        this.falseCase = falseCase;
-    }
-    isEquivalent(stmt) {
-        return (stmt instanceof IfStmt &&
-            this.condition.isEquivalent(stmt.condition) &&
-            areAllEquivalent(this.trueCase, stmt.trueCase) &&
-            areAllEquivalent(this.falseCase, stmt.falseCase));
-    }
-    visitStatement(visitor, context) {
-        return visitor.visitIfStmt(this, context);
-    }
-}
-exports.IfStmt = IfStmt;
-function leadingComment(text, multiline = false, trailingNewline = true) {
-    return new LeadingComment(text, multiline, trailingNewline);
-}
-exports.leadingComment = leadingComment;
-function jsDocComment(tags = []) {
-    return new JSDocComment(tags);
-}
-exports.jsDocComment = jsDocComment;
-function variable(name, type, sourceSpan) {
-    return new ReadVarExpr(name, type, sourceSpan);
-}
-exports.variable = variable;
-function importExpr(id, typeParams = null, sourceSpan) {
-    return new ExternalExpr(id, null, typeParams, sourceSpan);
-}
-exports.importExpr = importExpr;
-function importType(id, typeParams, typeModifiers) {
-    return id != null
-        ? expressionType(importExpr(id, typeParams, null), typeModifiers)
-        : null;
-}
-exports.importType = importType;
-function expressionType(expr, typeModifiers, typeParams) {
-    return new ExpressionType(expr, typeModifiers, typeParams);
-}
-exports.expressionType = expressionType;
-function transplantedType(type, typeModifiers) {
-    return new TransplantedType(type, typeModifiers);
-}
-exports.transplantedType = transplantedType;
-function typeofExpr(expr) {
-    return new TypeofExpr(expr);
-}
-exports.typeofExpr = typeofExpr;
-function literalArr(values, type, sourceSpan) {
-    return new LiteralArrayExpr(values, type, sourceSpan);
-}
-exports.literalArr = literalArr;
-function literalMap(values, type = null) {
-    return new LiteralMapExpr(values.map((e) => new LiteralMapEntry(e.key, e.value, e.quoted)), type, null);
-}
-exports.literalMap = literalMap;
-function unary(operator, expr, type, sourceSpan) {
-    return new UnaryOperatorExpr(operator, expr, type, sourceSpan);
-}
-exports.unary = unary;
-function not(expr, sourceSpan) {
-    return new NotExpr(expr, sourceSpan);
-}
-exports.not = not;
-function fn(params, body, type, sourceSpan, name) {
-    return new FunctionExpr(params, body, type, sourceSpan, name);
-}
-exports.fn = fn;
-function arrowFn(params, body, type, sourceSpan) {
-    return new ArrowFunctionExpr(params, body, type, sourceSpan);
-}
-exports.arrowFn = arrowFn;
-function ifStmt(condition, thenClause, elseClause, sourceSpan, leadingComments) {
-    return new IfStmt(condition, thenClause, elseClause, sourceSpan, leadingComments);
-}
-exports.ifStmt = ifStmt;
-function literal(value, type, sourceSpan) {
-    return new LiteralExpr(value, type, sourceSpan);
-}
-exports.literal = literal;
-function isNull(exp) {
-    return exp instanceof LiteralExpr && exp.value === null;
-}
-exports.isNull = isNull;
-/*
- * Serializes a `Tag` into a string.
- * Returns a string like " @foo {bar} baz" (note the leading whitespace before `@foo`).
- */
-function tagToString(tag) {
-    let out = '';
-    if (tag.tagName) {
-        out += ` @${tag.tagName}`;
-    }
-    if (tag.text) {
-        if (tag.text.match(/\/\*|\*\//)) {
-            throw new Error('JSDoc text cannot contain "/*" and "*/"');
-        }
-        out += ' ' + tag.text.replace(/@/g, '\\@');
-    }
-    return out;
-}
-function serializeTags(tags) {
-    if (tags.length === 0)
-        return '';
-    if (tags.length === 1 && tags[0].tagName && !tags[0].text) {
-        // The JSDOC comment is a single simple tag: e.g `/** @tagname */`.
-        return `*${tagToString(tags[0])} `;
-    }
-    let out = '*\n';
-    for (const tag of tags) {
-        out += ' *';
-        // If the tagToString is multi-line, insert " * " prefixes on lines.
-        out += tagToString(tag).replace(/\n/g, '\n * ');
-        out += '\n';
-    }
-    out += ' ';
-    return out;
-}