static-injector 1.0.10 → 2.1.0

package/transform/compiler/public_api.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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
+ */
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of this package.
+ */
+export * from './src/compiler';

package/transform/compiler/public_api.js

@@ -0,0 +1,30 @@
+"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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 });
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of this package.
+ */
+__exportStar(require("./src/compiler"), exports);
+// This file only reexports content of the `src` folder. Keep it that way.

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

@@ -0,0 +1,27 @@
+/**
+ * @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
+ */
+/**
+ * @module
+ * @description
+ * Entry point for all APIs of the compiler package.
+ *
+ * <div class="callout is-critical">
+ *   <header>Unstable APIs</header>
+ *   <p>
+ *     All compiler apis are currently considered experimental and private!
+ *   </p>
+ *   <p>
+ *     We expect the APIs in this package to keep on changing. Do not rely on them.
+ *   </p>
+ * </div>
+ */
+export * from './injectable_compiler_2';
+export * from './render3/r3_factory';
+export * from './output/output_ast';
+export * from './render3/util';
+export * from './parse_util';

package/transform/compiler/src/compiler.js

@@ -0,0 +1,47 @@
+"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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 });
+//////////////////////////////////////
+// THIS FILE HAS GLOBAL SIDE EFFECT //
+//       (see bottom of file)       //
+//////////////////////////////////////
+/**
+ * @module
+ * @description
+ * Entry point for all APIs of the compiler package.
+ *
+ * <div class="callout is-critical">
+ *   <header>Unstable APIs</header>
+ *   <p>
+ *     All compiler apis are currently considered experimental and private!
+ *   </p>
+ *   <p>
+ *     We expect the APIs in this package to keep on changing. Do not rely on them.
+ *   </p>
+ * </div>
+ */
+__exportStar(require("./injectable_compiler_2"), exports);
+__exportStar(require("./render3/r3_factory"), exports);
+__exportStar(require("./output/output_ast"), exports);
+__exportStar(require("./render3/util"), exports);
+__exportStar(require("./parse_util"), exports);

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

@@ -5,49 +5,20 @@
  * 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";
+import * as o from './output/output_ast';
+import { R3DependencyMetadata } from './render3/r3_factory';
+import { MaybeForwardRefExpression, R3CompiledExpression, R3Reference } from './render3/util';
 export interface R3InjectableMetadata {
     name: string;
     type: R3Reference;
     internalType: o.Expression;
     typeArgumentCount: number;
-    providedIn: R3ProviderExpression;
-    useClass?: R3ProviderExpression;
+    providedIn: MaybeForwardRefExpression;
+    useClass?: MaybeForwardRefExpression;
     useFactory?: o.Expression;
-    useExisting?: R3ProviderExpression;
-    useValue?: R3ProviderExpression;
+    useExisting?: MaybeForwardRefExpression;
+    useValue?: MaybeForwardRefExpression;
     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

@@ -8,7 +8,11 @@
  */
 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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -26,17 +30,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInjectableType = exports.compileInjectable = exports.createR3ProviderExpression = void 0;
+exports.createInjectableType = exports.compileInjectable = 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;
+const util_1 = require("./render3/util");
+const util_2 = require("./render3/view/util");
 function compileInjectable(meta, resolveForwardRefs) {
     let result = null;
     const factoryMeta = {
@@ -61,10 +60,10 @@ function compileInjectable(meta, resolveForwardRefs) {
         }
         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 }));
+            result = (0, 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);
+            result = (0, r3_factory_1.compileFactoryFunction)(factoryMeta);
         }
         else {
             result = {
@@ -75,7 +74,7 @@ function compileInjectable(meta, 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 }));
+            result = (0, r3_factory_1.compileFactoryFunction)(Object.assign(Object.assign({}, factoryMeta), { delegate: meta.useFactory, delegateDeps: meta.deps || [], delegateType: r3_factory_1.R3FactoryDelegateType.Function }));
         }
         else {
             result = {
@@ -88,11 +87,11 @@ function compileInjectable(meta, resolveForwardRefs) {
         // 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 }));
+        result = (0, 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
+        result = (0, r3_factory_1.compileFactoryFunction)(Object.assign(Object.assign({}, factoryMeta), { expression: o
                 .importExpr(r3_identifiers_1.Identifiers.inject)
                 .callFn([meta.useExisting.expression]) }));
     }
@@ -103,14 +102,12 @@ function compileInjectable(meta, resolveForwardRefs) {
         };
     }
     const token = meta.internalType;
-    const injectableProps = new util_3.DefinitionMap();
-    injectableProps.set("token", token);
-    injectableProps.set("factory", result.expression);
+    const injectableProps = new util_2.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);
+        injectableProps.set('providedIn', (0, util_1.convertFromMaybeForwardRefExpression)(meta.providedIn));
     }
     const expression = o
         .importExpr(r3_identifiers_1.Identifiers.ɵɵdefineInjectable)
@@ -124,7 +121,7 @@ function compileInjectable(meta, resolveForwardRefs) {
 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),
+        (0, util_1.typeWithParameters)(meta.type.type, meta.typeArgumentCount),
     ]));
 }
 exports.createInjectableType = createInjectableType;
@@ -134,7 +131,7 @@ function delegateToFactory(type, internalType, unwrapForwardRefs) {
         // ```
         // factory: type.ɵfac
         // ```
-        return internalType.prop("ɵfac");
+        return internalType.prop('ɵfac');
     }
     if (!unwrapForwardRefs) {
         // The type is not wrapped in a `forwardRef()`, so we create a simple factory function that
@@ -155,5 +152,5 @@ function delegateToFactory(type, internalType, unwrapForwardRefs) {
     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")]))]);
+    return o.fn([new o.FnParam('t', o.DYNAMIC_TYPE)], [new o.ReturnStatement(type.prop('ɵfac').callFn([o.variable('t')]))]);
 }

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

@@ -7,11 +7,12 @@
  */
 import { ParseSourceSpan } from '../parse_util';
 export declare enum TypeModifier {
-    Const = 0
+    None = 0,
+    Const = 1
 }
 export declare abstract class Type {
-    modifiers: TypeModifier[];
-    constructor(modifiers?: TypeModifier[]);
+    modifiers: TypeModifier;
+    constructor(modifiers?: TypeModifier);
     abstract visitType(visitor: TypeVisitor, context: any): any;
     hasModifier(modifier: TypeModifier): boolean;
 }
@@ -27,23 +28,23 @@ export declare enum BuiltinTypeName {
 }
 export declare class BuiltinType extends Type {
     name: BuiltinTypeName;
-    constructor(name: BuiltinTypeName, modifiers?: TypeModifier[]);
+    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);
+    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[]);
+    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[]);
+    constructor(valueType: Type | null | undefined, modifiers?: TypeModifier);
     visitType(visitor: TypeVisitor, context: any): any;
 }
 export declare const DYNAMIC_TYPE: BuiltinType;
@@ -104,20 +105,13 @@ export declare abstract class Expression {
      */
     abstract isConstant(): boolean;
     prop(name: string, sourceSpan?: ParseSourceSpan | null): ReadPropExpr;
-    callMethod(name: string | BuiltinMethod, params: Expression[], sourceSpan?: ParseSourceSpan | null): InvokeMethodExpr;
+    key(index: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null): ReadKeyExpr;
     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);
+    name: string;
+    constructor(name: string, type?: Type | null, sourceSpan?: ParseSourceSpan | null);
     isEquivalent(e: Expression): boolean;
     isConstant(): boolean;
     visitExpression(visitor: ExpressionVisitor, context: any): any;
@@ -144,7 +138,7 @@ export declare class WriteVarExpr extends Expression {
     isEquivalent(e: Expression): boolean;
     isConstant(): boolean;
     visitExpression(visitor: ExpressionVisitor, context: any): any;
-    toDeclStmt(type?: Type | null, modifiers?: StmtModifier[]): DeclareVarStmt;
+    toDeclStmt(type?: Type | null, modifiers?: StmtModifier): DeclareVarStmt;
     toConstDecl(): DeclareVarStmt;
 }
 export declare class WriteKeyExpr extends Expression {
@@ -165,21 +159,6 @@ export declare class WritePropExpr extends Expression {
     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[];
@@ -215,15 +194,11 @@ export declare class TemplateLiteralElement {
     rawText: string;
     constructor(text: string, sourceSpan?: ParseSourceSpan, rawText?: string);
 }
-export declare abstract class MessagePiece {
+export declare class LiteralPiece {
     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.
@@ -263,20 +238,6 @@ export declare class NotExpr extends Expression {
     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;
@@ -291,7 +252,7 @@ export declare class FunctionExpr extends Expression {
     isEquivalent(e: Expression): boolean;
     isConstant(): boolean;
     visitExpression(visitor: ExpressionVisitor, context: any): any;
-    toDeclStmt(name: string, modifiers?: StmtModifier[]): DeclareFunctionStmt;
+    toDeclStmt(name: string, modifiers?: StmtModifier): DeclareFunctionStmt;
 }
 export declare class UnaryOperatorExpr extends Expression {
     operator: UnaryOperator;
@@ -364,15 +325,12 @@ export interface ExpressionVisitor {
     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;
@@ -384,17 +342,14 @@ export interface ExpressionVisitor {
     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
+    None = 0,
+    Final = 1,
+    Private = 2,
+    Exported = 4,
+    Static = 8
 }
 export declare class LeadingComment {
     text: string;
@@ -409,10 +364,10 @@ export declare class JSDocComment extends LeadingComment {
     toString(): string;
 }
 export declare abstract class Statement {
-    modifiers: StmtModifier[];
+    modifiers: StmtModifier;
     sourceSpan: ParseSourceSpan | null;
     leadingComments?: LeadingComment[];
-    constructor(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.
@@ -426,7 +381,7 @@ 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[]);
+    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;
 }
@@ -435,7 +390,7 @@ export declare class DeclareFunctionStmt extends Statement {
     params: FnParam[];
     statements: Statement[];
     type: Type | null;
-    constructor(name: string, params: FnParam[], statements: Statement[], type?: Type | null, modifiers?: StmtModifier[], sourceSpan?: ParseSourceSpan | null, leadingComments?: LeadingComment[]);
+    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;
 }
@@ -451,42 +406,6 @@ export declare class ReturnStatement extends Statement {
     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[];
@@ -500,12 +419,14 @@ export interface StatementVisitor {
     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 leadingComment(text: string, multiline?: boolean, trailingNewline?: boolean): LeadingComment;
+export declare function jsDocComment(tags?: JSDocTag[]): JSDocComment;
 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 importType(id: ExternalReference, typeParams?: Type[] | null, typeModifiers?: TypeModifier): ExpressionType | null;
+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: {
@@ -515,7 +436,6 @@ export declare function literalMap(values: {
 }[], 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;
@@ -523,9 +443,10 @@ export declare function isNull(exp: Expression): boolean;
 export declare const enum JSDocTagName {
     Desc = "desc",
     Id = "id",
-    Meaning = "meaning"
+    Meaning = "meaning",
+    Suppress = "suppress"
 }
-export declare type JSDocTag = {
+export type JSDocTag = {
     tagName: JSDocTagName | string;
     text?: string;
 } | {