static-injector 2.1.1 → 2.2.1

package/transform/compiler/src/render3/r3_factory.js

@@ -31,7 +31,7 @@ var R3FactoryDelegateType;
 (function (R3FactoryDelegateType) {
     R3FactoryDelegateType[R3FactoryDelegateType["Class"] = 0] = "Class";
     R3FactoryDelegateType[R3FactoryDelegateType["Function"] = 1] = "Function";
-})(R3FactoryDelegateType = exports.R3FactoryDelegateType || (exports.R3FactoryDelegateType = {}));
+})(R3FactoryDelegateType || (exports.R3FactoryDelegateType = R3FactoryDelegateType = {}));
 var FactoryTarget;
 (function (FactoryTarget) {
     FactoryTarget[FactoryTarget["Directive"] = 0] = "Directive";
@@ -39,7 +39,7 @@ var FactoryTarget;
     FactoryTarget[FactoryTarget["Injectable"] = 2] = "Injectable";
     FactoryTarget[FactoryTarget["Pipe"] = 3] = "Pipe";
     FactoryTarget[FactoryTarget["NgModule"] = 4] = "NgModule";
-})(FactoryTarget = exports.FactoryTarget || (exports.FactoryTarget = {}));
+})(FactoryTarget || (exports.FactoryTarget = FactoryTarget = {}));
 /**
  * Construct a factory function expression for the given `R3FactoryMetadata`.
  */
@@ -52,7 +52,7 @@ function compileFactoryFunction(meta) {
     // delegated factory (which is used to create the current type) then this is only the type-to-
     // create parameter (t).
     const typeForCtor = !isDelegatedFactoryMetadata(meta)
-        ? new o.BinaryOperatorExpr(o.BinaryOperator.Or, t, meta.internalType)
+        ? new o.BinaryOperatorExpr(o.BinaryOperator.Or, t, meta.type.value)
         : t;
     let ctorExpr = null;
     if (meta.deps !== null) {
@@ -102,7 +102,7 @@ function compileFactoryFunction(meta) {
         // This factory uses a base factory, so call `ɵɵgetInheritedFactory()` to compute it.
         const getInheritedFactoryCall = o
             .importExpr(r3_identifiers_1.Identifiers.getInheritedFactory)
-            .callFn([meta.internalType]);
+            .callFn([meta.type.value]);
         // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))`
         const baseFactory = new o.BinaryOperatorExpr(o.BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
         body.push(new o.ReturnStatement(baseFactory.callFn([typeForCtor])));
@@ -168,6 +168,7 @@ function compileInjectDependency(dep, target, index) {
         return o.importExpr(injectFn).callFn(injectArgs);
     }
     else {
+        throw new Error('compileInjectDependency');
     }
 }
 function createCtorDepsType(deps) {

package/transform/compiler/src/render3/r3_identifiers.js

@@ -10,42 +10,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Identifiers = void 0;
 const CORE = 'static-injector';
 class Identifiers {
+    static inject = { name: 'ɵɵinject', moduleName: CORE };
+    static directiveInject = {
+        name: 'ɵɵdirectiveInject',
+        moduleName: CORE,
+    };
+    static invalidFactory = {
+        name: 'ɵɵinvalidFactory',
+        moduleName: CORE,
+    };
+    static invalidFactoryDep = {
+        name: 'ɵɵinvalidFactoryDep',
+        moduleName: CORE,
+    };
+    static forwardRef = {
+        name: 'forwardRef',
+        moduleName: CORE,
+    };
+    static resolveForwardRef = {
+        name: 'resolveForwardRef',
+        moduleName: CORE,
+    };
+    static ɵɵdefineInjectable = {
+        name: 'ɵɵdefineInjectable',
+        moduleName: CORE,
+    };
+    static InjectableDeclaration = {
+        name: 'ɵɵInjectableDeclaration',
+        moduleName: CORE,
+    };
+    static FactoryDeclaration = {
+        name: 'ɵɵFactoryDeclaration',
+        moduleName: CORE,
+    };
+    static getInheritedFactory = {
+        name: 'ɵɵgetInheritedFactory',
+        moduleName: CORE,
+    };
 }
 exports.Identifiers = Identifiers;
-Identifiers.inject = { name: 'ɵɵinject', moduleName: CORE };
-Identifiers.directiveInject = {
-    name: 'ɵɵdirectiveInject',
-    moduleName: CORE,
-};
-Identifiers.invalidFactory = {
-    name: 'ɵɵinvalidFactory',
-    moduleName: CORE,
-};
-Identifiers.invalidFactoryDep = {
-    name: 'ɵɵinvalidFactoryDep',
-    moduleName: CORE,
-};
-Identifiers.forwardRef = {
-    name: 'forwardRef',
-    moduleName: CORE,
-};
-Identifiers.resolveForwardRef = {
-    name: 'resolveForwardRef',
-    moduleName: CORE,
-};
-Identifiers.ɵɵdefineInjectable = {
-    name: 'ɵɵdefineInjectable',
-    moduleName: CORE,
-};
-Identifiers.InjectableDeclaration = {
-    name: 'ɵɵInjectableDeclaration',
-    moduleName: CORE,
-};
-Identifiers.FactoryDeclaration = {
-    name: 'ɵɵFactoryDeclaration',
-    moduleName: CORE,
-};
-Identifiers.getInheritedFactory = {
-    name: 'ɵɵgetInheritedFactory',
-    moduleName: CORE,
-};

package/transform/compiler/src/render3/view/util.js

@@ -38,9 +38,7 @@ const o = __importStar(require("../../output/output_ast"));
  * property names that are set can be resolved to their documented declaration.
  */
 class DefinitionMap {
-    constructor() {
-        this.values = [];
-    }
+    values = [];
     set(key, value) {
         if (value) {
             this.values.push({ key: key, value, quoted: false });

package/transform/compiler-cli/src/ngtsc/annotations/common/src/di.js

@@ -14,7 +14,6 @@ exports.validateConstructorDependencies = exports.getValidConstructorDependencie
 const compiler_1 = require("static-injector/transform/compiler");
 const typescript_1 = __importDefault(require("typescript"));
 const diagnostics_1 = require("../../../diagnostics");
-const reflection_1 = require("../../../reflection");
 const util_1 = require("./util");
 function getConstructorDependencies(clazz, reflector, isCore) {
     const deps = [];
@@ -38,7 +37,7 @@ function getConstructorDependencies(clazz, reflector, isCore) {
             const name = isCore || dec.import === null ? dec.name : dec.import.name;
             if (name === 'Inject') {
                 if (dec.args === null || dec.args.length !== 1) {
-                    throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARITY_WRONG, reflection_1.Decorator.nodeForError(dec), `Unexpected number of arguments to @Inject().`);
+                    throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARITY_WRONG, dec.node, `Unexpected number of arguments to @Inject().`);
                 }
                 token = new compiler_1.WrappedNodeExpr(dec.args[0]);
             }
@@ -56,7 +55,7 @@ function getConstructorDependencies(clazz, reflector, isCore) {
             else if (name === 'Attribute') {
             }
             else {
-                throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_UNEXPECTED, reflection_1.Decorator.nodeForError(dec), `Unexpected decorator ${name} on parameter.`);
+                throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_UNEXPECTED, dec.node, `Unexpected decorator ${name} on parameter.`);
             }
         });
         if (token === null) {
@@ -120,7 +119,6 @@ function validateConstructorDependencies(clazz, deps) {
         return deps.deps;
     }
     else {
-        // TODO(alxhub): this cast is necessary because the g3 typescript version doesn't narrow here.
         // There is at least one error.
         const error = deps.errors[0];
         throw createUnsuitableInjectionTokenError(clazz, error);

package/transform/compiler-cli/src/ngtsc/annotations/common/src/factory.js

@@ -16,6 +16,7 @@ function compileNgFactoryDefField(metadata) {
         initializer: res.expression,
         statements: res.statements,
         type: res.type,
+        deferrableImports: null,
     };
 }
 exports.compileNgFactoryDefField = compileNgFactoryDefField;

package/transform/compiler-cli/src/ngtsc/annotations/common/src/util.d.ts

@@ -54,7 +54,7 @@ export declare function wrapFunctionExpressionsInParens(expression: ts.Expressio
  * Create an R3Reference for a class.
  *
  * The `value` is the exported declaration of the class from its source file.
- * The `type` is an expression that would be used by ngcc in the typings (.d.ts) files.
+ * The `type` is an expression that would be used in the typings (.d.ts) files.
  */
 export declare function wrapTypeReference(reflector: ReflectionHost, clazz: ClassDeclaration): R3Reference;
 export declare function toFactoryMetadata(meta: Omit<R3FactoryMetadata, 'target'>, target: FactoryTarget): R3FactoryMetadata;

package/transform/compiler-cli/src/ngtsc/annotations/common/src/util.js

@@ -13,7 +13,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAbstractClassDeclaration = exports.toFactoryMetadata = exports.wrapTypeReference = exports.wrapFunctionExpressionsInParens = exports.tryUnwrapForwardRef = exports.unwrapExpression = exports.isAngularDecorator = exports.findAngularDecorator = exports.isAngularCore = exports.valueReferenceToExpression = void 0;
 const compiler_1 = require("static-injector/transform/compiler");
 const typescript_1 = __importDefault(require("typescript"));
-const reflection_1 = require("../../../reflection");
 function valueReferenceToExpression(valueRef) {
     if (valueRef.kind === 2 /* TypeValueReferenceKind.UNAVAILABLE */) {
         return null;
@@ -152,14 +151,11 @@ exports.wrapFunctionExpressionsInParens = wrapFunctionExpressionsInParens;
  * Create an R3Reference for a class.
  *
  * The `value` is the exported declaration of the class from its source file.
- * The `type` is an expression that would be used by ngcc in the typings (.d.ts) files.
+ * The `type` is an expression that would be used in the typings (.d.ts) files.
  */
 function wrapTypeReference(reflector, clazz) {
-    const dtsClass = reflector.getDtsDeclaration(clazz);
     const value = new compiler_1.WrappedNodeExpr(clazz.name);
-    const type = dtsClass !== null && (0, reflection_1.isNamedClassDeclaration)(dtsClass)
-        ? new compiler_1.WrappedNodeExpr(dtsClass.name)
-        : value;
+    const type = value;
     return { value, type };
 }
 exports.wrapTypeReference = wrapTypeReference;
@@ -167,7 +163,6 @@ function toFactoryMetadata(meta, target) {
     return {
         name: meta.name,
         type: meta.type,
-        internalType: meta.internalType,
         typeArgumentCount: meta.typeArgumentCount,
         deps: meta.deps,
         target,
@@ -175,7 +170,8 @@ function toFactoryMetadata(meta, target) {
 }
 exports.toFactoryMetadata = toFactoryMetadata;
 function isAbstractClassDeclaration(clazz) {
-    return (clazz.modifiers !== undefined &&
-        clazz.modifiers.some((mod) => mod.kind === typescript_1.default.SyntaxKind.AbstractKeyword));
+    return typescript_1.default.canHaveModifiers(clazz) && clazz.modifiers !== undefined
+        ? clazz.modifiers.some((mod) => mod.kind === typescript_1.default.SyntaxKind.AbstractKeyword)
+        : false;
 }
 exports.isAbstractClassDeclaration = isAbstractClassDeclaration;

package/transform/compiler-cli/src/ngtsc/annotations/src/injectable.d.ts

@@ -19,6 +19,7 @@ export declare class InjectableDecoratorHandler implements DecoratorHandler<Deco
     private reflector;
     private isCore;
     private strictCtorDeps;
+    private includeClassMetadata;
     /**
      * What to do if the injectable already contains a ɵprov property.
      *
@@ -26,7 +27,7 @@ export declare class InjectableDecoratorHandler implements DecoratorHandler<Deco
      * If false then there is no error and a new ɵprov property is not added.
      */
     private errorOnDuplicateProv;
-    constructor(reflector: ReflectionHost, isCore: boolean, strictCtorDeps: boolean, 
+    constructor(reflector: ReflectionHost, isCore: boolean, strictCtorDeps: boolean, includeClassMetadata: boolean, 
     /**
      * What to do if the injectable already contains a ɵprov property.
      *

package/transform/compiler-cli/src/ngtsc/annotations/src/injectable.js

@@ -21,7 +21,12 @@ const common_2 = require("../common");
  * Adapts the `compileInjectable` compiler for `@Injectable` decorators to the Ivy compiler.
  */
 class InjectableDecoratorHandler {
-    constructor(reflector, isCore, strictCtorDeps, 
+    reflector;
+    isCore;
+    strictCtorDeps;
+    includeClassMetadata;
+    errorOnDuplicateProv;
+    constructor(reflector, isCore, strictCtorDeps, includeClassMetadata, 
     /**
      * What to do if the injectable already contains a ɵprov property.
      *
@@ -32,6 +37,7 @@ class InjectableDecoratorHandler {
         this.reflector = reflector;
         this.isCore = isCore;
         this.strictCtorDeps = strictCtorDeps;
+        this.includeClassMetadata = includeClassMetadata;
         this.errorOnDuplicateProv = errorOnDuplicateProv;
     }
     detect(node, decorators) {
@@ -68,7 +74,7 @@ class InjectableDecoratorHandler {
         const results = [];
         if (true) {
             const meta = analysis.meta;
-            const factoryRes = compileFactoryFn((0, common_2.toFactoryMetadata)(Object.assign(Object.assign({}, meta), { deps: analysis.ctorDeps }), compiler_1.FactoryTarget.Injectable));
+            const factoryRes = compileFactoryFn((0, common_2.toFactoryMetadata)({ ...meta, deps: analysis.ctorDeps }, compiler_1.FactoryTarget.Injectable));
             results.push(factoryRes);
         }
         const ɵprov = this.reflector
@@ -85,6 +91,7 @@ class InjectableDecoratorHandler {
                 initializer: res.expression,
                 statements: res.statements,
                 type: res.type,
+                deferrableImports: null,
             });
         }
         return results;
@@ -100,17 +107,15 @@ exports.InjectableDecoratorHandler = InjectableDecoratorHandler;
 function extractInjectableMetadata(clazz, decorator, reflector) {
     const name = clazz.name.text;
     const type = (0, common_2.wrapTypeReference)(reflector, clazz);
-    const internalType = new compiler_1.WrappedNodeExpr(reflector.getInternalNameOfClass(clazz));
     const typeArgumentCount = reflector.getGenericArityOfClass(clazz) || 0;
     if (decorator.args === null) {
-        throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_NOT_CALLED, reflection_1.Decorator.nodeForError(decorator), '@Injectable must be called');
+        throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_NOT_CALLED, decorator.node, '@Injectable must be called');
     }
     if (decorator.args.length === 0) {
         return {
             name,
             type,
             typeArgumentCount,
-            internalType,
             providedIn: (0, compiler_1.createMayBeForwardRefExpression)(new compiler_1.LiteralExpr(null), 0 /* ForwardRefHandling.None */),
         };
     }
@@ -139,7 +144,6 @@ function extractInjectableMetadata(clazz, decorator, reflector) {
             name,
             type,
             typeArgumentCount,
-            internalType,
             providedIn,
         };
         if (meta.has('useValue')) {
@@ -171,13 +175,13 @@ function extractInjectableMetadata(clazz, decorator, reflector) {
  */
 function getProviderExpression(expression, reflector) {
     const forwardRefValue = (0, common_2.tryUnwrapForwardRef)(expression, reflector);
-    return (0, compiler_1.createMayBeForwardRefExpression)(new compiler_1.WrappedNodeExpr(forwardRefValue !== null && forwardRefValue !== void 0 ? forwardRefValue : expression), forwardRefValue !== null
+    return (0, compiler_1.createMayBeForwardRefExpression)(new compiler_1.WrappedNodeExpr(forwardRefValue ?? expression), forwardRefValue !== null
         ? 2 /* ForwardRefHandling.Unwrapped */
         : 0 /* ForwardRefHandling.None */);
 }
 function extractInjectableCtorDeps(clazz, meta, decorator, reflector, isCore, strictCtorDeps) {
     if (decorator.args === null) {
-        throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_NOT_CALLED, reflection_1.Decorator.nodeForError(decorator), '@Injectable must be called');
+        throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_NOT_CALLED, decorator.node, '@Injectable must be called');
     }
     let ctorDeps = null;
     if (decorator.args.length === 0) {

package/transform/compiler-cli/src/ngtsc/diagnostics/error.d.ts

@@ -11,8 +11,8 @@ export declare class FatalDiagnosticError {
     readonly code: ErrorCode;
     readonly node: ts.Node;
     readonly message: string | ts.DiagnosticMessageChain;
-    readonly relatedInformation?: ts.DiagnosticRelatedInformation[];
-    constructor(code: ErrorCode, node: ts.Node, message: string | ts.DiagnosticMessageChain, relatedInformation?: ts.DiagnosticRelatedInformation[]);
+    readonly relatedInformation?: ts.DiagnosticRelatedInformation[] | undefined;
+    constructor(code: ErrorCode, node: ts.Node, message: string | ts.DiagnosticMessageChain, relatedInformation?: ts.DiagnosticRelatedInformation[] | undefined);
     /**
      * @internal
      */

package/transform/compiler-cli/src/ngtsc/diagnostics/error.js

@@ -34,16 +34,20 @@ exports.isFatalDiagnosticError = exports.makeRelatedInformation = exports.makeDi
 const ts = __importStar(require("typescript"));
 const error_code_1 = require("./error_code");
 class FatalDiagnosticError {
+    code;
+    node;
+    message;
+    relatedInformation;
     constructor(code, node, message, relatedInformation) {
         this.code = code;
         this.node = node;
         this.message = message;
         this.relatedInformation = relatedInformation;
-        /**
-         * @internal
-         */
-        this._isFatalDiagnosticError = true;
     }
+    /**
+     * @internal
+     */
+    _isFatalDiagnosticError = true;
     toDiagnostic() {
         return makeDiagnostic(this.code, this.node, this.message, this.relatedInformation);
     }

package/transform/compiler-cli/src/ngtsc/diagnostics/error_code.js

@@ -175,7 +175,7 @@ var ErrorCode;
      * type inference.
      */
     ErrorCode[ErrorCode["SUGGEST_SUBOPTIMAL_TYPE_INFERENCE"] = 10002] = "SUGGEST_SUBOPTIMAL_TYPE_INFERENCE";
-})(ErrorCode = exports.ErrorCode || (exports.ErrorCode = {}));
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
 /**
  * @internal
  * Base URL for the error details page.

package/transform/compiler-cli/src/ngtsc/imports/src/default.js

@@ -22,7 +22,6 @@ exports.attachDefaultImportDeclaration = attachDefaultImportDeclaration;
  * dependency.
  */
 function getDefaultImportDeclaration(expr) {
-    var _a;
-    return ((_a = expr[DefaultImportDeclaration]) !== null && _a !== void 0 ? _a : null);
+    return (expr[DefaultImportDeclaration] ?? null);
 }
 exports.getDefaultImportDeclaration = getDefaultImportDeclaration;

package/transform/compiler-cli/src/ngtsc/reflection/src/host.d.ts

@@ -7,11 +7,9 @@
  */
 import ts from 'typescript';
 /**
- * Metadata extracted from an instance of a decorator on another declaration, or synthesized from
- * other information about a class.
+ * Metadata extracted from an instance of a decorator on another declaration.
  */
-export type Decorator = ConcreteDecorator | SyntheticDecorator;
-export interface BaseDecorator {
+export interface Decorator {
     /**
      * Name by which the decorator was invoked in the user's code.
      *
@@ -22,48 +20,25 @@ export interface BaseDecorator {
     /**
      * Identifier which refers to the decorator in the user's code.
      */
-    identifier: DecoratorIdentifier | null;
+    identifier: DecoratorIdentifier;
     /**
      * `Import` by which the decorator was brought into the module in which it was invoked, or `null`
      * if the decorator was declared in the same module and not imported.
+     *
+     * Note: this field is declared using computed property syntax to work around a clang-format bug
+     * that resulted in inconsistent indentation of this comment block.
      */
-    import: Import | null;
+    ['import']: Import | null;
     /**
-     * TypeScript reference to the decorator itself, or `null` if the decorator is synthesized (e.g.
-     * in ngcc).
+     * TypeScript reference to the decorator itself.
      */
-    node: ts.Node | null;
+    node: ts.Node;
     /**
      * Arguments of the invocation of the decorator, if the decorator is invoked, or `null`
      * otherwise.
      */
     args: ts.Expression[] | null;
 }
-/**
- * Metadata extracted from an instance of a decorator on another declaration, which was actually
- * present in a file.
- *
- * Concrete decorators always have an `identifier` and a `node`.
- */
-export interface ConcreteDecorator extends BaseDecorator {
-    identifier: DecoratorIdentifier;
-    node: ts.Node;
-}
-/**
- * Synthetic decorators never have an `identifier` or a `node`, but know the node for which they
- * were synthesized.
- */
-export interface SyntheticDecorator extends BaseDecorator {
-    identifier: null;
-    node: null;
-    /**
-     * The `ts.Node` for which this decorator was created.
-     */
-    synthesizedFor: ts.Node;
-}
-export declare const Decorator: {
-    nodeForError: (decorator: Decorator) => ts.Node;
-};
 /**
  * A decorator is identified by either a simple identifier (e.g. `Decorator`) or, in some cases,
  * a namespaced property access (e.g. `core.Decorator`).
@@ -367,7 +342,7 @@ export interface FunctionDefinition {
     /**
      * A reference to the node which declares the function.
      */
-    node: ts.MethodDeclaration | ts.FunctionDeclaration | ts.FunctionExpression | ts.VariableDeclaration;
+    node: ts.MethodDeclaration | ts.FunctionDeclaration | ts.FunctionExpression | ts.VariableDeclaration | ts.ArrowFunction;
     /**
      * Statements of the function body, if a body is present, or null if no body is present or the
      * function is identified to represent a tslib helper function, in which case `helper` will
@@ -381,35 +356,14 @@ export interface FunctionDefinition {
      * Metadata regarding the function's parameters, including possible default value expressions.
      */
     parameters: Parameter[];
-}
-/**
- * Possible declarations of known values, such as built-in objects/functions or TypeScript helpers.
- */
-export declare enum KnownDeclaration {
-    /**
-     * Indicates the JavaScript global `Object` class.
-     */
-    JsGlobalObject = 0,
-    /**
-     * Indicates the `__assign` TypeScript helper function.
-     */
-    TsHelperAssign = 1,
-    /**
-     * Indicates the `__spread` TypeScript helper function.
-     */
-    TsHelperSpread = 2,
-    /**
-     * Indicates the `__spreadArrays` TypeScript helper function.
-     */
-    TsHelperSpreadArrays = 3,
     /**
-     * Indicates the `__spreadArray` TypeScript helper function.
+     * Generic type parameters of the function.
      */
-    TsHelperSpreadArray = 4,
+    typeParameters: ts.TypeParameterDeclaration[] | null;
     /**
-     * Indicates the `__read` TypeScript helper function.
+     * Number of known signatures of the function.
      */
-    TsHelperRead = 5
+    signatureCount: number;
 }
 /**
  * A parameter to a function or method.
@@ -427,6 +381,10 @@ export interface Parameter {
      * Expression which represents the default value of the parameter, if any.
      */
     initializer: ts.Expression | null;
+    /**
+     * Type of the parameter.
+     */
+    type: ts.TypeNode | null;
 }
 /**
  * The source of an imported symbol, including the original symbol name and the module from which it
@@ -443,50 +401,20 @@ export interface Import {
      * This could either be an absolute module name (@angular/core for example) or a relative path.
      */
     from: string;
-}
-/**
- * A single enum member extracted from JavaScript when no `ts.EnumDeclaration` is available.
- */
-export interface EnumMember {
-    /**
-     * The name of the enum member.
-     */
-    name: ts.PropertyName;
     /**
-     * The initializer expression of the enum member. Unlike in TypeScript, this is always available
-     * in emitted JavaScript.
+     * TypeScript node that represents this import.
      */
-    initializer: ts.Expression;
+    node: ts.ImportDeclaration;
 }
 /**
  * A type that is used to identify a declaration.
- *
- * Declarations are normally `ts.Declaration` types such as variable declarations, class
- * declarations, function declarations etc.
- * But in some cases there is no `ts.Declaration` that can be used for a declaration, such
- * as when they are declared inline as part of an exported expression. Then we must use a
- * `ts.Expression` as the declaration.
- * An example of this is `exports.someVar = 42` where the declaration expression would be
- * `exports.someVar`.
  */
-export type DeclarationNode = ts.Declaration | ts.Expression;
+export type DeclarationNode = ts.Declaration;
 /**
- * The type of a Declaration - whether its node is concrete (ts.Declaration) or inline
- * (ts.Expression). See `ConcreteDeclaration`, `InlineDeclaration` and `DeclarationNode` for more
- * information about this.
- */
-export declare const enum DeclarationKind {
-    Concrete = 0,
-    Inline = 1
-}
-/**
- * Base type for all `Declaration`s.
+ * The declaration of a symbol, along with information about how it was imported into the
+ * application.
  */
-export interface BaseDeclaration<T extends DeclarationNode> {
-    /**
-     * The type of the underlying `node`.
-     */
-    kind: DeclarationKind;
+export interface Declaration<T extends ts.Declaration = ts.Declaration> {
     /**
      * The absolute module path from which the symbol was imported into the application, if the symbol
      * was imported via an absolute module (even through a chain of re-exports). If the symbol is part
@@ -497,53 +425,7 @@ export interface BaseDeclaration<T extends DeclarationNode> {
      * TypeScript reference to the declaration itself, if one exists.
      */
     node: T;
-    /**
-     * If set, describes the type of the known declaration this declaration resolves to.
-     */
-    known: KnownDeclaration | null;
-}
-/**
- * Returns true if the `decl` is a `ConcreteDeclaration` (ie. that its `node` property is a
- * `ts.Declaration`).
- */
-export declare function isConcreteDeclaration(decl: Declaration): decl is ConcreteDeclaration;
-export interface ConcreteDeclaration<T extends ts.Declaration = ts.Declaration> extends BaseDeclaration<T> {
-    kind: DeclarationKind.Concrete;
-    /**
-     * Optionally represents a special identity of the declaration, or `null` if the declaration
-     * does not have a special identity.
-     */
-    identity: SpecialDeclarationIdentity | null;
-}
-export type SpecialDeclarationIdentity = DownleveledEnum;
-export declare const enum SpecialDeclarationKind {
-    DownleveledEnum = 0
-}
-/**
- * A special declaration identity that represents an enum. This is used in downleveled forms where
- * a `ts.EnumDeclaration` is emitted in an alternative form, e.g. an IIFE call that declares all
- * members.
- */
-export interface DownleveledEnum {
-    kind: SpecialDeclarationKind.DownleveledEnum;
-    enumMembers: EnumMember[];
 }
-/**
- * A declaration that does not have an associated TypeScript `ts.Declaration`.
- *
- * This can occur in some downlevelings when an `export const VAR = ...;` (a `ts.Declaration`) is
- * transpiled to an assignment statement (e.g. `exports.VAR = ...;`). There is no `ts.Declaration`
- * associated with `VAR` in that case, only an expression.
- */
-export interface InlineDeclaration extends BaseDeclaration<Exclude<DeclarationNode, ts.Declaration>> {
-    kind: DeclarationKind.Inline;
-    implementation?: DeclarationNode;
-}
-/**
- * The declaration of a symbol, along with information about how it was imported into the
- * application.
- */
-export type Declaration<T extends ts.Declaration = ts.Declaration> = ConcreteDeclaration<T> | InlineDeclaration;
 /**
  * Abstracts reflection operations on a TypeScript AST.
  *
@@ -632,35 +514,4 @@ export interface ReflectionHost {
      * is not a class or has an unknown number of type parameters.
      */
     getGenericArityOfClass(clazz: ClassDeclaration): number | null;
-    /**
-     * Take an exported declaration (maybe a class down-leveled to a variable) and look up the
-     * declaration of its type in a separate .d.ts tree.
-     *
-     * This function is allowed to return `null` if the current compilation unit does not have a
-     * separate .d.ts tree. When compiling TypeScript code this is always the case, since .d.ts files
-     * are produced only during the emit of such a compilation. When compiling .js code, however,
-     * there is frequently a parallel .d.ts tree which this method exposes.
-     *
-     * Note that the `ts.Declaration` returned from this function may not be from the same
-     * `ts.Program` as the input declaration.
-     */
-    getDtsDeclaration(declaration: DeclarationNode): ts.Declaration | null;
-    /**
-     * Get a `ts.Identifier` for a given `ClassDeclaration` which can be used to refer to the class
-     * within its definition (such as in static fields).
-     *
-     * This can differ from `clazz.name` when ngcc runs over ES5 code, since the class may have a
-     * different name within its IIFE wrapper than it does externally.
-     */
-    getInternalNameOfClass(clazz: ClassDeclaration): ts.Identifier;
-    /**
-     * Get a `ts.Identifier` for a given `ClassDeclaration` which can be used to refer to the class
-     * from statements that are "adjacent", and conceptually tightly bound, to the class but not
-     * actually inside it.
-     *
-     * Similar to `getInternalNameOfClass()`, this name can differ from `clazz.name` when ngcc runs
-     * over ES5 code, since these "adjacent" statements need to exist in the IIFE where the class may
-     * have a different name than it does externally.
-     */
-    getAdjacentNameOfClass(clazz: ClassDeclaration): ts.Identifier;
 }