static-injector 1.0.8

package/readme.md

@@ -0,0 +1,27 @@
+# 简介
+
+- 这是 Angualr 依赖注入的独立版本,初始版本逻辑为从 Angular 源码中提取出来,并修复了一些已知 bug
+- 使用方法与 Angular 的依赖注入完全一致
+
+# 使用方法
+
+- 以`Injector.create`创建第一级依赖注入器
+- 声明为依赖注入类即为`@Injectable`装饰器
+
+# 与`injection-js`的不同
+
+- `injection-js`属于动态依赖注入,是 Angular5 之前使用的版本,Angular5 之后转为静态依赖注入
+- 理论上会比`injection-js`快一些(否则 Angular 也不会做替换...),但是没有做 Benchmark
+- 需要会使用`typescript`调用转换器进行转换,或者使用 webpack 的 ts-loader 传入转换器,或者其他转换工具支持 typescript 并且支持 typescript 的自定义转换器
+  > 未来会提供各个打包工具的使用方法
+- 两者基本上可以互换(细节部分需要调整)
+
+# 测试
+
+- 做了一部分的单元测试.保证大部分功能正常使用
+- 因为大部分代码本身就是从 Angular 中提取的,所以稳定性肯定也是有保证
+
+# 模板
+
+- [webpack 下使用](https://github.com/wszgrcy/static-injector-webpack-template)
+- [rollup 下使用](https://github.com/wszgrcy/static-injector-rollup-template)

package/transform/compiler/index.d.ts

@@ -0,0 +1,5 @@
+export * from './src/injectable_compiler_2';
+export * from './src/render3/r3_factory';
+export * from './src/output/output_ast';
+export * from './src/render3/util';
+export * from './src/parse_util';

package/transform/compiler/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/injectable_compiler_2"), exports);
+__exportStar(require("./src/render3/r3_factory"), exports);
+__exportStar(require("./src/output/output_ast"), exports);
+__exportStar(require("./src/render3/util"), exports);
+__exportStar(require("./src/parse_util"), exports);

package/transform/compiler/src/core.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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
+ */
+/**
+ * Injection flags for DI.
+ */
+export declare const enum InjectFlags {
+    Default = 0,
+    /** Don't descend into ancestors of the node requesting injection. */
+    Self = 2,
+    /** Skip the node that is requesting injection. */
+    SkipSelf = 4,
+    /** Inject `defaultValue` instead if token not found. */
+    Optional = 8
+}

package/transform/compiler/src/core.js

@@ -0,0 +1,9 @@
+"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 });

package/transform/compiler/src/injectable_compiler_2.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @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
+ */
+import * as o from "./output/output_ast";
+import { R3DependencyMetadata } from "./render3/r3_factory";
+import { R3CompiledExpression, R3Reference } from "./render3/util";
+export interface R3InjectableMetadata {
+    name: string;
+    type: R3Reference;
+    internalType: o.Expression;
+    typeArgumentCount: number;
+    providedIn: R3ProviderExpression;
+    useClass?: R3ProviderExpression;
+    useFactory?: o.Expression;
+    useExisting?: R3ProviderExpression;
+    useValue?: R3ProviderExpression;
+    deps?: R3DependencyMetadata[];
+}
+/**
+ * An expression used when instantiating an injectable.
+ *
+ * This is the type of the `useClass`, `useExisting` and `useValue` properties of
+ * `R3InjectableMetadata` since those can refer to types that may eagerly reference types that have
+ * not yet been defined.
+ */
+export interface R3ProviderExpression<T extends o.Expression = o.Expression> {
+    /**
+     * The expression that is used to instantiate the Injectable.
+     */
+    expression: T;
+    /**
+     * If true, then the `expression` contains a reference to something that has not yet been
+     * defined.
+     *
+     * This means that the expression must not be eagerly evaluated. Instead it must be wrapped in a
+     * function closure that will be evaluated lazily to allow the definition of the expression to be
+     * evaluated first.
+     *
+     * In some cases the expression will naturally be placed inside such a function closure, such as
+     * in a fully compiled factory function. In those case nothing more needs to be done.
+     *
+     * But in other cases, such as partial-compilation the expression will be located in top level
+     * code so will need to be wrapped in a function that is passed to a `forwardRef()` call.
+     */
+    isForwardRef: boolean;
+}
+export declare function createR3ProviderExpression<T extends o.Expression>(expression: T, isForwardRef: boolean): R3ProviderExpression<T>;
+export declare function compileInjectable(meta: R3InjectableMetadata, resolveForwardRefs: boolean): R3CompiledExpression;
+export declare function createInjectableType(meta: R3InjectableMetadata): o.ExpressionType;

package/transform/compiler/src/injectable_compiler_2.js

@@ -0,0 +1,159 @@
+"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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInjectableType = exports.compileInjectable = exports.createR3ProviderExpression = void 0;
+const o = __importStar(require("./output/output_ast"));
+const util_1 = require("./render3/partial/util");
+const r3_factory_1 = require("./render3/r3_factory");
+const r3_identifiers_1 = require("./render3/r3_identifiers");
+const util_2 = require("./render3/util");
+const util_3 = require("./render3/view/util");
+function createR3ProviderExpression(expression, isForwardRef) {
+    return { expression, isForwardRef };
+}
+exports.createR3ProviderExpression = createR3ProviderExpression;
+function compileInjectable(meta, resolveForwardRefs) {
+    let result = null;
+    const factoryMeta = {
+        name: meta.name,
+        type: meta.type,
+        internalType: meta.internalType,
+        typeArgumentCount: meta.typeArgumentCount,
+        deps: [],
+        target: r3_factory_1.FactoryTarget.Injectable,
+    };
+    if (meta.useClass !== undefined) {
+        // meta.useClass has two modes of operation. Either deps are specified, in which case `new` is
+        // used to instantiate the class with dependencies injected, or deps are not specified and
+        // the factory of the class is used to instantiate it.
+        //
+        // A special case exists for useClass: Type where Type is the injectable type itself and no
+        // deps are specified, in which case 'useClass' is effectively ignored.
+        const useClassOnSelf = meta.useClass.expression.isEquivalent(meta.internalType);
+        let deps = undefined;
+        if (meta.deps !== undefined) {
+            deps = meta.deps;
+        }
+        if (deps !== undefined) {
+            // factory: () => new meta.useClass(...deps)
+            result = r3_factory_1.compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { delegate: meta.useClass.expression, delegateDeps: deps, delegateType: r3_factory_1.R3FactoryDelegateType.Class }));
+        }
+        else if (useClassOnSelf) {
+            result = r3_factory_1.compileFactoryFunction(factoryMeta);
+        }
+        else {
+            result = {
+                statements: [],
+                expression: delegateToFactory(meta.type.value, meta.useClass.expression, resolveForwardRefs),
+            };
+        }
+    }
+    else if (meta.useFactory !== undefined) {
+        if (meta.deps !== undefined) {
+            result = r3_factory_1.compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { delegate: meta.useFactory, delegateDeps: meta.deps || [], delegateType: r3_factory_1.R3FactoryDelegateType.Function }));
+        }
+        else {
+            result = {
+                statements: [],
+                expression: o.fn([], [new o.ReturnStatement(meta.useFactory.callFn([]))]),
+            };
+        }
+    }
+    else if (meta.useValue !== undefined) {
+        // Note: it's safe to use `meta.useValue` instead of the `USE_VALUE in meta` check used for
+        // client code because meta.useValue is an Expression which will be defined even if the actual
+        // value is undefined.
+        result = r3_factory_1.compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { expression: meta.useValue.expression }));
+    }
+    else if (meta.useExisting !== undefined) {
+        // useExisting is an `inject` call on the existing token.
+        result = r3_factory_1.compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { expression: o
+                .importExpr(r3_identifiers_1.Identifiers.inject)
+                .callFn([meta.useExisting.expression]) }));
+    }
+    else {
+        result = {
+            statements: [],
+            expression: delegateToFactory(meta.type.value, meta.internalType, resolveForwardRefs),
+        };
+    }
+    const token = meta.internalType;
+    const injectableProps = new util_3.DefinitionMap();
+    injectableProps.set("token", token);
+    injectableProps.set("factory", result.expression);
+    // Only generate providedIn property if it has a non-null value
+    if (meta.providedIn.expression.value !== null) {
+        injectableProps.set("providedIn", meta.providedIn.isForwardRef
+            ? util_1.generateForwardRef(meta.providedIn.expression)
+            : meta.providedIn.expression);
+    }
+    const expression = o
+        .importExpr(r3_identifiers_1.Identifiers.ɵɵdefineInjectable)
+        .callFn([injectableProps.toLiteralMap()], undefined, true);
+    return {
+        expression,
+        type: createInjectableType(meta),
+        statements: result.statements,
+    };
+}
+exports.compileInjectable = compileInjectable;
+function createInjectableType(meta) {
+    return new o.ExpressionType(o.importExpr(r3_identifiers_1.Identifiers.InjectableDeclaration, [
+        util_2.typeWithParameters(meta.type.type, meta.typeArgumentCount),
+    ]));
+}
+exports.createInjectableType = createInjectableType;
+function delegateToFactory(type, internalType, unwrapForwardRefs) {
+    if (type.node === internalType.node) {
+        // The types are the same, so we can simply delegate directly to the type's factory.
+        // ```
+        // factory: type.ɵfac
+        // ```
+        return internalType.prop("ɵfac");
+    }
+    if (!unwrapForwardRefs) {
+        // The type is not wrapped in a `forwardRef()`, so we create a simple factory function that
+        // accepts a sub-type as an argument.
+        // ```
+        // factory: function(t) { return internalType.ɵfac(t); }
+        // ```
+        return createFactoryFunction(internalType);
+    }
+    // The internalType is actually wrapped in a `forwardRef()` so we need to resolve that before
+    // calling its factory.
+    // ```
+    // factory: function(t) { return core.resolveForwardRef(type).ɵfac(t); }
+    // ```
+    const unwrappedType = o
+        .importExpr(r3_identifiers_1.Identifiers.resolveForwardRef)
+        .callFn([internalType]);
+    return createFactoryFunction(unwrappedType);
+}
+function createFactoryFunction(type) {
+    return o.fn([new o.FnParam("t", o.DYNAMIC_TYPE)], [new o.ReturnStatement(type.callMethod("ɵfac", [o.variable("t")]))]);
+}

package/transform/compiler/src/output/output_ast.d.ts

@@ -0,0 +1,534 @@
+/**
+ * @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
+ */
+import { ParseSourceSpan } from '../parse_util';
+export declare enum TypeModifier {
+    Const = 0
+}
+export declare abstract class Type {
+    modifiers: TypeModifier[];
+    constructor(modifiers?: TypeModifier[]);
+    abstract visitType(visitor: TypeVisitor, context: any): any;
+    hasModifier(modifier: TypeModifier): boolean;
+}
+export declare enum BuiltinTypeName {
+    Dynamic = 0,
+    Bool = 1,
+    String = 2,
+    Int = 3,
+    Number = 4,
+    Function = 5,
+    Inferred = 6,
+    None = 7
+}
+export declare class BuiltinType extends Type {
+    name: BuiltinTypeName;
+    constructor(name: BuiltinTypeName, modifiers?: TypeModifier[]);
+    visitType(visitor: TypeVisitor, context: any): any;
+}
+export declare class ExpressionType extends Type {
+    value: Expression;
+    typeParams: Type[] | null;
+    constructor(value: Expression, modifiers?: TypeModifier[], typeParams?: Type[] | null);
+    visitType(visitor: TypeVisitor, context: any): any;
+}
+export declare class ArrayType extends Type {
+    of: Type;
+    constructor(of: Type, modifiers?: TypeModifier[]);
+    visitType(visitor: TypeVisitor, context: any): any;
+}
+export declare class MapType extends Type {
+    valueType: Type | null;
+    constructor(valueType: Type | null | undefined, modifiers?: TypeModifier[]);
+    visitType(visitor: TypeVisitor, context: any): any;
+}
+export declare const DYNAMIC_TYPE: BuiltinType;
+export declare const INFERRED_TYPE: BuiltinType;
+export declare const BOOL_TYPE: BuiltinType;
+export declare const INT_TYPE: BuiltinType;
+export declare const NUMBER_TYPE: BuiltinType;
+export declare const STRING_TYPE: BuiltinType;
+export declare const FUNCTION_TYPE: BuiltinType;
+export declare const NONE_TYPE: BuiltinType;
+export interface TypeVisitor {
+    visitBuiltinType(type: BuiltinType, context: any): any;
+    visitExpressionType(type: ExpressionType, context: any): any;
+    visitArrayType(type: ArrayType, context: any): any;
+    visitMapType(type: MapType, context: any): any;
+}
+export declare enum UnaryOperator {
+    Minus = 0,
+    Plus = 1
+}
+export declare enum BinaryOperator {
+    Equals = 0,
+    NotEquals = 1,
+    Identical = 2,
+    NotIdentical = 3,
+    Minus = 4,
+    Plus = 5,
+    Divide = 6,
+    Multiply = 7,
+    Modulo = 8,
+    And = 9,
+    Or = 10,
+    BitwiseAnd = 11,
+    Lower = 12,
+    LowerEquals = 13,
+    Bigger = 14,
+    BiggerEquals = 15,
+    NullishCoalesce = 16
+}
+export declare function nullSafeIsEquivalent<T extends {
+    isEquivalent(other: T): boolean;
+}>(base: T | null, other: T | null): boolean;
+export declare function areAllEquivalent<T extends {
+    isEquivalent(other: T): boolean;
+}>(base: T[], other: T[]): boolean;
+export declare abstract class Expression {
+    type: Type | null;
+    sourceSpan: ParseSourceSpan | null;
+    constructor(type: Type | null | undefined, sourceSpan?: ParseSourceSpan | null);
+    abstract visitExpression(visitor: ExpressionVisitor, context: any): any;
+    /**
+     * Calculates whether this expression produces the same value as the given expression.
+     * Note: We don't check Types nor ParseSourceSpans nor function arguments.
+     */
+    abstract isEquivalent(e: Expression): boolean;
+    /**
+     * Return true if the expression is constant.
+     */
+    abstract isConstant(): boolean;
+    prop(name: string, sourceSpan?: ParseSourceSpan | null): ReadPropExpr;
+    callMethod(name: string | BuiltinMethod, params: Expression[], sourceSpan?: ParseSourceSpan | null): InvokeMethodExpr;
+    callFn(params: Expression[], sourceSpan?: ParseSourceSpan | null, pure?: boolean): InvokeFunctionExpr;
+    toStmt(): Statement;
+}
+export declare enum BuiltinVar {
+    This = 0,
+    Super = 1,
+    CatchError = 2,
+    CatchStack = 3
+}
+export declare class ReadVarExpr extends Expression {
+    name: string | null;
+    builtin: BuiltinVar | null;
+    constructor(name: string | BuiltinVar, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+    set(value: Expression): WriteVarExpr;
+}
+export declare class TypeofExpr extends Expression {
+    expr: Expression;
+    constructor(expr: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+}
+export declare class WrappedNodeExpr<T> extends Expression {
+    node: T;
+    constructor(node: T, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class WriteVarExpr extends Expression {
+    name: string;
+    value: Expression;
+    constructor(name: string, value: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+    toDeclStmt(type?: Type | null, modifiers?: StmtModifier[]): DeclareVarStmt;
+    toConstDecl(): DeclareVarStmt;
+}
+export declare class WriteKeyExpr extends Expression {
+    receiver: Expression;
+    index: Expression;
+    value: Expression;
+    constructor(receiver: Expression, index: Expression, value: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class WritePropExpr extends Expression {
+    receiver: Expression;
+    name: string;
+    value: Expression;
+    constructor(receiver: Expression, name: string, value: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare enum BuiltinMethod {
+    ConcatArray = 0,
+    SubscribeObservable = 1,
+    Bind = 2
+}
+export declare class InvokeMethodExpr extends Expression {
+    receiver: Expression;
+    args: Expression[];
+    name: string | null;
+    builtin: BuiltinMethod | null;
+    constructor(receiver: Expression, method: string | BuiltinMethod, args: Expression[], type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class InvokeFunctionExpr extends Expression {
+    fn: Expression;
+    args: Expression[];
+    pure: boolean;
+    constructor(fn: Expression, args: Expression[], type?: Type | null, sourceSpan?: ParseSourceSpan | null, pure?: boolean);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class InstantiateExpr extends Expression {
+    classExpr: Expression;
+    args: Expression[];
+    constructor(classExpr: Expression, args: Expression[], type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class LiteralExpr extends Expression {
+    value: number | string | boolean | null | undefined;
+    constructor(value: number | string | boolean | null | undefined, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class TemplateLiteral {
+    elements: TemplateLiteralElement[];
+    expressions: Expression[];
+    constructor(elements: TemplateLiteralElement[], expressions: Expression[]);
+}
+export declare class TemplateLiteralElement {
+    text: string;
+    sourceSpan?: ParseSourceSpan;
+    rawText: string;
+    constructor(text: string, sourceSpan?: ParseSourceSpan, rawText?: string);
+}
+export declare abstract class MessagePiece {
+    text: string;
+    sourceSpan: ParseSourceSpan;
+    constructor(text: string, sourceSpan: ParseSourceSpan);
+}
+export declare class LiteralPiece extends MessagePiece {
+}
+export declare class PlaceholderPiece extends MessagePiece {
+}
+/**
+ * A structure to hold the cooked and raw strings of a template literal element, along with its
+ * source-span range.
+ */
+export interface CookedRawString {
+    cooked: string;
+    raw: string;
+    range: ParseSourceSpan | null;
+}
+export declare class ExternalExpr extends Expression {
+    value: ExternalReference;
+    typeParams: Type[] | null;
+    constructor(value: ExternalReference, type?: Type | null, typeParams?: Type[] | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class ExternalReference {
+    moduleName: string | null;
+    name: string | null;
+    runtime?: any | null;
+    constructor(moduleName: string | null, name: string | null, runtime?: any | null);
+}
+export declare class ConditionalExpr extends Expression {
+    condition: Expression;
+    falseCase: Expression | null;
+    trueCase: Expression;
+    constructor(condition: Expression, trueCase: Expression, falseCase?: Expression | null, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class NotExpr extends Expression {
+    condition: Expression;
+    constructor(condition: Expression, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class AssertNotNull extends Expression {
+    condition: Expression;
+    constructor(condition: Expression, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class CastExpr extends Expression {
+    value: Expression;
+    constructor(value: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class FnParam {
+    name: string;
+    type: Type | null;
+    constructor(name: string, type?: Type | null);
+    isEquivalent(param: FnParam): boolean;
+}
+export declare class FunctionExpr extends Expression {
+    params: FnParam[];
+    statements: Statement[];
+    name?: string | null;
+    constructor(params: FnParam[], statements: Statement[], type?: Type | null, sourceSpan?: ParseSourceSpan | null, name?: string | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+    toDeclStmt(name: string, modifiers?: StmtModifier[]): DeclareFunctionStmt;
+}
+export declare class UnaryOperatorExpr extends Expression {
+    operator: UnaryOperator;
+    expr: Expression;
+    parens: boolean;
+    constructor(operator: UnaryOperator, expr: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null, parens?: boolean);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class BinaryOperatorExpr extends Expression {
+    operator: BinaryOperator;
+    rhs: Expression;
+    parens: boolean;
+    lhs: Expression;
+    constructor(operator: BinaryOperator, lhs: Expression, rhs: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null, parens?: boolean);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class ReadPropExpr extends Expression {
+    receiver: Expression;
+    name: string;
+    constructor(receiver: Expression, name: string, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+    set(value: Expression): WritePropExpr;
+}
+export declare class ReadKeyExpr extends Expression {
+    receiver: Expression;
+    index: Expression;
+    constructor(receiver: Expression, index: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+    set(value: Expression): WriteKeyExpr;
+}
+export declare class LiteralArrayExpr extends Expression {
+    entries: Expression[];
+    constructor(entries: Expression[], type?: Type | null, sourceSpan?: ParseSourceSpan | null);
+    isConstant(): boolean;
+    isEquivalent(e: Expression): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class LiteralMapEntry {
+    key: string;
+    value: Expression;
+    quoted: boolean;
+    constructor(key: string, value: Expression, quoted: boolean);
+    isEquivalent(e: LiteralMapEntry): boolean;
+}
+export declare class LiteralMapExpr extends Expression {
+    entries: LiteralMapEntry[];
+    valueType: Type | null;
+    constructor(entries: LiteralMapEntry[], type?: MapType | null, sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export declare class CommaExpr extends Expression {
+    parts: Expression[];
+    constructor(parts: Expression[], sourceSpan?: ParseSourceSpan | null);
+    isEquivalent(e: Expression): boolean;
+    isConstant(): boolean;
+    visitExpression(visitor: ExpressionVisitor, context: any): any;
+}
+export interface ExpressionVisitor {
+    visitReadVarExpr(ast: ReadVarExpr, context: any): any;
+    visitWriteVarExpr(expr: WriteVarExpr, context: any): any;
+    visitWriteKeyExpr(expr: WriteKeyExpr, context: any): any;
+    visitWritePropExpr(expr: WritePropExpr, context: any): any;
+    visitInvokeMethodExpr(ast: InvokeMethodExpr, context: any): any;
+    visitInvokeFunctionExpr(ast: InvokeFunctionExpr, context: any): any;
+    visitInstantiateExpr(ast: InstantiateExpr, context: any): any;
+    visitLiteralExpr(ast: LiteralExpr, context: any): any;
+    visitExternalExpr(ast: ExternalExpr, context: any): any;
+    visitConditionalExpr(ast: ConditionalExpr, context: any): any;
+    visitNotExpr(ast: NotExpr, context: any): any;
+    visitAssertNotNullExpr(ast: AssertNotNull, context: any): any;
+    visitCastExpr(ast: CastExpr, context: any): any;
+    visitFunctionExpr(ast: FunctionExpr, context: any): any;
+    visitUnaryOperatorExpr(ast: UnaryOperatorExpr, context: any): any;
+    visitBinaryOperatorExpr(ast: BinaryOperatorExpr, context: any): any;
+    visitReadPropExpr(ast: ReadPropExpr, context: any): any;
+    visitReadKeyExpr(ast: ReadKeyExpr, context: any): any;
+    visitLiteralArrayExpr(ast: LiteralArrayExpr, context: any): any;
+    visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any;
+    visitCommaExpr(ast: CommaExpr, context: any): any;
+    visitWrappedNodeExpr(ast: WrappedNodeExpr<any>, context: any): any;
+    visitTypeofExpr(ast: TypeofExpr, context: any): any;
+}
+export declare const THIS_EXPR: ReadVarExpr;
+export declare const SUPER_EXPR: ReadVarExpr;
+export declare const CATCH_ERROR_VAR: ReadVarExpr;
+export declare const CATCH_STACK_VAR: ReadVarExpr;
+export declare const NULL_EXPR: LiteralExpr;
+export declare const TYPED_NULL_EXPR: LiteralExpr;
+export declare enum StmtModifier {
+    Final = 0,
+    Private = 1,
+    Exported = 2,
+    Static = 3
+}
+export declare class LeadingComment {
+    text: string;
+    multiline: boolean;
+    trailingNewline: boolean;
+    constructor(text: string, multiline: boolean, trailingNewline: boolean);
+    toString(): string;
+}
+export declare class JSDocComment extends LeadingComment {
+    tags: JSDocTag[];
+    constructor(tags: JSDocTag[]);
+    toString(): string;
+}
+export declare abstract class Statement {
+    modifiers: StmtModifier[];
+    sourceSpan: ParseSourceSpan | null;
+    leadingComments?: LeadingComment[];
+    constructor(modifiers?: StmtModifier[], sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
+    /**
+     * Calculates whether this statement produces the same value as the given statement.
+     * Note: We don't check Types nor ParseSourceSpans nor function arguments.
+     */
+    abstract isEquivalent(stmt: Statement): boolean;
+    abstract visitStatement(visitor: StatementVisitor, context: any): any;
+    hasModifier(modifier: StmtModifier): boolean;
+    addLeadingComment(leadingComment: LeadingComment): void;
+}
+export declare class DeclareVarStmt extends Statement {
+    name: string;
+    value?: Expression;
+    type: Type | null;
+    constructor(name: string, value?: Expression, type?: Type | null, modifiers?: StmtModifier[], sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
+    isEquivalent(stmt: Statement): boolean;
+    visitStatement(visitor: StatementVisitor, context: any): any;
+}
+export declare class DeclareFunctionStmt extends Statement {
+    name: string;
+    params: FnParam[];
+    statements: Statement[];
+    type: Type | null;
+    constructor(name: string, params: FnParam[], statements: Statement[], type?: Type | null, modifiers?: StmtModifier[], sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
+    isEquivalent(stmt: Statement): boolean;
+    visitStatement(visitor: StatementVisitor, context: any): any;
+}
+export declare class ExpressionStatement extends Statement {
+    expr: Expression;
+    constructor(expr: Expression, sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
+    isEquivalent(stmt: Statement): boolean;
+    visitStatement(visitor: StatementVisitor, context: any): any;
+}
+export declare class ReturnStatement extends Statement {
+    value: Expression;
+    constructor(value: Expression, sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
+    isEquivalent(stmt: Statement): boolean;
+    visitStatement(visitor: StatementVisitor, context: any): any;
+}
+export declare class AbstractClassPart {
+    type: Type | null;
+    modifiers: StmtModifier[];
+    constructor(type?: Type | null, modifiers?: StmtModifier[]);
+    hasModifier(modifier: StmtModifier): boolean;
+}
+export declare class ClassField extends AbstractClassPart {
+    name: string;
+    initializer?: Expression;
+    constructor(name: string, type?: Type | null, modifiers?: StmtModifier[], initializer?: Expression);
+    isEquivalent(f: ClassField): boolean;
+}
+export declare class ClassMethod extends AbstractClassPart {
+    name: string | null;
+    params: FnParam[];
+    body: Statement[];
+    constructor(name: string | null, params: FnParam[], body: Statement[], type?: Type | null, modifiers?: StmtModifier[]);
+    isEquivalent(m: ClassMethod): boolean;
+}
+export declare class ClassGetter extends AbstractClassPart {
+    name: string;
+    body: Statement[];
+    constructor(name: string, body: Statement[], type?: Type | null, modifiers?: StmtModifier[]);
+    isEquivalent(m: ClassGetter): boolean;
+}
+export declare class ClassStmt extends Statement {
+    name: string;
+    parent: Expression | null;
+    fields: ClassField[];
+    getters: ClassGetter[];
+    constructorMethod: ClassMethod;
+    methods: ClassMethod[];
+    constructor(name: string, parent: Expression | null, fields: ClassField[], getters: ClassGetter[], constructorMethod: ClassMethod, methods: ClassMethod[], modifiers?: StmtModifier[], sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
+    isEquivalent(stmt: Statement): boolean;
+    visitStatement(visitor: StatementVisitor, context: any): any;
+}
+export declare class IfStmt extends Statement {
+    condition: Expression;
+    trueCase: Statement[];
+    falseCase: Statement[];
+    constructor(condition: Expression, trueCase: Statement[], falseCase?: Statement[], sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
+    isEquivalent(stmt: Statement): boolean;
+    visitStatement(visitor: StatementVisitor, context: any): any;
+}
+export interface StatementVisitor {
+    visitDeclareVarStmt(stmt: DeclareVarStmt, context: any): any;
+    visitDeclareFunctionStmt(stmt: DeclareFunctionStmt, context: any): any;
+    visitExpressionStmt(stmt: ExpressionStatement, context: any): any;
+    visitReturnStmt(stmt: ReturnStatement, context: any): any;
+    visitDeclareClassStmt(stmt: ClassStmt, context: any): any;
+    visitIfStmt(stmt: IfStmt, context: any): any;
+}
+export declare function variable(name: string, type?: Type | null, sourceSpan?: ParseSourceSpan | null): ReadVarExpr;
+export declare function importExpr(id: ExternalReference, typeParams?: Type[] | null, sourceSpan?: ParseSourceSpan | null): ExternalExpr;
+export declare function expressionType(expr: Expression, typeModifiers?: TypeModifier[], typeParams?: Type[] | null): ExpressionType;
+export declare function typeofExpr(expr: Expression): TypeofExpr;
+export declare function literalArr(values: Expression[], type?: Type | null, sourceSpan?: ParseSourceSpan | null): LiteralArrayExpr;
+export declare function literalMap(values: {
+    key: string;
+    quoted: boolean;
+    value: Expression;
+}[], type?: MapType | null): LiteralMapExpr;
+export declare function unary(operator: UnaryOperator, expr: Expression, type?: Type, sourceSpan?: ParseSourceSpan | null): UnaryOperatorExpr;
+export declare function not(expr: Expression, sourceSpan?: ParseSourceSpan | null): NotExpr;
+export declare function assertNotNull(expr: Expression, sourceSpan?: ParseSourceSpan | null): AssertNotNull;
+export declare function fn(params: FnParam[], body: Statement[], type?: Type | null, sourceSpan?: ParseSourceSpan | null, name?: string | null): FunctionExpr;
+export declare function ifStmt(condition: Expression, thenClause: Statement[], elseClause?: Statement[], sourceSpan?: ParseSourceSpan, leadingComments?: LeadingComment[]): IfStmt;
+export declare function literal(value: any, type?: Type | null, sourceSpan?: ParseSourceSpan | null): LiteralExpr;
+export declare function isNull(exp: Expression): boolean;
+export declare const enum JSDocTagName {
+    Desc = "desc",
+    Id = "id",
+    Meaning = "meaning"
+}
+export declare type JSDocTag = {
+    tagName: JSDocTagName | string;
+    text?: string;
+} | {
+    tagName?: undefined;
+    text: string;
+};