static-injector 1.0.8

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

@@ -0,0 +1,986 @@
+"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.LiteralArrayExpr = exports.ReadKeyExpr = exports.ReadPropExpr = exports.BinaryOperatorExpr = exports.UnaryOperatorExpr = exports.FunctionExpr = exports.FnParam = exports.CastExpr = exports.AssertNotNull = exports.NotExpr = exports.ConditionalExpr = exports.ExternalReference = exports.ExternalExpr = exports.PlaceholderPiece = exports.LiteralPiece = exports.MessagePiece = exports.TemplateLiteralElement = exports.TemplateLiteral = exports.LiteralExpr = exports.InstantiateExpr = exports.InvokeFunctionExpr = exports.InvokeMethodExpr = exports.BuiltinMethod = exports.WritePropExpr = exports.WriteKeyExpr = exports.WriteVarExpr = exports.WrappedNodeExpr = exports.TypeofExpr = exports.ReadVarExpr = exports.BuiltinVar = 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.MapType = exports.ArrayType = exports.ExpressionType = exports.BuiltinType = exports.BuiltinTypeName = exports.Type = exports.TypeModifier = void 0;
+exports.isNull = exports.literal = exports.ifStmt = exports.fn = exports.assertNotNull = exports.not = exports.unary = exports.literalMap = exports.literalArr = exports.typeofExpr = exports.expressionType = exports.importExpr = exports.variable = exports.IfStmt = exports.ClassStmt = exports.ClassGetter = exports.ClassMethod = exports.ClassField = exports.AbstractClassPart = exports.ReturnStatement = exports.ExpressionStatement = exports.DeclareFunctionStmt = exports.DeclareVarStmt = exports.Statement = exports.JSDocComment = exports.LeadingComment = exports.StmtModifier = exports.TYPED_NULL_EXPR = exports.NULL_EXPR = exports.CATCH_STACK_VAR = exports.CATCH_ERROR_VAR = exports.SUPER_EXPR = exports.THIS_EXPR = exports.CommaExpr = exports.LiteralMapExpr = exports.LiteralMapEntry = void 0;
+//// Types
+var TypeModifier;
+(function (TypeModifier) {
+    TypeModifier[TypeModifier["Const"] = 0] = "Const";
+})(TypeModifier = exports.TypeModifier || (exports.TypeModifier = {}));
+class Type {
+    constructor(modifiers = []) {
+        this.modifiers = modifiers;
+    }
+    hasModifier(modifier) {
+        return this.modifiers.indexOf(modifier) !== -1;
+    }
+}
+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 || (exports.BuiltinTypeName = {}));
+class BuiltinType extends Type {
+    constructor(name, modifiers) {
+        super(modifiers);
+        this.name = name;
+    }
+    visitType(visitor, context) {
+        return visitor.visitBuiltinType(this, context);
+    }
+}
+exports.BuiltinType = BuiltinType;
+class ExpressionType extends Type {
+    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 {
+    constructor(of, modifiers) {
+        super(modifiers);
+        this.of = of;
+    }
+    visitType(visitor, context) {
+        return visitor.visitArrayType(this, context);
+    }
+}
+exports.ArrayType = ArrayType;
+class MapType extends Type {
+    constructor(valueType, modifiers) {
+        super(modifiers);
+        this.valueType = valueType || null;
+    }
+    visitType(visitor, context) {
+        return visitor.visitMapType(this, context);
+    }
+}
+exports.MapType = MapType;
+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 || (exports.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["BitwiseAnd"] = 11] = "BitwiseAnd";
+    BinaryOperator[BinaryOperator["Lower"] = 12] = "Lower";
+    BinaryOperator[BinaryOperator["LowerEquals"] = 13] = "LowerEquals";
+    BinaryOperator[BinaryOperator["Bigger"] = 14] = "Bigger";
+    BinaryOperator[BinaryOperator["BiggerEquals"] = 15] = "BiggerEquals";
+    BinaryOperator[BinaryOperator["NullishCoalesce"] = 16] = "NullishCoalesce";
+})(BinaryOperator = exports.BinaryOperator || (exports.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 {
+    constructor(type, sourceSpan) {
+        this.type = type || null;
+        this.sourceSpan = sourceSpan || null;
+    }
+    prop(name, sourceSpan) {
+        return new ReadPropExpr(this, name, null, sourceSpan);
+    }
+    callMethod(name, params, sourceSpan) {
+        return new InvokeMethodExpr(this, name, params, null, sourceSpan);
+    }
+    callFn(params, sourceSpan, pure) {
+        return new InvokeFunctionExpr(this, params, null, sourceSpan, pure);
+    }
+    toStmt() {
+        return new ExpressionStatement(this, null);
+    }
+}
+exports.Expression = Expression;
+var BuiltinVar;
+(function (BuiltinVar) {
+    BuiltinVar[BuiltinVar["This"] = 0] = "This";
+    BuiltinVar[BuiltinVar["Super"] = 1] = "Super";
+    BuiltinVar[BuiltinVar["CatchError"] = 2] = "CatchError";
+    BuiltinVar[BuiltinVar["CatchStack"] = 3] = "CatchStack";
+})(BuiltinVar = exports.BuiltinVar || (exports.BuiltinVar = {}));
+class ReadVarExpr extends Expression {
+    constructor(name, type, sourceSpan) {
+        super(type, sourceSpan);
+        if (typeof name === 'string') {
+            this.name = name;
+            this.builtin = null;
+        }
+        else {
+            this.name = null;
+            this.builtin = name;
+        }
+    }
+    isEquivalent(e) {
+        return (e instanceof ReadVarExpr &&
+            this.name === e.name &&
+            this.builtin === e.builtin);
+    }
+    isConstant() {
+        return false;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitReadVarExpr(this, context);
+    }
+    set(value) {
+        if (!this.name) {
+            throw new Error(`Built in variable ${this.builtin} can not be assigned to.`);
+        }
+        return new WriteVarExpr(this.name, value, null, this.sourceSpan);
+    }
+}
+exports.ReadVarExpr = ReadVarExpr;
+class TypeofExpr extends Expression {
+    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();
+    }
+}
+exports.TypeofExpr = TypeofExpr;
+class WrappedNodeExpr extends Expression {
+    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);
+    }
+}
+exports.WrappedNodeExpr = WrappedNodeExpr;
+class WriteVarExpr extends Expression {
+    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);
+    }
+    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 {
+    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);
+    }
+}
+exports.WriteKeyExpr = WriteKeyExpr;
+class WritePropExpr extends Expression {
+    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);
+    }
+}
+exports.WritePropExpr = WritePropExpr;
+var BuiltinMethod;
+(function (BuiltinMethod) {
+    BuiltinMethod[BuiltinMethod["ConcatArray"] = 0] = "ConcatArray";
+    BuiltinMethod[BuiltinMethod["SubscribeObservable"] = 1] = "SubscribeObservable";
+    BuiltinMethod[BuiltinMethod["Bind"] = 2] = "Bind";
+})(BuiltinMethod = exports.BuiltinMethod || (exports.BuiltinMethod = {}));
+class InvokeMethodExpr extends Expression {
+    constructor(receiver, method, args, type, sourceSpan) {
+        super(type, sourceSpan);
+        this.receiver = receiver;
+        this.args = args;
+        if (typeof method === 'string') {
+            this.name = method;
+            this.builtin = null;
+        }
+        else {
+            this.name = null;
+            this.builtin = method;
+        }
+    }
+    isEquivalent(e) {
+        return (e instanceof InvokeMethodExpr &&
+            this.receiver.isEquivalent(e.receiver) &&
+            this.name === e.name &&
+            this.builtin === e.builtin &&
+            areAllEquivalent(this.args, e.args));
+    }
+    isConstant() {
+        return false;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitInvokeMethodExpr(this, context);
+    }
+}
+exports.InvokeMethodExpr = InvokeMethodExpr;
+class InvokeFunctionExpr extends Expression {
+    constructor(fn, args, type, sourceSpan, pure = false) {
+        super(type, sourceSpan);
+        this.fn = fn;
+        this.args = args;
+        this.pure = pure;
+    }
+    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);
+    }
+}
+exports.InvokeFunctionExpr = InvokeFunctionExpr;
+class InstantiateExpr extends Expression {
+    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);
+    }
+}
+exports.InstantiateExpr = InstantiateExpr;
+class LiteralExpr extends Expression {
+    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);
+    }
+}
+exports.LiteralExpr = LiteralExpr;
+class TemplateLiteral {
+    constructor(elements, expressions) {
+        this.elements = elements;
+        this.expressions = expressions;
+    }
+}
+exports.TemplateLiteral = TemplateLiteral;
+class TemplateLiteralElement {
+    constructor(text, sourceSpan, rawText) {
+        var _a;
+        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 =
+            (_a = rawText !== null && rawText !== void 0 ? rawText : sourceSpan === null || sourceSpan === void 0 ? void 0 : sourceSpan.toString()) !== null && _a !== void 0 ? _a : escapeForTemplateLiteral(escapeSlashes(text));
+    }
+}
+exports.TemplateLiteralElement = TemplateLiteralElement;
+class MessagePiece {
+    constructor(text, sourceSpan) {
+        this.text = text;
+        this.sourceSpan = sourceSpan;
+    }
+}
+exports.MessagePiece = MessagePiece;
+class LiteralPiece extends MessagePiece {
+}
+exports.LiteralPiece = LiteralPiece;
+class PlaceholderPiece extends MessagePiece {
+}
+exports.PlaceholderPiece = PlaceholderPiece;
+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, '$\\{');
+class ExternalExpr extends Expression {
+    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);
+    }
+}
+exports.ExternalExpr = ExternalExpr;
+class ExternalReference {
+    constructor(moduleName, name, runtime) {
+        this.moduleName = moduleName;
+        this.name = name;
+        this.runtime = runtime;
+    }
+}
+exports.ExternalReference = ExternalReference;
+class ConditionalExpr extends Expression {
+    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);
+    }
+}
+exports.ConditionalExpr = ConditionalExpr;
+class NotExpr extends Expression {
+    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);
+    }
+}
+exports.NotExpr = NotExpr;
+class AssertNotNull extends Expression {
+    constructor(condition, sourceSpan) {
+        super(condition.type, sourceSpan);
+        this.condition = condition;
+    }
+    isEquivalent(e) {
+        return (e instanceof AssertNotNull && this.condition.isEquivalent(e.condition));
+    }
+    isConstant() {
+        return false;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitAssertNotNullExpr(this, context);
+    }
+}
+exports.AssertNotNull = AssertNotNull;
+class CastExpr extends Expression {
+    constructor(value, type, sourceSpan) {
+        super(type, sourceSpan);
+        this.value = value;
+    }
+    isEquivalent(e) {
+        return e instanceof CastExpr && this.value.isEquivalent(e.value);
+    }
+    isConstant() {
+        return false;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitCastExpr(this, context);
+    }
+}
+exports.CastExpr = CastExpr;
+class FnParam {
+    constructor(name, type = null) {
+        this.name = name;
+        this.type = type;
+    }
+    isEquivalent(param) {
+        return this.name === param.name;
+    }
+}
+exports.FnParam = FnParam;
+class FunctionExpr extends Expression {
+    constructor(params, statements, type, sourceSpan, name) {
+        super(type, sourceSpan);
+        this.params = params;
+        this.statements = statements;
+        this.name = name;
+    }
+    isEquivalent(e) {
+        return (e instanceof FunctionExpr &&
+            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);
+    }
+}
+exports.FunctionExpr = FunctionExpr;
+class UnaryOperatorExpr extends Expression {
+    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);
+    }
+}
+exports.UnaryOperatorExpr = UnaryOperatorExpr;
+class BinaryOperatorExpr extends Expression {
+    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);
+    }
+}
+exports.BinaryOperatorExpr = BinaryOperatorExpr;
+class ReadPropExpr extends Expression {
+    constructor(receiver, name, type, sourceSpan) {
+        super(type, sourceSpan);
+        this.receiver = receiver;
+        this.name = 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);
+    }
+}
+exports.ReadPropExpr = ReadPropExpr;
+class ReadKeyExpr extends Expression {
+    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);
+    }
+}
+exports.ReadKeyExpr = ReadKeyExpr;
+class LiteralArrayExpr extends Expression {
+    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);
+    }
+}
+exports.LiteralArrayExpr = LiteralArrayExpr;
+class LiteralMapEntry {
+    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);
+    }
+}
+exports.LiteralMapEntry = LiteralMapEntry;
+class LiteralMapExpr extends Expression {
+    constructor(entries, type, sourceSpan) {
+        super(type, sourceSpan);
+        this.entries = entries;
+        this.valueType = null;
+        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);
+    }
+}
+exports.LiteralMapExpr = LiteralMapExpr;
+class CommaExpr extends Expression {
+    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);
+    }
+}
+exports.CommaExpr = CommaExpr;
+exports.THIS_EXPR = new ReadVarExpr(BuiltinVar.This, null, null);
+exports.SUPER_EXPR = new ReadVarExpr(BuiltinVar.Super, null, null);
+exports.CATCH_ERROR_VAR = new ReadVarExpr(BuiltinVar.CatchError, null, null);
+exports.CATCH_STACK_VAR = new ReadVarExpr(BuiltinVar.CatchStack, null, null);
+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["Final"] = 0] = "Final";
+    StmtModifier[StmtModifier["Private"] = 1] = "Private";
+    StmtModifier[StmtModifier["Exported"] = 2] = "Exported";
+    StmtModifier[StmtModifier["Static"] = 3] = "Static";
+})(StmtModifier = exports.StmtModifier || (exports.StmtModifier = {}));
+class LeadingComment {
+    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 {
+    constructor(tags) {
+        super('', /* multiline */ true, /* trailingNewline */ true);
+        this.tags = tags;
+    }
+    toString() {
+        return serializeTags(this.tags);
+    }
+}
+exports.JSDocComment = JSDocComment;
+class Statement {
+    constructor(modifiers = [], sourceSpan = null, leadingComments) {
+        this.modifiers = modifiers;
+        this.sourceSpan = sourceSpan;
+        this.leadingComments = leadingComments;
+    }
+    hasModifier(modifier) {
+        return this.modifiers.indexOf(modifier) !== -1;
+    }
+    addLeadingComment(leadingComment) {
+        var _a;
+        this.leadingComments = (_a = this.leadingComments) !== null && _a !== void 0 ? _a : [];
+        this.leadingComments.push(leadingComment);
+    }
+}
+exports.Statement = Statement;
+class DeclareVarStmt extends Statement {
+    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 {
+    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 {
+    constructor(expr, sourceSpan, leadingComments) {
+        super([], 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 {
+    constructor(value, sourceSpan = null, leadingComments) {
+        super([], 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 AbstractClassPart {
+    constructor(type = null, modifiers = []) {
+        this.type = type;
+        this.modifiers = modifiers;
+    }
+    hasModifier(modifier) {
+        return this.modifiers.indexOf(modifier) !== -1;
+    }
+}
+exports.AbstractClassPart = AbstractClassPart;
+class ClassField extends AbstractClassPart {
+    constructor(name, type, modifiers, initializer) {
+        super(type, modifiers);
+        this.name = name;
+        this.initializer = initializer;
+    }
+    isEquivalent(f) {
+        return this.name === f.name;
+    }
+}
+exports.ClassField = ClassField;
+class ClassMethod extends AbstractClassPart {
+    constructor(name, params, body, type, modifiers) {
+        super(type, modifiers);
+        this.name = name;
+        this.params = params;
+        this.body = body;
+    }
+    isEquivalent(m) {
+        return this.name === m.name && areAllEquivalent(this.body, m.body);
+    }
+}
+exports.ClassMethod = ClassMethod;
+class ClassGetter extends AbstractClassPart {
+    constructor(name, body, type, modifiers) {
+        super(type, modifiers);
+        this.name = name;
+        this.body = body;
+    }
+    isEquivalent(m) {
+        return this.name === m.name && areAllEquivalent(this.body, m.body);
+    }
+}
+exports.ClassGetter = ClassGetter;
+class ClassStmt extends Statement {
+    constructor(name, parent, fields, getters, constructorMethod, methods, modifiers, sourceSpan, leadingComments) {
+        super(modifiers, sourceSpan, leadingComments);
+        this.name = name;
+        this.parent = parent;
+        this.fields = fields;
+        this.getters = getters;
+        this.constructorMethod = constructorMethod;
+        this.methods = methods;
+    }
+    isEquivalent(stmt) {
+        return (stmt instanceof ClassStmt &&
+            this.name === stmt.name &&
+            nullSafeIsEquivalent(this.parent, stmt.parent) &&
+            areAllEquivalent(this.fields, stmt.fields) &&
+            areAllEquivalent(this.getters, stmt.getters) &&
+            this.constructorMethod.isEquivalent(stmt.constructorMethod) &&
+            areAllEquivalent(this.methods, stmt.methods));
+    }
+    visitStatement(visitor, context) {
+        return visitor.visitDeclareClassStmt(this, context);
+    }
+}
+exports.ClassStmt = ClassStmt;
+class IfStmt extends Statement {
+    constructor(condition, trueCase, falseCase = [], sourceSpan, leadingComments) {
+        super([], 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 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 expressionType(expr, typeModifiers, typeParams) {
+    return new ExpressionType(expr, typeModifiers, typeParams);
+}
+exports.expressionType = expressionType;
+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 assertNotNull(expr, sourceSpan) {
+    return new AssertNotNull(expr, sourceSpan);
+}
+exports.assertNotNull = assertNotNull;
+function fn(params, body, type, sourceSpan, name) {
+    return new FunctionExpr(params, body, type, sourceSpan, name);
+}
+exports.fn = fn;
+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;
+}