static-injector 1.0.8

package/transform/compiler-cli/src/ngtsc/reflection/src/host.js

@@ -0,0 +1,98 @@
+"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.isConcreteDeclaration = exports.KnownDeclaration = exports.ClassMemberKind = exports.isDecoratorIdentifier = exports.Decorator = void 0;
+const ts = __importStar(require("typescript"));
+exports.Decorator = {
+    nodeForError: (decorator) => {
+        if (decorator.node !== null) {
+            return decorator.node;
+        }
+        else {
+            // TODO(alxhub): we can't rely on narrowing until TS 3.6 is in g3.
+            return decorator.synthesizedFor;
+        }
+    },
+};
+/** 装饰器可能是 Injectable或者xx.Injectable */
+function isDecoratorIdentifier(exp) {
+    return (ts.isIdentifier(exp) ||
+        (ts.isPropertyAccessExpression(exp) &&
+            ts.isIdentifier(exp.expression) &&
+            ts.isIdentifier(exp.name)));
+}
+exports.isDecoratorIdentifier = isDecoratorIdentifier;
+/**
+ * An enumeration of possible kinds of class members.
+ */
+var ClassMemberKind;
+(function (ClassMemberKind) {
+    ClassMemberKind[ClassMemberKind["Constructor"] = 0] = "Constructor";
+    ClassMemberKind[ClassMemberKind["Getter"] = 1] = "Getter";
+    ClassMemberKind[ClassMemberKind["Setter"] = 2] = "Setter";
+    ClassMemberKind[ClassMemberKind["Property"] = 3] = "Property";
+    ClassMemberKind[ClassMemberKind["Method"] = 4] = "Method";
+})(ClassMemberKind = exports.ClassMemberKind || (exports.ClassMemberKind = {}));
+/**
+ * Possible declarations of known values, such as built-in objects/functions or TypeScript helpers.
+ */
+var KnownDeclaration;
+(function (KnownDeclaration) {
+    /**
+     * Indicates the JavaScript global `Object` class.
+     */
+    KnownDeclaration[KnownDeclaration["JsGlobalObject"] = 0] = "JsGlobalObject";
+    /**
+     * Indicates the `__assign` TypeScript helper function.
+     */
+    KnownDeclaration[KnownDeclaration["TsHelperAssign"] = 1] = "TsHelperAssign";
+    /**
+     * Indicates the `__spread` TypeScript helper function.
+     */
+    KnownDeclaration[KnownDeclaration["TsHelperSpread"] = 2] = "TsHelperSpread";
+    /**
+     * Indicates the `__spreadArrays` TypeScript helper function.
+     */
+    KnownDeclaration[KnownDeclaration["TsHelperSpreadArrays"] = 3] = "TsHelperSpreadArrays";
+    /**
+     * Indicates the `__spreadArray` TypeScript helper function.
+     */
+    KnownDeclaration[KnownDeclaration["TsHelperSpreadArray"] = 4] = "TsHelperSpreadArray";
+    /**
+     * Indicates the `__read` TypeScript helper function.
+     */
+    KnownDeclaration[KnownDeclaration["TsHelperRead"] = 5] = "TsHelperRead";
+})(KnownDeclaration = exports.KnownDeclaration || (exports.KnownDeclaration = {}));
+/**
+ * Returns true if the `decl` is a `ConcreteDeclaration` (ie. that its `node` property is a
+ * `ts.Declaration`).
+ */
+function isConcreteDeclaration(decl) {
+    return decl.kind === 0 /* Concrete */;
+}
+exports.isConcreteDeclaration = isConcreteDeclaration;

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

@@ -0,0 +1,24 @@
+/**
+ * @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 ts from "typescript";
+import { TypeValueReference } from "./host";
+/**
+ * Potentially convert a `ts.TypeNode` to a `TypeValueReference`, which indicates how to use the
+ * type given in the `ts.TypeNode` in a value position.
+ *
+ * This can return `null` if the `typeNode` is `null`, if it does not refer to a symbol with a value
+ * declaration, or if it is not possible to statically understand.
+ */
+export declare function typeToValue(typeNode: ts.TypeNode | null, checker: ts.TypeChecker): TypeValueReference;
+/**
+ * Attempt to extract a `ts.Expression` that's equivalent to a `ts.TypeNode`, as the two have
+ * different AST shapes but can reference the same symbols.
+ *
+ * This will return `null` if an equivalent expression cannot be constructed.
+ */
+export declare function typeNodeToValueExpr(node: ts.TypeNode): ts.Expression | null;

package/transform/compiler-cli/src/ngtsc/reflection/src/type_to_value.js

@@ -0,0 +1,271 @@
+"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.typeNodeToValueExpr = exports.typeToValue = void 0;
+const ts = __importStar(require("typescript"));
+/**
+ * Potentially convert a `ts.TypeNode` to a `TypeValueReference`, which indicates how to use the
+ * type given in the `ts.TypeNode` in a value position.
+ *
+ * This can return `null` if the `typeNode` is `null`, if it does not refer to a symbol with a value
+ * declaration, or if it is not possible to statically understand.
+ */
+function typeToValue(typeNode, checker) {
+    // It's not possible to get a value expression if the parameter doesn't even have a type.
+    if (typeNode === null) {
+        return missingType();
+    }
+    if (!ts.isTypeReferenceNode(typeNode)) {
+        return unsupportedType(typeNode);
+    }
+    const symbols = resolveTypeSymbols(typeNode, checker);
+    if (symbols === null) {
+        return unknownReference(typeNode);
+    }
+    const { local, decl } = symbols;
+    // It's only valid to convert a type reference to a value reference if the type actually
+    // has a value declaration associated with it. Note that const enums are an exception,
+    // because while they do have a value declaration, they don't exist at runtime.
+    if (decl.valueDeclaration === undefined ||
+        decl.flags & ts.SymbolFlags.ConstEnum) {
+        let typeOnlyDecl = null;
+        if (decl.declarations !== undefined && decl.declarations.length > 0) {
+            typeOnlyDecl = decl.declarations[0];
+        }
+        return noValueDeclaration(typeNode, typeOnlyDecl);
+    }
+    // The type points to a valid value declaration. Rewrite the TypeReference into an
+    // Expression which references the value pointed to by the TypeReference, if possible.
+    // Look at the local `ts.Symbol`'s declarations and see if it comes from an import
+    // statement. If so, extract the module specifier and the name of the imported type.
+    const firstDecl = local.declarations && local.declarations[0];
+    if (firstDecl !== undefined) {
+        if (ts.isImportClause(firstDecl) && firstDecl.name !== undefined) {
+            // This is a default import.
+            //   import Foo from 'foo';
+            if (firstDecl.isTypeOnly) {
+                // Type-only imports cannot be represented as value.
+                return typeOnlyImport(typeNode, firstDecl);
+            }
+            return {
+                kind: 0 /* LOCAL */,
+                expression: firstDecl.name,
+                defaultImportStatement: firstDecl.parent,
+            };
+        }
+        else if (ts.isImportSpecifier(firstDecl)) {
+            // The symbol was imported by name
+            //   import {Foo} from 'foo';
+            // or
+            //   import {Foo as Bar} from 'foo';
+            if (firstDecl.parent.parent.isTypeOnly) {
+                // Type-only imports cannot be represented as value.
+                return typeOnlyImport(typeNode, firstDecl.parent.parent);
+            }
+            // Determine the name to import (`Foo`) from the import specifier, as the symbol names of
+            // the imported type could refer to a local alias (like `Bar` in the example above).
+            const importedName = (firstDecl.propertyName || firstDecl.name).text;
+            // The first symbol name refers to the local name, which is replaced by `importedName` above.
+            // Any remaining symbol names make up the complete path to the value.
+            const [_localName, ...nestedPath] = symbols.symbolNames;
+            const moduleName = extractModuleName(firstDecl.parent.parent.parent);
+            return {
+                kind: 1 /* IMPORTED */,
+                valueDeclaration: decl.valueDeclaration,
+                moduleName,
+                importedName,
+                nestedPath,
+            };
+        }
+        else if (ts.isNamespaceImport(firstDecl)) {
+            // The import is a namespace import
+            //   import * as Foo from 'foo';
+            if (firstDecl.parent.isTypeOnly) {
+                // Type-only imports cannot be represented as value.
+                return typeOnlyImport(typeNode, firstDecl.parent);
+            }
+            if (symbols.symbolNames.length === 1) {
+                // The type refers to the namespace itself, which cannot be represented as a value.
+                return namespaceImport(typeNode, firstDecl.parent);
+            }
+            // The first symbol name refers to the local name of the namespace, which is is discarded
+            // as a new namespace import will be generated. This is followed by the symbol name that needs
+            // to be imported and any remaining names that constitute the complete path to the value.
+            const [_ns, importedName, ...nestedPath] = symbols.symbolNames;
+            const moduleName = extractModuleName(firstDecl.parent.parent);
+            return {
+                kind: 1 /* IMPORTED */,
+                valueDeclaration: decl.valueDeclaration,
+                moduleName,
+                importedName,
+                nestedPath,
+            };
+        }
+    }
+    // If the type is not imported, the type reference can be converted into an expression as is.
+    const expression = typeNodeToValueExpr(typeNode);
+    if (expression !== null) {
+        return {
+            kind: 0 /* LOCAL */,
+            expression,
+            defaultImportStatement: null,
+        };
+    }
+    else {
+        return unsupportedType(typeNode);
+    }
+}
+exports.typeToValue = typeToValue;
+function unsupportedType(typeNode) {
+    return {
+        kind: 2 /* UNAVAILABLE */,
+        reason: { kind: 5 /* UNSUPPORTED */, typeNode },
+    };
+}
+function noValueDeclaration(typeNode, decl) {
+    return {
+        kind: 2 /* UNAVAILABLE */,
+        reason: { kind: 1 /* NO_VALUE_DECLARATION */, typeNode, decl },
+    };
+}
+function typeOnlyImport(typeNode, importClause) {
+    return {
+        kind: 2 /* UNAVAILABLE */,
+        reason: {
+            kind: 2 /* TYPE_ONLY_IMPORT */,
+            typeNode,
+            importClause,
+        },
+    };
+}
+function unknownReference(typeNode) {
+    return {
+        kind: 2 /* UNAVAILABLE */,
+        reason: { kind: 3 /* UNKNOWN_REFERENCE */, typeNode },
+    };
+}
+function namespaceImport(typeNode, importClause) {
+    return {
+        kind: 2 /* UNAVAILABLE */,
+        reason: { kind: 4 /* NAMESPACE */, typeNode, importClause },
+    };
+}
+function missingType() {
+    return {
+        kind: 2 /* UNAVAILABLE */,
+        reason: { kind: 0 /* MISSING_TYPE */ },
+    };
+}
+/**
+ * Attempt to extract a `ts.Expression` that's equivalent to a `ts.TypeNode`, as the two have
+ * different AST shapes but can reference the same symbols.
+ *
+ * This will return `null` if an equivalent expression cannot be constructed.
+ */
+function typeNodeToValueExpr(node) {
+    if (ts.isTypeReferenceNode(node)) {
+        return entityNameToValue(node.typeName);
+    }
+    else {
+        return null;
+    }
+}
+exports.typeNodeToValueExpr = typeNodeToValueExpr;
+/**
+ * Resolve a `TypeReference` node to the `ts.Symbol`s for both its declaration and its local source.
+ *
+ * In the event that the `TypeReference` refers to a locally declared symbol, these will be the
+ * same. If the `TypeReference` refers to an imported symbol, then `decl` will be the fully resolved
+ * `ts.Symbol` of the referenced symbol. `local` will be the `ts.Symbol` of the `ts.Identifier`
+ * which points to the import statement by which the symbol was imported.
+ *
+ * All symbol names that make up the type reference are returned left-to-right into the
+ * `symbolNames` array, which is guaranteed to include at least one entry.
+ */
+function resolveTypeSymbols(typeRef, checker) {
+    const typeName = typeRef.typeName;
+    // typeRefSymbol is the ts.Symbol of the entire type reference.
+    const typeRefSymbol = checker.getSymbolAtLocation(typeName);
+    if (typeRefSymbol === undefined) {
+        return null;
+    }
+    // `local` is the `ts.Symbol` for the local `ts.Identifier` for the type.
+    // If the type is actually locally declared or is imported by name, for example:
+    //   import {Foo} from './foo';
+    // then it'll be the same as `typeRefSymbol`.
+    //
+    // If the type is imported via a namespace import, for example:
+    //   import * as foo from './foo';
+    // and then referenced as:
+    //   constructor(f: foo.Foo)
+    // then `local` will be the `ts.Symbol` of `foo`, whereas `typeRefSymbol` will be the `ts.Symbol`
+    // of `foo.Foo`. This allows tracking of the import behind whatever type reference exists.
+    let local = typeRefSymbol;
+    // Destructure a name like `foo.X.Y.Z` as follows:
+    // - in `leftMost`, the `ts.Identifier` of the left-most name (`foo`) in the qualified name.
+    //   This identifier is used to resolve the `ts.Symbol` for `local`.
+    // - in `symbolNames`, all names involved in the qualified path, or a single symbol name if the
+    //   type is not qualified.
+    let leftMost = typeName;
+    const symbolNames = [];
+    while (ts.isQualifiedName(leftMost)) {
+        symbolNames.unshift(leftMost.right.text);
+        leftMost = leftMost.left;
+    }
+    symbolNames.unshift(leftMost.text);
+    if (leftMost !== typeName) {
+        const localTmp = checker.getSymbolAtLocation(leftMost);
+        if (localTmp !== undefined) {
+            local = localTmp;
+        }
+    }
+    // De-alias the top-level type reference symbol to get the symbol of the actual declaration.
+    let decl = typeRefSymbol;
+    if (typeRefSymbol.flags & ts.SymbolFlags.Alias) {
+        decl = checker.getAliasedSymbol(typeRefSymbol);
+    }
+    return { local, decl, symbolNames };
+}
+function entityNameToValue(node) {
+    if (ts.isQualifiedName(node)) {
+        const left = entityNameToValue(node.left);
+        return left !== null ? ts.createPropertyAccess(left, node.right) : null;
+    }
+    else if (ts.isIdentifier(node)) {
+        return ts.getMutableClone(node);
+    }
+    else {
+        return null;
+    }
+}
+function extractModuleName(node) {
+    if (!ts.isStringLiteral(node.moduleSpecifier)) {
+        throw new Error("not a module specifier");
+    }
+    return node.moduleSpecifier.text;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * @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 ts from 'typescript';
+import { ClassDeclaration, ClassMember, CtorParameter, DeclarationNode, Decorator, Import, ReflectionHost } from './host';
+/**
+ * reflector.ts implements static reflection of declarations using the TypeScript `ts.TypeChecker`.
+ */
+export declare class TypeScriptReflectionHost implements ReflectionHost {
+    protected checker: ts.TypeChecker;
+    constructor(checker: ts.TypeChecker);
+    getDecoratorsOfDeclaration(declaration: DeclarationNode): Decorator[] | null;
+    getMembersOfClass(clazz: ClassDeclaration): ClassMember[];
+    getConstructorParameters(clazz: ClassDeclaration): CtorParameter[] | null;
+    getImportOfIdentifier(id: ts.Identifier): Import | null;
+    isClass(node: ts.Node): node is ClassDeclaration;
+    hasBaseClass(clazz: ClassDeclaration): boolean;
+    getBaseClassExpression(clazz: ClassDeclaration): ts.Expression | null;
+    getGenericArityOfClass(clazz: ClassDeclaration): number | null;
+    getDtsDeclaration(_: ClassDeclaration): ts.Declaration | null;
+    getInternalNameOfClass(clazz: ClassDeclaration): ts.Identifier;
+    getAdjacentNameOfClass(clazz: ClassDeclaration): ts.Identifier;
+    protected getDirectImportOfIdentifier(id: ts.Identifier): Import | null;
+    /**
+     * Try to get the import info for this identifier as though it is a namespaced import.
+     *
+     * For example, if the identifier is the `Directive` part of a qualified type chain like:
+     *
+     * ```
+     * core.Directive
+     * ```
+     *
+     * then it might be that `core` is a namespace import such as:
+     *
+     * ```
+     * import * as core from 'tslib';
+     * ```
+     *
+     * @param id the TypeScript identifier to find the import info for.
+     * @returns The import info if this is a namespaced import or `null`.
+     */
+    protected getImportOfNamespacedIdentifier(id: ts.Identifier, namespaceIdentifier: ts.Identifier | null): Import | null;
+    private _reflectDecorator;
+    private _reflectMember;
+}
+export declare function reflectObjectLiteral(node: ts.ObjectLiteralExpression): Map<string, ts.Expression>;

package/transform/compiler-cli/src/ngtsc/reflection/src/typescript.js

@@ -0,0 +1,396 @@
+"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.reflectObjectLiteral = exports.TypeScriptReflectionHost = void 0;
+const ts = __importStar(require("typescript"));
+const host_1 = require("./host");
+const type_to_value_1 = require("./type_to_value");
+const util_1 = require("./util");
+/**
+ * reflector.ts implements static reflection of declarations using the TypeScript `ts.TypeChecker`.
+ */
+class TypeScriptReflectionHost {
+    constructor(checker) {
+        this.checker = checker;
+    }
+    getDecoratorsOfDeclaration(declaration) {
+        if (declaration.decorators === undefined ||
+            declaration.decorators.length === 0) {
+            return null;
+        }
+        return declaration.decorators
+            .map((decorator) => this._reflectDecorator(decorator))
+            .filter((dec) => dec !== null);
+    }
+    getMembersOfClass(clazz) {
+        const tsClazz = castDeclarationToClassOrDie(clazz);
+        return tsClazz.members
+            .map((member) => this._reflectMember(member))
+            .filter((member) => member !== null);
+    }
+    getConstructorParameters(clazz) {
+        const tsClazz = castDeclarationToClassOrDie(clazz);
+        const isDeclaration = tsClazz.getSourceFile().isDeclarationFile;
+        // For non-declaration files, we want to find the constructor with a `body`. The constructors
+        // without a `body` are overloads whereas we want the implementation since it's the one that'll
+        // be executed and which can have decorators. For declaration files, we take the first one that
+        // we get.
+        const ctor = tsClazz.members.find((member) => ts.isConstructorDeclaration(member) &&
+            (isDeclaration || member.body !== undefined));
+        if (ctor === undefined) {
+            return null;
+        }
+        return ctor.parameters.map((node) => {
+            // The name of the parameter is easy.
+            const name = parameterName(node.name);
+            const decorators = this.getDecoratorsOfDeclaration(node);
+            // It may or may not be possible to write an expression that refers to the value side of the
+            // type named for the parameter.
+            let originalTypeNode = node.type || null;
+            let typeNode = originalTypeNode;
+            // Check if we are dealing with a simple nullable union type e.g. `foo: Foo|null`
+            // and extract the type. More complex union types e.g. `foo: Foo|Bar` are not supported.
+            // We also don't need to support `foo: Foo|undefined` because Angular's DI injects `null` for
+            // optional tokes that don't have providers.
+            if (typeNode && ts.isUnionTypeNode(typeNode)) {
+                let childTypeNodes = typeNode.types.filter((childTypeNode) => !(ts.isLiteralTypeNode(childTypeNode) &&
+                    childTypeNode.literal.kind === ts.SyntaxKind.NullKeyword));
+                if (childTypeNodes.length === 1) {
+                    typeNode = childTypeNodes[0];
+                }
+            }
+            const typeValueReference = type_to_value_1.typeToValue(typeNode, this.checker);
+            return {
+                name,
+                nameNode: node.name,
+                typeValueReference,
+                typeNode: originalTypeNode,
+                decorators,
+            };
+        });
+    }
+    getImportOfIdentifier(id) {
+        const directImport = this.getDirectImportOfIdentifier(id);
+        if (directImport !== null) {
+            return directImport;
+        }
+        else if (ts.isQualifiedName(id.parent) && id.parent.right === id) {
+            return this.getImportOfNamespacedIdentifier(id, getQualifiedNameRoot(id.parent));
+        }
+        else if (ts.isPropertyAccessExpression(id.parent) &&
+            id.parent.name === id) {
+            return this.getImportOfNamespacedIdentifier(id, getFarLeftIdentifier(id.parent));
+        }
+        else {
+            return null;
+        }
+    }
+    isClass(node) {
+        // For our purposes, classes are "named" ts.ClassDeclarations;
+        // (`node.name` can be undefined in unnamed default exports: `default export class { ... }`).
+        return util_1.isNamedClassDeclaration(node);
+    }
+    hasBaseClass(clazz) {
+        return this.getBaseClassExpression(clazz) !== null;
+    }
+    getBaseClassExpression(clazz) {
+        if (!(ts.isClassDeclaration(clazz) || ts.isClassExpression(clazz)) ||
+            clazz.heritageClauses === undefined) {
+            return null;
+        }
+        const extendsClause = clazz.heritageClauses.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword);
+        if (extendsClause === undefined) {
+            return null;
+        }
+        const extendsType = extendsClause.types[0];
+        if (extendsType === undefined) {
+            return null;
+        }
+        return extendsType.expression;
+    }
+    getGenericArityOfClass(clazz) {
+        if (!ts.isClassDeclaration(clazz)) {
+            return null;
+        }
+        return clazz.typeParameters !== undefined ? clazz.typeParameters.length : 0;
+    }
+    getDtsDeclaration(_) {
+        return null;
+    }
+    getInternalNameOfClass(clazz) {
+        return clazz.name;
+    }
+    getAdjacentNameOfClass(clazz) {
+        return clazz.name;
+    }
+    getDirectImportOfIdentifier(id) {
+        const symbol = this.checker.getSymbolAtLocation(id);
+        if (symbol === undefined ||
+            symbol.declarations === undefined ||
+            symbol.declarations.length !== 1) {
+            return null;
+        }
+        const decl = symbol.declarations[0];
+        const importDecl = getContainingImportDeclaration(decl);
+        // Ignore declarations that are defined locally (not imported).
+        if (importDecl === null) {
+            return null;
+        }
+        // The module specifier is guaranteed to be a string literal, so this should always pass.
+        if (!ts.isStringLiteral(importDecl.moduleSpecifier)) {
+            // Not allowed to happen in TypeScript ASTs.
+            return null;
+        }
+        return {
+            from: importDecl.moduleSpecifier.text,
+            name: getExportedName(decl, id),
+        };
+    }
+    /**
+     * Try to get the import info for this identifier as though it is a namespaced import.
+     *
+     * For example, if the identifier is the `Directive` part of a qualified type chain like:
+     *
+     * ```
+     * core.Directive
+     * ```
+     *
+     * then it might be that `core` is a namespace import such as:
+     *
+     * ```
+     * import * as core from 'tslib';
+     * ```
+     *
+     * @param id the TypeScript identifier to find the import info for.
+     * @returns The import info if this is a namespaced import or `null`.
+     */
+    getImportOfNamespacedIdentifier(id, namespaceIdentifier) {
+        if (namespaceIdentifier === null) {
+            return null;
+        }
+        const namespaceSymbol = this.checker.getSymbolAtLocation(namespaceIdentifier);
+        if (!namespaceSymbol || namespaceSymbol.declarations === undefined) {
+            return null;
+        }
+        const declaration = namespaceSymbol.declarations.length === 1
+            ? namespaceSymbol.declarations[0]
+            : null;
+        if (!declaration) {
+            return null;
+        }
+        const namespaceDeclaration = ts.isNamespaceImport(declaration)
+            ? declaration
+            : null;
+        if (!namespaceDeclaration) {
+            return null;
+        }
+        const importDeclaration = namespaceDeclaration.parent.parent;
+        if (!ts.isStringLiteral(importDeclaration.moduleSpecifier)) {
+            // Should not happen as this would be invalid TypesScript
+            return null;
+        }
+        return {
+            from: importDeclaration.moduleSpecifier.text,
+            name: id.text,
+        };
+    }
+    _reflectDecorator(node) {
+        // Attempt to resolve the decorator expression into a reference to a concrete Identifier. The
+        // expression may contain a call to a function which returns the decorator function, in which
+        // case we want to return the arguments.
+        let decoratorExpr = node.expression;
+        let args = null;
+        // Check for call expressions.
+        if (ts.isCallExpression(decoratorExpr)) {
+            args = Array.from(decoratorExpr.arguments);
+            decoratorExpr = decoratorExpr.expression;
+        }
+        // The final resolved decorator should be a `ts.Identifier` - if it's not, then something is
+        // wrong and the decorator can't be resolved statically.
+        if (!host_1.isDecoratorIdentifier(decoratorExpr)) {
+            return null;
+        }
+        const decoratorIdentifier = ts.isIdentifier(decoratorExpr)
+            ? decoratorExpr
+            : decoratorExpr.name;
+        const importDecl = this.getImportOfIdentifier(decoratorIdentifier);
+        return {
+            name: decoratorIdentifier.text,
+            identifier: decoratorExpr,
+            import: importDecl,
+            node,
+            args,
+        };
+    }
+    _reflectMember(node) {
+        let kind = null;
+        let value = null;
+        let name = null;
+        let nameNode = null;
+        if (ts.isPropertyDeclaration(node)) {
+            kind = host_1.ClassMemberKind.Property;
+            value = node.initializer || null;
+        }
+        else if (ts.isGetAccessorDeclaration(node)) {
+            kind = host_1.ClassMemberKind.Getter;
+        }
+        else if (ts.isSetAccessorDeclaration(node)) {
+            kind = host_1.ClassMemberKind.Setter;
+        }
+        else if (ts.isMethodDeclaration(node)) {
+            kind = host_1.ClassMemberKind.Method;
+        }
+        else if (ts.isConstructorDeclaration(node)) {
+            kind = host_1.ClassMemberKind.Constructor;
+        }
+        else {
+            return null;
+        }
+        if (ts.isConstructorDeclaration(node)) {
+            name = 'constructor';
+        }
+        else if (ts.isIdentifier(node.name)) {
+            name = node.name.text;
+            nameNode = node.name;
+        }
+        else if (ts.isStringLiteral(node.name)) {
+            name = node.name.text;
+            nameNode = node.name;
+        }
+        else {
+            return null;
+        }
+        const decorators = this.getDecoratorsOfDeclaration(node);
+        const isStatic = node.modifiers !== undefined &&
+            node.modifiers.some((mod) => mod.kind === ts.SyntaxKind.StaticKeyword);
+        return {
+            node,
+            implementation: node,
+            kind,
+            type: node.type || null,
+            name,
+            nameNode,
+            decorators,
+            value,
+            isStatic,
+        };
+    }
+}
+exports.TypeScriptReflectionHost = TypeScriptReflectionHost;
+function reflectObjectLiteral(node) {
+    const map = new Map();
+    node.properties.forEach((prop) => {
+        if (ts.isPropertyAssignment(prop)) {
+            const name = propertyNameToString(prop.name);
+            if (name === null) {
+                return;
+            }
+            map.set(name, prop.initializer);
+        }
+        else if (ts.isShorthandPropertyAssignment(prop)) {
+            map.set(prop.name.text, prop.name);
+        }
+        else {
+            return;
+        }
+    });
+    return map;
+}
+exports.reflectObjectLiteral = reflectObjectLiteral;
+function castDeclarationToClassOrDie(declaration) {
+    if (!ts.isClassDeclaration(declaration)) {
+        throw new Error(`Reflecting on a ${ts.SyntaxKind[declaration.kind]} instead of a ClassDeclaration.`);
+    }
+    return declaration;
+}
+function parameterName(name) {
+    if (ts.isIdentifier(name)) {
+        return name.text;
+    }
+    else {
+        return null;
+    }
+}
+function propertyNameToString(node) {
+    if (ts.isIdentifier(node) ||
+        ts.isStringLiteral(node) ||
+        ts.isNumericLiteral(node)) {
+        return node.text;
+    }
+    else {
+        return null;
+    }
+}
+/**
+ * Compute the left most identifier in a qualified type chain. E.g. the `a` of `a.b.c.SomeType`.
+ * @param qualifiedName The starting property access expression from which we want to compute
+ * the left most identifier.
+ * @returns the left most identifier in the chain or `null` if it is not an identifier.
+ */
+function getQualifiedNameRoot(qualifiedName) {
+    while (ts.isQualifiedName(qualifiedName.left)) {
+        qualifiedName = qualifiedName.left;
+    }
+    return ts.isIdentifier(qualifiedName.left) ? qualifiedName.left : null;
+}
+/**
+ * Compute the left most identifier in a property access chain. E.g. the `a` of `a.b.c.d`.
+ * @param propertyAccess The starting property access expression from which we want to compute
+ * the left most identifier.
+ * @returns the left most identifier in the chain or `null` if it is not an identifier.
+ */
+function getFarLeftIdentifier(propertyAccess) {
+    while (ts.isPropertyAccessExpression(propertyAccess.expression)) {
+        propertyAccess = propertyAccess.expression;
+    }
+    return ts.isIdentifier(propertyAccess.expression)
+        ? propertyAccess.expression
+        : null;
+}
+/**
+ * Return the ImportDeclaration for the given `node` if it is either an `ImportSpecifier` or a
+ * `NamespaceImport`. If not return `null`.
+ */
+function getContainingImportDeclaration(node) {
+    return ts.isImportSpecifier(node)
+        ? node.parent.parent.parent
+        : ts.isNamespaceImport(node)
+            ? node.parent.parent
+            : null;
+}
+/**
+ * Compute the name by which the `decl` was exported, not imported.
+ * If no such declaration can be found (e.g. it is a namespace import)
+ * then fallback to the `originalId`.
+ */
+function getExportedName(decl, originalId) {
+    return ts.isImportSpecifier(decl)
+        ? (decl.propertyName !== undefined ? decl.propertyName : decl.name).text
+        : originalId.text;
+}
+const LocalExportedClasses = Symbol('LocalExportedClasses');