@angular/compiler-cli 12.1.1 → 12.1.5

package/src/ngtsc/typecheck/src/type_check_file.mjs

@@ -1,65 +0,0 @@
-/**
- * @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 { join } from '../../file_system';
-import { NoopImportRewriter } from '../../imports';
-import { ImportManager } from '../../translator';
-import { Environment } from './environment';
-import { generateTypeCheckBlock } from './type_check_block';
-/**
- * An `Environment` representing the single type-checking file into which most (if not all) Type
- * Check Blocks (TCBs) will be generated.
- *
- * The `TypeCheckFile` hosts multiple TCBs and allows the sharing of declarations (e.g. type
- * constructors) between them. Rather than return such declarations via `getPreludeStatements()`, it
- * hoists them to the top of the generated `ts.SourceFile`.
- */
-export class TypeCheckFile extends Environment {
-    constructor(fileName, config, refEmitter, reflector, compilerHost) {
-        super(config, new ImportManager(new NoopImportRewriter(), 'i'), refEmitter, reflector, ts.createSourceFile(compilerHost.getCanonicalFileName(fileName), '', ts.ScriptTarget.Latest, true));
-        this.fileName = fileName;
-        this.nextTcbId = 1;
-        this.tcbStatements = [];
-    }
-    addTypeCheckBlock(ref, meta, domSchemaChecker, oobRecorder, genericContextBehavior) {
-        const fnId = ts.createIdentifier(`_tcb${this.nextTcbId++}`);
-        const fn = generateTypeCheckBlock(this, ref, fnId, meta, domSchemaChecker, oobRecorder, genericContextBehavior);
-        this.tcbStatements.push(fn);
-    }
-    render(removeComments) {
-        let source = this.importManager.getAllImports(this.contextFile.fileName)
-            .map(i => `import * as ${i.qualifier.text} from '${i.specifier}';`)
-            .join('\n') +
-            '\n\n';
-        const printer = ts.createPrinter({ removeComments });
-        source += '\n';
-        for (const stmt of this.pipeInstStatements) {
-            source += printer.printNode(ts.EmitHint.Unspecified, stmt, this.contextFile) + '\n';
-        }
-        for (const stmt of this.typeCtorStatements) {
-            source += printer.printNode(ts.EmitHint.Unspecified, stmt, this.contextFile) + '\n';
-        }
-        source += '\n';
-        for (const stmt of this.tcbStatements) {
-            source += printer.printNode(ts.EmitHint.Unspecified, stmt, this.contextFile) + '\n';
-        }
-        // Ensure the template type-checking file is an ES module. Otherwise, it's interpreted as some
-        // kind of global namespace in TS, which forces a full re-typecheck of the user's program that
-        // is somehow more expensive than the initial parse.
-        source += '\nexport const IS_A_MODULE = true;\n';
-        return source;
-    }
-    getPreludeStatements() {
-        return [];
-    }
-}
-export function typeCheckFilePath(rootDirs) {
-    const shortest = rootDirs.concat([]).sort((a, b) => a.length - b.length)[0];
-    return join(shortest, '__ng_typecheck__.ts');
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type_check_file.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/type_check_file.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as ts from 'typescript';\n\nimport {AbsoluteFsPath, join} from '../../file_system';\nimport {NoopImportRewriter, Reference, ReferenceEmitter} from '../../imports';\nimport {ClassDeclaration, ReflectionHost} from '../../reflection';\nimport {ImportManager} from '../../translator';\nimport {TypeCheckBlockMetadata, TypeCheckingConfig} from '../api';\n\nimport {DomSchemaChecker} from './dom';\nimport {Environment} from './environment';\nimport {OutOfBandDiagnosticRecorder} from './oob';\nimport {generateTypeCheckBlock, TcbGenericContextBehavior} from './type_check_block';\n\n\n\n/**\n * An `Environment` representing the single type-checking file into which most (if not all) Type\n * Check Blocks (TCBs) will be generated.\n *\n * The `TypeCheckFile` hosts multiple TCBs and allows the sharing of declarations (e.g. type\n * constructors) between them. Rather than return such declarations via `getPreludeStatements()`, it\n * hoists them to the top of the generated `ts.SourceFile`.\n */\nexport class TypeCheckFile extends Environment {\n  private nextTcbId = 1;\n  private tcbStatements: ts.Statement[] = [];\n\n  constructor(\n      readonly fileName: AbsoluteFsPath, config: TypeCheckingConfig, refEmitter: ReferenceEmitter,\n      reflector: ReflectionHost, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>) {\n    super(\n        config, new ImportManager(new NoopImportRewriter(), 'i'), refEmitter, reflector,\n        ts.createSourceFile(\n            compilerHost.getCanonicalFileName(fileName), '', ts.ScriptTarget.Latest, true));\n  }\n\n  addTypeCheckBlock(\n      ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, meta: TypeCheckBlockMetadata,\n      domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder,\n      genericContextBehavior: TcbGenericContextBehavior): void {\n    const fnId = ts.createIdentifier(`_tcb${this.nextTcbId++}`);\n    const fn = generateTypeCheckBlock(\n        this, ref, fnId, meta, domSchemaChecker, oobRecorder, genericContextBehavior);\n    this.tcbStatements.push(fn);\n  }\n\n  render(removeComments: boolean): string {\n    let source: string = this.importManager.getAllImports(this.contextFile.fileName)\n                             .map(i => `import * as ${i.qualifier.text} from '${i.specifier}';`)\n                             .join('\\n') +\n        '\\n\\n';\n    const printer = ts.createPrinter({removeComments});\n    source += '\\n';\n    for (const stmt of this.pipeInstStatements) {\n      source += printer.printNode(ts.EmitHint.Unspecified, stmt, this.contextFile) + '\\n';\n    }\n    for (const stmt of this.typeCtorStatements) {\n      source += printer.printNode(ts.EmitHint.Unspecified, stmt, this.contextFile) + '\\n';\n    }\n    source += '\\n';\n    for (const stmt of this.tcbStatements) {\n      source += printer.printNode(ts.EmitHint.Unspecified, stmt, this.contextFile) + '\\n';\n    }\n\n    // Ensure the template type-checking file is an ES module. Otherwise, it's interpreted as some\n    // kind of global namespace in TS, which forces a full re-typecheck of the user's program that\n    // is somehow more expensive than the initial parse.\n    source += '\\nexport const IS_A_MODULE = true;\\n';\n\n    return source;\n  }\n\n  getPreludeStatements(): ts.Statement[] {\n    return [];\n  }\n}\n\nexport function typeCheckFilePath(rootDirs: AbsoluteFsPath[]): AbsoluteFsPath {\n  const shortest = rootDirs.concat([]).sort((a, b) => a.length - b.length)[0];\n  return join(shortest, '__ng_typecheck__.ts');\n}\n"]}

package/src/ngtsc/typecheck/src/type_constructor.mjs

@@ -1,227 +0,0 @@
-/**
- * @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 { checkIfGenericTypeBoundsAreContextFree } from './tcb_util';
-import { tsCreateTypeQueryForCoercedInput } from './ts_util';
-export function generateTypeCtorDeclarationFn(node, meta, nodeTypeRef, typeParams, reflector) {
-    if (requiresInlineTypeCtor(node, reflector)) {
-        throw new Error(`${node.name.text} requires an inline type constructor`);
-    }
-    const rawTypeArgs = typeParams !== undefined ? generateGenericArgs(typeParams) : undefined;
-    const rawType = ts.createTypeReferenceNode(nodeTypeRef, rawTypeArgs);
-    const initParam = constructTypeCtorParameter(node, meta, rawType);
-    const typeParameters = typeParametersWithDefaultTypes(typeParams);
-    if (meta.body) {
-        const fnType = ts.createFunctionTypeNode(
-        /* typeParameters */ typeParameters, 
-        /* parameters */ [initParam], 
-        /* type */ rawType);
-        const decl = ts.createVariableDeclaration(
-        /* name */ meta.fnName, 
-        /* type */ fnType, 
-        /* body */ ts.createNonNullExpression(ts.createNull()));
-        const declList = ts.createVariableDeclarationList([decl], ts.NodeFlags.Const);
-        return ts.createVariableStatement(
-        /* modifiers */ undefined, 
-        /* declarationList */ declList);
-    }
-    else {
-        return ts.createFunctionDeclaration(
-        /* decorators */ undefined, 
-        /* modifiers */ [ts.createModifier(ts.SyntaxKind.DeclareKeyword)], 
-        /* asteriskToken */ undefined, 
-        /* name */ meta.fnName, 
-        /* typeParameters */ typeParameters, 
-        /* parameters */ [initParam], 
-        /* type */ rawType, 
-        /* body */ undefined);
-    }
-}
-/**
- * Generate an inline type constructor for the given class and metadata.
- *
- * An inline type constructor is a specially shaped TypeScript static method, intended to be placed
- * within a directive class itself, that permits type inference of any generic type parameters of
- * the class from the types of expressions bound to inputs or outputs, and the types of elements
- * that match queries performed by the directive. It also catches any errors in the types of these
- * expressions. This method is never called at runtime, but is used in type-check blocks to
- * construct directive types.
- *
- * An inline type constructor for NgFor looks like:
- *
- * static ngTypeCtor<T>(init: Pick<NgForOf<T>, 'ngForOf'|'ngForTrackBy'|'ngForTemplate'>):
- *   NgForOf<T>;
- *
- * A typical constructor would be:
- *
- * NgForOf.ngTypeCtor(init: {
- *   ngForOf: ['foo', 'bar'],
- *   ngForTrackBy: null as any,
- *   ngForTemplate: null as any,
- * }); // Infers a type of NgForOf<string>.
- *
- * Any inputs declared on the type for which no property binding is present are assigned a value of
- * type `any`, to avoid producing any type errors for unset inputs.
- *
- * Inline type constructors are used when the type being created has bounded generic types which
- * make writing a declared type constructor (via `generateTypeCtorDeclarationFn`) difficult or
- * impossible.
- *
- * @param node the `ClassDeclaration<ts.ClassDeclaration>` for which a type constructor will be
- * generated.
- * @param meta additional metadata required to generate the type constructor.
- * @returns a `ts.MethodDeclaration` for the type constructor.
- */
-export function generateInlineTypeCtor(node, meta) {
-    // Build rawType, a `ts.TypeNode` of the class with its generic parameters passed through from
-    // the definition without any type bounds. For example, if the class is
-    // `FooDirective<T extends Bar>`, its rawType would be `FooDirective<T>`.
-    const rawTypeArgs = node.typeParameters !== undefined ? generateGenericArgs(node.typeParameters) : undefined;
-    const rawType = ts.createTypeReferenceNode(node.name, rawTypeArgs);
-    const initParam = constructTypeCtorParameter(node, meta, rawType);
-    // If this constructor is being generated into a .ts file, then it needs a fake body. The body
-    // is set to a return of `null!`. If the type constructor is being generated into a .d.ts file,
-    // it needs no body.
-    let body = undefined;
-    if (meta.body) {
-        body = ts.createBlock([
-            ts.createReturn(ts.createNonNullExpression(ts.createNull())),
-        ]);
-    }
-    // Create the type constructor method declaration.
-    return ts.createMethod(
-    /* decorators */ undefined, 
-    /* modifiers */ [ts.createModifier(ts.SyntaxKind.StaticKeyword)], 
-    /* asteriskToken */ undefined, 
-    /* name */ meta.fnName, 
-    /* questionToken */ undefined, 
-    /* typeParameters */ typeParametersWithDefaultTypes(node.typeParameters), 
-    /* parameters */ [initParam], 
-    /* type */ rawType, 
-    /* body */ body);
-}
-function constructTypeCtorParameter(node, meta, rawType) {
-    // initType is the type of 'init', the single argument to the type constructor method.
-    // If the Directive has any inputs, its initType will be:
-    //
-    // Pick<rawType, 'inputA'|'inputB'>
-    //
-    // Pick here is used to select only those fields from which the generic type parameters of the
-    // directive will be inferred.
-    //
-    // In the special case there are no inputs, initType is set to {}.
-    let initType = null;
-    const keys = meta.fields.inputs;
-    const plainKeys = [];
-    const coercedKeys = [];
-    for (const key of keys) {
-        if (!meta.coercedInputFields.has(key)) {
-            plainKeys.push(ts.createLiteralTypeNode(ts.createStringLiteral(key)));
-        }
-        else {
-            coercedKeys.push(ts.createPropertySignature(
-            /* modifiers */ undefined, 
-            /* name */ key, 
-            /* questionToken */ undefined, 
-            /* type */ tsCreateTypeQueryForCoercedInput(rawType.typeName, key), 
-            /* initializer */ undefined));
-        }
-    }
-    if (plainKeys.length > 0) {
-        // Construct a union of all the field names.
-        const keyTypeUnion = ts.createUnionTypeNode(plainKeys);
-        // Construct the Pick<rawType, keyTypeUnion>.
-        initType = ts.createTypeReferenceNode('Pick', [rawType, keyTypeUnion]);
-    }
-    if (coercedKeys.length > 0) {
-        const coercedLiteral = ts.createTypeLiteralNode(coercedKeys);
-        initType = initType !== null ? ts.createIntersectionTypeNode([initType, coercedLiteral]) :
-            coercedLiteral;
-    }
-    if (initType === null) {
-        // Special case - no inputs, outputs, or other fields which could influence the result type.
-        initType = ts.createTypeLiteralNode([]);
-    }
-    // Create the 'init' parameter itself.
-    return ts.createParameter(
-    /* decorators */ undefined, 
-    /* modifiers */ undefined, 
-    /* dotDotDotToken */ undefined, 
-    /* name */ 'init', 
-    /* questionToken */ undefined, 
-    /* type */ initType, 
-    /* initializer */ undefined);
-}
-function generateGenericArgs(params) {
-    return params.map(param => ts.createTypeReferenceNode(param.name, undefined));
-}
-export function requiresInlineTypeCtor(node, host) {
-    // The class requires an inline type constructor if it has generic type bounds that can not be
-    // emitted into a different context.
-    return !checkIfGenericTypeBoundsAreContextFree(node, host);
-}
-/**
- * Add a default `= any` to type parameters that don't have a default value already.
- *
- * TypeScript uses the default type of a type parameter whenever inference of that parameter fails.
- * This can happen when inferring a complex type from 'any'. For example, if `NgFor`'s inference is
- * done with the TCB code:
- *
- * ```
- * class NgFor<T> {
- *   ngForOf: T[];
- * }
- *
- * declare function ctor<T>(o: Pick<NgFor<T>, 'ngForOf'|'ngForTrackBy'|'ngForTemplate'>): NgFor<T>;
- * ```
- *
- * An invocation looks like:
- *
- * ```
- * var _t1 = ctor({ngForOf: [1, 2], ngForTrackBy: null as any, ngForTemplate: null as any});
- * ```
- *
- * This correctly infers the type `NgFor<number>` for `_t1`, since `T` is inferred from the
- * assignment of type `number[]` to `ngForOf`'s type `T[]`. However, if `any` is passed instead:
- *
- * ```
- * var _t2 = ctor({ngForOf: [1, 2] as any, ngForTrackBy: null as any, ngForTemplate: null as any});
- * ```
- *
- * then inference for `T` fails (it cannot be inferred from `T[] = any`). In this case, `T` takes
- * the type `{}`, and so `_t2` is inferred as `NgFor<{}>`. This is obviously wrong.
- *
- * Adding a default type to the generic declaration in the constructor solves this problem, as the
- * default type will be used in the event that inference fails.
- *
- * ```
- * declare function ctor<T = any>(o: Pick<NgFor<T>, 'ngForOf'>): NgFor<T>;
- *
- * var _t3 = ctor({ngForOf: [1, 2] as any});
- * ```
- *
- * This correctly infers `T` as `any`, and therefore `_t3` as `NgFor<any>`.
- */
-function typeParametersWithDefaultTypes(params) {
-    if (params === undefined) {
-        return undefined;
-    }
-    return params.map(param => {
-        if (param.default === undefined) {
-            return ts.updateTypeParameterDeclaration(
-            /* node */ param, 
-            /* name */ param.name, 
-            /* constraint */ param.constraint, 
-            /* defaultType */ ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword));
-        }
-        else {
-            return param;
-        }
-    });
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type_constructor.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/type_constructor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAIjC,OAAO,EAAC,sCAAsC,EAAC,MAAM,YAAY,CAAC;AAElE,OAAO,EAAC,gCAAgC,EAAC,MAAM,WAAW,CAAC;AAE3D,MAAM,UAAU,6BAA6B,CACzC,IAA2C,EAAE,IAAsB,EAAE,WAA0B,EAC/F,UAAmD,EAAE,SAAyB;IAChF,IAAI,sBAAsB,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE;QAC3C,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,sCAAsC,CAAC,CAAC;KAC1E;IAED,MAAM,WAAW,GAAG,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3F,MAAM,OAAO,GAAG,EAAE,CAAC,uBAAuB,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IAErE,MAAM,SAAS,GAAG,0BAA0B,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAElE,MAAM,cAAc,GAAG,8BAA8B,CAAC,UAAU,CAAC,CAAC;IAElE,IAAI,IAAI,CAAC,IAAI,EAAE;QACb,MAAM,MAAM,GAAG,EAAE,CAAC,sBAAsB;QACpC,oBAAoB,CAAC,cAAc;QACnC,gBAAgB,CAAA,CAAC,SAAS,CAAC;QAC3B,UAAU,CAAC,OAAO,CACrB,CAAC;QAEF,MAAM,IAAI,GAAG,EAAE,CAAC,yBAAyB;QACrC,UAAU,CAAC,IAAI,CAAC,MAAM;QACtB,UAAU,CAAC,MAAM;QACjB,UAAU,CAAC,EAAE,CAAC,uBAAuB,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;QAC5D,MAAM,QAAQ,GAAG,EAAE,CAAC,6BAA6B,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC9E,OAAO,EAAE,CAAC,uBAAuB;QAC7B,eAAe,CAAC,SAAS;QACzB,qBAAqB,CAAC,QAAQ,CAAC,CAAC;KACrC;SAAM;QACL,OAAO,EAAE,CAAC,yBAAyB;QAC/B,gBAAgB,CAAC,SAAS;QAC1B,eAAe,CAAA,CAAC,EAAE,CAAC,cAAc,CAAC,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;QAChE,mBAAmB,CAAC,SAAS;QAC7B,UAAU,CAAC,IAAI,CAAC,MAAM;QACtB,oBAAoB,CAAC,cAAc;QACnC,gBAAgB,CAAA,CAAC,SAAS,CAAC;QAC3B,UAAU,CAAC,OAAO;QAClB,UAAU,CAAC,SAAS,CAAC,CAAC;KAC3B;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,sBAAsB,CAClC,IAA2C,EAAE,IAAsB;IACrE,8FAA8F;IAC9F,uEAAuE;IACvE,yEAAyE;IACzE,MAAM,WAAW,GACb,IAAI,CAAC,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,mBAAmB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7F,MAAM,OAAO,GAAG,EAAE,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAEnE,MAAM,SAAS,GAAG,0BAA0B,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAElE,8FAA8F;IAC9F,+FAA+F;IAC/F,oBAAoB;IACpB,IAAI,IAAI,GAAuB,SAAS,CAAC;IACzC,IAAI,IAAI,CAAC,IAAI,EAAE;QACb,IAAI,GAAG,EAAE,CAAC,WAAW,CAAC;YACpB,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,uBAAuB,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,CAAC;SAC7D,CAAC,CAAC;KACJ;IAED,kDAAkD;IAClD,OAAO,EAAE,CAAC,YAAY;IAClB,gBAAgB,CAAC,SAAS;IAC1B,eAAe,CAAA,CAAC,EAAE,CAAC,cAAc,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;IAC/D,mBAAmB,CAAC,SAAS;IAC7B,UAAU,CAAC,IAAI,CAAC,MAAM;IACtB,mBAAmB,CAAC,SAAS;IAC7B,oBAAoB,CAAC,8BAA8B,CAAC,IAAI,CAAC,cAAc,CAAC;IACxE,gBAAgB,CAAA,CAAC,SAAS,CAAC;IAC3B,UAAU,CAAC,OAAO;IAClB,UAAU,CAAC,IAAI,CAClB,CAAC;AACJ,CAAC;AAED,SAAS,0BAA0B,CAC/B,IAA2C,EAAE,IAAsB,EACnE,OAA6B;IAC/B,sFAAsF;IACtF,yDAAyD;IACzD,EAAE;IACF,mCAAmC;IACnC,EAAE;IACF,8FAA8F;IAC9F,8BAA8B;IAC9B,EAAE;IACF,kEAAkE;IAClE,IAAI,QAAQ,GAAqB,IAAI,CAAC;IAEtC,MAAM,IAAI,GAAa,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;IAC1C,MAAM,SAAS,GAAyB,EAAE,CAAC;IAC3C,MAAM,WAAW,GAA2B,EAAE,CAAC;IAC/C,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;QACtB,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACrC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,qBAAqB,CAAC,EAAE,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;SACvE;aAAM;YACL,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,uBAAuB;YACvC,eAAe,CAAC,SAAS;YACzB,UAAU,CAAC,GAAG;YACd,mBAAmB,CAAC,SAAS;YAC7B,UAAU,CAAC,gCAAgC,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC;YAClE,iBAAiB,CAAC,SAAS,CAAC,CAAC,CAAC;SACnC;KACF;IACD,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;QACxB,4CAA4C;QAC5C,MAAM,YAAY,GAAG,EAAE,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC;QAEvD,6CAA6C;QAC7C,QAAQ,GAAG,EAAE,CAAC,uBAAuB,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;KACxE;IACD,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;QAC1B,MAAM,cAAc,GAAG,EAAE,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;QAE7D,QAAQ,GAAG,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,0BAA0B,CAAC,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;YAC3D,cAAc,CAAC;KAC/C;IAED,IAAI,QAAQ,KAAK,IAAI,EAAE;QACrB,4FAA4F;QAC5F,QAAQ,GAAG,EAAE,CAAC,qBAAqB,CAAC,EAAE,CAAC,CAAC;KACzC;IAED,sCAAsC;IACtC,OAAO,EAAE,CAAC,eAAe;IACrB,gBAAgB,CAAC,SAAS;IAC1B,eAAe,CAAC,SAAS;IACzB,oBAAoB,CAAC,SAAS;IAC9B,UAAU,CAAC,MAAM;IACjB,mBAAmB,CAAC,SAAS;IAC7B,UAAU,CAAC,QAAQ;IACnB,iBAAiB,CAAC,SAAS,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,mBAAmB,CAAC,MAAkD;IAC7E,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,uBAAuB,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;AAChF,CAAC;AAED,MAAM,UAAU,sBAAsB,CAClC,IAA2C,EAAE,IAAoB;IACnE,8FAA8F;IAC9F,oCAAoC;IACpC,OAAO,CAAC,sCAAsC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC7D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,SAAS,8BAA8B,CAAC,MACS;IAC/C,IAAI,MAAM,KAAK,SAAS,EAAE;QACxB,OAAO,SAAS,CAAC;KAClB;IAED,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;QACxB,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE;YAC/B,OAAO,EAAE,CAAC,8BAA8B;YACpC,UAAU,CAAC,KAAK;YAChB,UAAU,CAAC,KAAK,CAAC,IAAI;YACrB,gBAAgB,CAAC,KAAK,CAAC,UAAU;YACjC,iBAAiB,CAAC,EAAE,CAAC,qBAAqB,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;SAC3E;aAAM;YACL,OAAO,KAAK,CAAC;SACd;IACH,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as ts from 'typescript';\n\nimport {ClassDeclaration, ReflectionHost} from '../../reflection';\nimport {TypeCtorMetadata} from '../api';\nimport {checkIfGenericTypeBoundsAreContextFree} from './tcb_util';\n\nimport {tsCreateTypeQueryForCoercedInput} from './ts_util';\n\nexport function generateTypeCtorDeclarationFn(\n    node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata, nodeTypeRef: ts.EntityName,\n    typeParams: ts.TypeParameterDeclaration[]|undefined, reflector: ReflectionHost): ts.Statement {\n  if (requiresInlineTypeCtor(node, reflector)) {\n    throw new Error(`${node.name.text} requires an inline type constructor`);\n  }\n\n  const rawTypeArgs = typeParams !== undefined ? generateGenericArgs(typeParams) : undefined;\n  const rawType = ts.createTypeReferenceNode(nodeTypeRef, rawTypeArgs);\n\n  const initParam = constructTypeCtorParameter(node, meta, rawType);\n\n  const typeParameters = typeParametersWithDefaultTypes(typeParams);\n\n  if (meta.body) {\n    const fnType = ts.createFunctionTypeNode(\n        /* typeParameters */ typeParameters,\n        /* parameters */[initParam],\n        /* type */ rawType,\n    );\n\n    const decl = ts.createVariableDeclaration(\n        /* name */ meta.fnName,\n        /* type */ fnType,\n        /* body */ ts.createNonNullExpression(ts.createNull()));\n    const declList = ts.createVariableDeclarationList([decl], ts.NodeFlags.Const);\n    return ts.createVariableStatement(\n        /* modifiers */ undefined,\n        /* declarationList */ declList);\n  } else {\n    return ts.createFunctionDeclaration(\n        /* decorators */ undefined,\n        /* modifiers */[ts.createModifier(ts.SyntaxKind.DeclareKeyword)],\n        /* asteriskToken */ undefined,\n        /* name */ meta.fnName,\n        /* typeParameters */ typeParameters,\n        /* parameters */[initParam],\n        /* type */ rawType,\n        /* body */ undefined);\n  }\n}\n\n/**\n * Generate an inline type constructor for the given class and metadata.\n *\n * An inline type constructor is a specially shaped TypeScript static method, intended to be placed\n * within a directive class itself, that permits type inference of any generic type parameters of\n * the class from the types of expressions bound to inputs or outputs, and the types of elements\n * that match queries performed by the directive. It also catches any errors in the types of these\n * expressions. This method is never called at runtime, but is used in type-check blocks to\n * construct directive types.\n *\n * An inline type constructor for NgFor looks like:\n *\n * static ngTypeCtor<T>(init: Pick<NgForOf<T>, 'ngForOf'|'ngForTrackBy'|'ngForTemplate'>):\n *   NgForOf<T>;\n *\n * A typical constructor would be:\n *\n * NgForOf.ngTypeCtor(init: {\n *   ngForOf: ['foo', 'bar'],\n *   ngForTrackBy: null as any,\n *   ngForTemplate: null as any,\n * }); // Infers a type of NgForOf<string>.\n *\n * Any inputs declared on the type for which no property binding is present are assigned a value of\n * type `any`, to avoid producing any type errors for unset inputs.\n *\n * Inline type constructors are used when the type being created has bounded generic types which\n * make writing a declared type constructor (via `generateTypeCtorDeclarationFn`) difficult or\n * impossible.\n *\n * @param node the `ClassDeclaration<ts.ClassDeclaration>` for which a type constructor will be\n * generated.\n * @param meta additional metadata required to generate the type constructor.\n * @returns a `ts.MethodDeclaration` for the type constructor.\n */\nexport function generateInlineTypeCtor(\n    node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata): ts.MethodDeclaration {\n  // Build rawType, a `ts.TypeNode` of the class with its generic parameters passed through from\n  // the definition without any type bounds. For example, if the class is\n  // `FooDirective<T extends Bar>`, its rawType would be `FooDirective<T>`.\n  const rawTypeArgs =\n      node.typeParameters !== undefined ? generateGenericArgs(node.typeParameters) : undefined;\n  const rawType = ts.createTypeReferenceNode(node.name, rawTypeArgs);\n\n  const initParam = constructTypeCtorParameter(node, meta, rawType);\n\n  // If this constructor is being generated into a .ts file, then it needs a fake body. The body\n  // is set to a return of `null!`. If the type constructor is being generated into a .d.ts file,\n  // it needs no body.\n  let body: ts.Block|undefined = undefined;\n  if (meta.body) {\n    body = ts.createBlock([\n      ts.createReturn(ts.createNonNullExpression(ts.createNull())),\n    ]);\n  }\n\n  // Create the type constructor method declaration.\n  return ts.createMethod(\n      /* decorators */ undefined,\n      /* modifiers */[ts.createModifier(ts.SyntaxKind.StaticKeyword)],\n      /* asteriskToken */ undefined,\n      /* name */ meta.fnName,\n      /* questionToken */ undefined,\n      /* typeParameters */ typeParametersWithDefaultTypes(node.typeParameters),\n      /* parameters */[initParam],\n      /* type */ rawType,\n      /* body */ body,\n  );\n}\n\nfunction constructTypeCtorParameter(\n    node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata,\n    rawType: ts.TypeReferenceNode): ts.ParameterDeclaration {\n  // initType is the type of 'init', the single argument to the type constructor method.\n  // If the Directive has any inputs, its initType will be:\n  //\n  // Pick<rawType, 'inputA'|'inputB'>\n  //\n  // Pick here is used to select only those fields from which the generic type parameters of the\n  // directive will be inferred.\n  //\n  // In the special case there are no inputs, initType is set to {}.\n  let initType: ts.TypeNode|null = null;\n\n  const keys: string[] = meta.fields.inputs;\n  const plainKeys: ts.LiteralTypeNode[] = [];\n  const coercedKeys: ts.PropertySignature[] = [];\n  for (const key of keys) {\n    if (!meta.coercedInputFields.has(key)) {\n      plainKeys.push(ts.createLiteralTypeNode(ts.createStringLiteral(key)));\n    } else {\n      coercedKeys.push(ts.createPropertySignature(\n          /* modifiers */ undefined,\n          /* name */ key,\n          /* questionToken */ undefined,\n          /* type */ tsCreateTypeQueryForCoercedInput(rawType.typeName, key),\n          /* initializer */ undefined));\n    }\n  }\n  if (plainKeys.length > 0) {\n    // Construct a union of all the field names.\n    const keyTypeUnion = ts.createUnionTypeNode(plainKeys);\n\n    // Construct the Pick<rawType, keyTypeUnion>.\n    initType = ts.createTypeReferenceNode('Pick', [rawType, keyTypeUnion]);\n  }\n  if (coercedKeys.length > 0) {\n    const coercedLiteral = ts.createTypeLiteralNode(coercedKeys);\n\n    initType = initType !== null ? ts.createIntersectionTypeNode([initType, coercedLiteral]) :\n                                   coercedLiteral;\n  }\n\n  if (initType === null) {\n    // Special case - no inputs, outputs, or other fields which could influence the result type.\n    initType = ts.createTypeLiteralNode([]);\n  }\n\n  // Create the 'init' parameter itself.\n  return ts.createParameter(\n      /* decorators */ undefined,\n      /* modifiers */ undefined,\n      /* dotDotDotToken */ undefined,\n      /* name */ 'init',\n      /* questionToken */ undefined,\n      /* type */ initType,\n      /* initializer */ undefined);\n}\n\nfunction generateGenericArgs(params: ReadonlyArray<ts.TypeParameterDeclaration>): ts.TypeNode[] {\n  return params.map(param => ts.createTypeReferenceNode(param.name, undefined));\n}\n\nexport function requiresInlineTypeCtor(\n    node: ClassDeclaration<ts.ClassDeclaration>, host: ReflectionHost): boolean {\n  // The class requires an inline type constructor if it has generic type bounds that can not be\n  // emitted into a different context.\n  return !checkIfGenericTypeBoundsAreContextFree(node, host);\n}\n\n/**\n * Add a default `= any` to type parameters that don't have a default value already.\n *\n * TypeScript uses the default type of a type parameter whenever inference of that parameter fails.\n * This can happen when inferring a complex type from 'any'. For example, if `NgFor`'s inference is\n * done with the TCB code:\n *\n * ```\n * class NgFor<T> {\n *   ngForOf: T[];\n * }\n *\n * declare function ctor<T>(o: Pick<NgFor<T>, 'ngForOf'|'ngForTrackBy'|'ngForTemplate'>): NgFor<T>;\n * ```\n *\n * An invocation looks like:\n *\n * ```\n * var _t1 = ctor({ngForOf: [1, 2], ngForTrackBy: null as any, ngForTemplate: null as any});\n * ```\n *\n * This correctly infers the type `NgFor<number>` for `_t1`, since `T` is inferred from the\n * assignment of type `number[]` to `ngForOf`'s type `T[]`. However, if `any` is passed instead:\n *\n * ```\n * var _t2 = ctor({ngForOf: [1, 2] as any, ngForTrackBy: null as any, ngForTemplate: null as any});\n * ```\n *\n * then inference for `T` fails (it cannot be inferred from `T[] = any`). In this case, `T` takes\n * the type `{}`, and so `_t2` is inferred as `NgFor<{}>`. This is obviously wrong.\n *\n * Adding a default type to the generic declaration in the constructor solves this problem, as the\n * default type will be used in the event that inference fails.\n *\n * ```\n * declare function ctor<T = any>(o: Pick<NgFor<T>, 'ngForOf'>): NgFor<T>;\n *\n * var _t3 = ctor({ngForOf: [1, 2] as any});\n * ```\n *\n * This correctly infers `T` as `any`, and therefore `_t3` as `NgFor<any>`.\n */\nfunction typeParametersWithDefaultTypes(params: ReadonlyArray<ts.TypeParameterDeclaration>|\n                                        undefined): ts.TypeParameterDeclaration[]|undefined {\n  if (params === undefined) {\n    return undefined;\n  }\n\n  return params.map(param => {\n    if (param.default === undefined) {\n      return ts.updateTypeParameterDeclaration(\n          /* node */ param,\n          /* name */ param.name,\n          /* constraint */ param.constraint,\n          /* defaultType */ ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword));\n    } else {\n      return param;\n    }\n  });\n}\n"]}

package/src/ngtsc/typecheck/src/type_emitter.mjs

@@ -1,127 +0,0 @@
-/**
- * @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 { Reference } from '../../imports';
-const INELIGIBLE = {};
-/**
- * Determines whether the provided type can be emitted, which means that it can be safely emitted
- * into a different location.
- *
- * If this function returns true, a `TypeEmitter` should be able to succeed. Vice versa, if this
- * function returns false, then using the `TypeEmitter` should not be attempted as it is known to
- * fail.
- */
-export function canEmitType(type, resolver) {
-    return canEmitTypeWorker(type);
-    function canEmitTypeWorker(type) {
-        return visitNode(type) !== INELIGIBLE;
-    }
-    // To determine whether a type can be emitted, we have to recursively look through all type nodes.
-    // If a type reference node is found at any position within the type and that type reference
-    // cannot be emitted, then the `INELIGIBLE` constant is returned to stop the recursive walk as
-    // the type as a whole cannot be emitted in that case. Otherwise, the result of visiting all child
-    // nodes determines the result. If no ineligible type reference node is found then the walk
-    // returns `undefined`, indicating that no type node was visited that could not be emitted.
-    function visitNode(node) {
-        // Emitting a type reference node in a different context requires that an import for the type
-        // can be created. If a type reference node cannot be emitted, `INELIGIBLE` is returned to stop
-        // the walk.
-        if (ts.isTypeReferenceNode(node) && !canEmitTypeReference(node)) {
-            return INELIGIBLE;
-        }
-        else {
-            return ts.forEachChild(node, visitNode);
-        }
-    }
-    function canEmitTypeReference(type) {
-        const reference = resolver(type);
-        // If the type could not be resolved, it can not be emitted.
-        if (reference === null) {
-            return false;
-        }
-        // If the type is a reference, consider the type to be eligible for emitting.
-        if (reference instanceof Reference) {
-            return true;
-        }
-        // The type can be emitted if either it does not have any type arguments, or all of them can be
-        // emitted.
-        return type.typeArguments === undefined || type.typeArguments.every(canEmitTypeWorker);
-    }
-}
-/**
- * Given a `ts.TypeNode`, this class derives an equivalent `ts.TypeNode` that has been emitted into
- * a different context.
- *
- * For example, consider the following code:
- *
- * ```
- * import {NgIterable} from '@angular/core';
- *
- * class NgForOf<T, U extends NgIterable<T>> {}
- * ```
- *
- * Here, the generic type parameters `T` and `U` can be emitted into a different context, as the
- * type reference to `NgIterable` originates from an absolute module import so that it can be
- * emitted anywhere, using that same module import. The process of emitting translates the
- * `NgIterable` type reference to a type reference that is valid in the context in which it is
- * emitted, for example:
- *
- * ```
- * import * as i0 from '@angular/core';
- * import * as i1 from '@angular/common';
- *
- * const _ctor1: <T, U extends i0.NgIterable<T>>(o: Pick<i1.NgForOf<T, U>, 'ngForOf'>):
- * i1.NgForOf<T, U>;
- * ```
- *
- * Notice how the type reference for `NgIterable` has been translated into a qualified name,
- * referring to the namespace import that was created.
- */
-export class TypeEmitter {
-    constructor(resolver, emitReference) {
-        this.resolver = resolver;
-        this.emitReference = emitReference;
-    }
-    emitType(type) {
-        const typeReferenceTransformer = context => {
-            const visitNode = (node) => {
-                if (ts.isTypeReferenceNode(node)) {
-                    return this.emitTypeReference(node);
-                }
-                else {
-                    return ts.visitEachChild(node, visitNode, context);
-                }
-            };
-            return node => ts.visitNode(node, visitNode);
-        };
-        return ts.transform(type, [typeReferenceTransformer]).transformed[0];
-    }
-    emitTypeReference(type) {
-        // Determine the reference that the type corresponds with.
-        const reference = this.resolver(type);
-        if (reference === null) {
-            throw new Error('Unable to emit an unresolved reference');
-        }
-        // Emit the type arguments, if any.
-        let typeArguments = undefined;
-        if (type.typeArguments !== undefined) {
-            typeArguments = ts.createNodeArray(type.typeArguments.map(typeArg => this.emitType(typeArg)));
-        }
-        // Emit the type name.
-        let typeName = type.typeName;
-        if (reference instanceof Reference) {
-            const emittedType = this.emitReference(reference);
-            if (!ts.isTypeReferenceNode(emittedType)) {
-                throw new Error(`Expected TypeReferenceNode for emitted reference, got ${ts.SyntaxKind[emittedType.kind]}`);
-            }
-            typeName = emittedType.typeName;
-        }
-        return ts.updateTypeReferenceNode(type, typeName, typeArguments);
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type_emitter.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/type_emitter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as ts from 'typescript';\nimport {Reference} from '../../imports';\n\n/**\n * A resolved type reference can either be a `Reference`, the original `ts.TypeReferenceNode` itself\n * or null. A value of null indicates that no reference could be resolved or that the reference can\n * not be emitted.\n */\nexport type ResolvedTypeReference = Reference|ts.TypeReferenceNode|null;\n\n/**\n * A type reference resolver function is responsible for finding the declaration of the type\n * reference and verifying whether it can be emitted.\n */\nexport type TypeReferenceResolver = (type: ts.TypeReferenceNode) => ResolvedTypeReference;\n\n/**\n * A marker to indicate that a type reference is ineligible for emitting. This needs to be truthy\n * as it's returned from `ts.forEachChild`, which only returns truthy values.\n */\ntype INELIGIBLE = {\n  __brand: 'ineligible';\n};\nconst INELIGIBLE: INELIGIBLE = {} as INELIGIBLE;\n\n/**\n * Determines whether the provided type can be emitted, which means that it can be safely emitted\n * into a different location.\n *\n * If this function returns true, a `TypeEmitter` should be able to succeed. Vice versa, if this\n * function returns false, then using the `TypeEmitter` should not be attempted as it is known to\n * fail.\n */\nexport function canEmitType(type: ts.TypeNode, resolver: TypeReferenceResolver): boolean {\n  return canEmitTypeWorker(type);\n\n  function canEmitTypeWorker(type: ts.TypeNode): boolean {\n    return visitNode(type) !== INELIGIBLE;\n  }\n\n  // To determine whether a type can be emitted, we have to recursively look through all type nodes.\n  // If a type reference node is found at any position within the type and that type reference\n  // cannot be emitted, then the `INELIGIBLE` constant is returned to stop the recursive walk as\n  // the type as a whole cannot be emitted in that case. Otherwise, the result of visiting all child\n  // nodes determines the result. If no ineligible type reference node is found then the walk\n  // returns `undefined`, indicating that no type node was visited that could not be emitted.\n  function visitNode(node: ts.Node): INELIGIBLE|undefined {\n    // Emitting a type reference node in a different context requires that an import for the type\n    // can be created. If a type reference node cannot be emitted, `INELIGIBLE` is returned to stop\n    // the walk.\n    if (ts.isTypeReferenceNode(node) && !canEmitTypeReference(node)) {\n      return INELIGIBLE;\n    } else {\n      return ts.forEachChild(node, visitNode);\n    }\n  }\n\n  function canEmitTypeReference(type: ts.TypeReferenceNode): boolean {\n    const reference = resolver(type);\n\n    // If the type could not be resolved, it can not be emitted.\n    if (reference === null) {\n      return false;\n    }\n\n    // If the type is a reference, consider the type to be eligible for emitting.\n    if (reference instanceof Reference) {\n      return true;\n    }\n\n    // The type can be emitted if either it does not have any type arguments, or all of them can be\n    // emitted.\n    return type.typeArguments === undefined || type.typeArguments.every(canEmitTypeWorker);\n  }\n}\n\n/**\n * Given a `ts.TypeNode`, this class derives an equivalent `ts.TypeNode` that has been emitted into\n * a different context.\n *\n * For example, consider the following code:\n *\n * ```\n * import {NgIterable} from '@angular/core';\n *\n * class NgForOf<T, U extends NgIterable<T>> {}\n * ```\n *\n * Here, the generic type parameters `T` and `U` can be emitted into a different context, as the\n * type reference to `NgIterable` originates from an absolute module import so that it can be\n * emitted anywhere, using that same module import. The process of emitting translates the\n * `NgIterable` type reference to a type reference that is valid in the context in which it is\n * emitted, for example:\n *\n * ```\n * import * as i0 from '@angular/core';\n * import * as i1 from '@angular/common';\n *\n * const _ctor1: <T, U extends i0.NgIterable<T>>(o: Pick<i1.NgForOf<T, U>, 'ngForOf'>):\n * i1.NgForOf<T, U>;\n * ```\n *\n * Notice how the type reference for `NgIterable` has been translated into a qualified name,\n * referring to the namespace import that was created.\n */\nexport class TypeEmitter {\n  /**\n   * Resolver function that computes a `Reference` corresponding with a `ts.TypeReferenceNode`.\n   */\n  private resolver: TypeReferenceResolver;\n\n  /**\n   * Given a `Reference`, this function is responsible for the actual emitting work. It should\n   * produce a `ts.TypeNode` that is valid within the desired context.\n   */\n  private emitReference: (ref: Reference) => ts.TypeNode;\n\n  constructor(resolver: TypeReferenceResolver, emitReference: (ref: Reference) => ts.TypeNode) {\n    this.resolver = resolver;\n    this.emitReference = emitReference;\n  }\n\n  emitType(type: ts.TypeNode): ts.TypeNode {\n    const typeReferenceTransformer: ts.TransformerFactory<ts.TypeNode> = context => {\n      const visitNode = (node: ts.Node): ts.Node => {\n        if (ts.isTypeReferenceNode(node)) {\n          return this.emitTypeReference(node);\n        } else {\n          return ts.visitEachChild(node, visitNode, context);\n        }\n      };\n      return node => ts.visitNode(node, visitNode);\n    };\n    return ts.transform(type, [typeReferenceTransformer]).transformed[0];\n  }\n\n  private emitTypeReference(type: ts.TypeReferenceNode): ts.TypeNode {\n    // Determine the reference that the type corresponds with.\n    const reference = this.resolver(type);\n    if (reference === null) {\n      throw new Error('Unable to emit an unresolved reference');\n    }\n\n    // Emit the type arguments, if any.\n    let typeArguments: ts.NodeArray<ts.TypeNode>|undefined = undefined;\n    if (type.typeArguments !== undefined) {\n      typeArguments = ts.createNodeArray(type.typeArguments.map(typeArg => this.emitType(typeArg)));\n    }\n\n    // Emit the type name.\n    let typeName = type.typeName;\n    if (reference instanceof Reference) {\n      const emittedType = this.emitReference(reference);\n      if (!ts.isTypeReferenceNode(emittedType)) {\n        throw new Error(`Expected TypeReferenceNode for emitted reference, got ${\n            ts.SyntaxKind[emittedType.kind]}`);\n      }\n\n      typeName = emittedType.typeName;\n    }\n\n    return ts.updateTypeReferenceNode(type, typeName, typeArguments);\n  }\n}\n"]}

package/src/ngtsc/typecheck/src/type_parameter_emitter.mjs

@@ -1,93 +0,0 @@
-/**
- * @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 { Reference } from '../../imports';
-import { isNamedClassDeclaration } from '../../reflection';
-import { canEmitType, TypeEmitter } from './type_emitter';
-/**
- * See `TypeEmitter` for more information on the emitting process.
- */
-export class TypeParameterEmitter {
-    constructor(typeParameters, reflector) {
-        this.typeParameters = typeParameters;
-        this.reflector = reflector;
-    }
-    /**
-     * Determines whether the type parameters can be emitted. If this returns true, then a call to
-     * `emit` is known to succeed. Vice versa, if false is returned then `emit` should not be
-     * called, as it would fail.
-     */
-    canEmit() {
-        if (this.typeParameters === undefined) {
-            return true;
-        }
-        return this.typeParameters.every(typeParam => {
-            return this.canEmitType(typeParam.constraint) && this.canEmitType(typeParam.default);
-        });
-    }
-    canEmitType(type) {
-        if (type === undefined) {
-            return true;
-        }
-        return canEmitType(type, typeReference => this.resolveTypeReference(typeReference));
-    }
-    /**
-     * Emits the type parameters using the provided emitter function for `Reference`s.
-     */
-    emit(emitReference) {
-        if (this.typeParameters === undefined) {
-            return undefined;
-        }
-        const emitter = new TypeEmitter(type => this.resolveTypeReference(type), emitReference);
-        return this.typeParameters.map(typeParam => {
-            const constraint = typeParam.constraint !== undefined ? emitter.emitType(typeParam.constraint) : undefined;
-            const defaultType = typeParam.default !== undefined ? emitter.emitType(typeParam.default) : undefined;
-            return ts.updateTypeParameterDeclaration(
-            /* node */ typeParam, 
-            /* name */ typeParam.name, 
-            /* constraint */ constraint, 
-            /* defaultType */ defaultType);
-        });
-    }
-    resolveTypeReference(type) {
-        const target = ts.isIdentifier(type.typeName) ? type.typeName : type.typeName.right;
-        const declaration = this.reflector.getDeclarationOfIdentifier(target);
-        // If no declaration could be resolved or does not have a `ts.Declaration`, the type cannot be
-        // resolved.
-        if (declaration === null || declaration.node === null) {
-            return null;
-        }
-        // If the declaration corresponds with a local type parameter, the type reference can be used
-        // as is.
-        if (this.isLocalTypeParameter(declaration.node)) {
-            return type;
-        }
-        let owningModule = null;
-        if (declaration.viaModule !== null) {
-            owningModule = {
-                specifier: declaration.viaModule,
-                resolutionContext: type.getSourceFile().fileName,
-            };
-        }
-        // If no owning module is known, the reference needs to be exported to be able to emit an import
-        // statement for it. If the declaration is not exported, null is returned to prevent emit.
-        if (owningModule === null && !this.isStaticallyExported(declaration.node)) {
-            return null;
-        }
-        return new Reference(declaration.node, owningModule);
-    }
-    isStaticallyExported(decl) {
-        return isNamedClassDeclaration(decl) && this.reflector.isStaticallyExported(decl);
-    }
-    isLocalTypeParameter(decl) {
-        // Checking for local type parameters only occurs during resolution of type parameters, so it is
-        // guaranteed that type parameters are present.
-        return this.typeParameters.some(param => param === decl);
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type_parameter_emitter.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/type_parameter_emitter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAe,SAAS,EAAC,MAAM,eAAe,CAAC;AACtD,OAAO,EAAkB,uBAAuB,EAAiB,MAAM,kBAAkB,CAAC;AAE1F,OAAO,EAAC,WAAW,EAAyB,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAG/E;;GAEG;AACH,MAAM,OAAO,oBAAoB;IAC/B,YACY,cAAmE,EACnE,SAAyB;QADzB,mBAAc,GAAd,cAAc,CAAqD;QACnE,cAAS,GAAT,SAAS,CAAgB;IAAG,CAAC;IAEzC;;;;OAIG;IACH,OAAO;QACL,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE;YACrC,OAAO,IAAI,CAAC;SACb;QAED,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE;YAC3C,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QACvF,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,WAAW,CAAC,IAA2B;QAC7C,IAAI,IAAI,KAAK,SAAS,EAAE;YACtB,OAAO,IAAI,CAAC;SACb;QAED,OAAO,WAAW,CAAC,IAAI,EAAE,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC;IACtF,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,aAA8C;QACjD,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE;YACrC,OAAO,SAAS,CAAC;SAClB;QAED,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,CAAC;QAExF,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;YACzC,MAAM,UAAU,GACZ,SAAS,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC5F,MAAM,WAAW,GACb,SAAS,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAEtF,OAAO,EAAE,CAAC,8BAA8B;YACpC,UAAU,CAAC,SAAS;YACpB,UAAU,CAAC,SAAS,CAAC,IAAI;YACzB,gBAAgB,CAAC,UAAU;YAC3B,iBAAiB,CAAC,WAAW,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,oBAAoB,CAAC,IAA0B;QACrD,MAAM,MAAM,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;QACpF,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,0BAA0B,CAAC,MAAM,CAAC,CAAC;QAEtE,8FAA8F;QAC9F,YAAY;QACZ,IAAI,WAAW,KAAK,IAAI,IAAI,WAAW,CAAC,IAAI,KAAK,IAAI,EAAE;YACrD,OAAO,IAAI,CAAC;SACb;QAED,6FAA6F;QAC7F,SAAS;QACT,IAAI,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;YAC/C,OAAO,IAAI,CAAC;SACb;QAED,IAAI,YAAY,GAAsB,IAAI,CAAC;QAC3C,IAAI,WAAW,CAAC,SAAS,KAAK,IAAI,EAAE;YAClC,YAAY,GAAG;gBACb,SAAS,EAAE,WAAW,CAAC,SAAS;gBAChC,iBAAiB,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ;aACjD,CAAC;SACH;QAED,gGAAgG;QAChG,0FAA0F;QAC1F,IAAI,YAAY,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;YACzE,OAAO,IAAI,CAAC;SACb;QAED,OAAO,IAAI,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IACvD,CAAC;IAEO,oBAAoB,CAAC,IAAqB;QAChD,OAAO,uBAAuB,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACpF,CAAC;IAEO,oBAAoB,CAAC,IAAqB;QAChD,gGAAgG;QAChG,+CAA+C;QAC/C,OAAO,IAAI,CAAC,cAAe,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC;IAC5D,CAAC;CACF","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as ts from 'typescript';\n\nimport {OwningModule, Reference} from '../../imports';\nimport {DeclarationNode, isNamedClassDeclaration, ReflectionHost} from '../../reflection';\n\nimport {canEmitType, ResolvedTypeReference, TypeEmitter} from './type_emitter';\n\n\n/**\n * See `TypeEmitter` for more information on the emitting process.\n */\nexport class TypeParameterEmitter {\n  constructor(\n      private typeParameters: ts.NodeArray<ts.TypeParameterDeclaration>|undefined,\n      private reflector: ReflectionHost) {}\n\n  /**\n   * Determines whether the type parameters can be emitted. If this returns true, then a call to\n   * `emit` is known to succeed. Vice versa, if false is returned then `emit` should not be\n   * called, as it would fail.\n   */\n  canEmit(): boolean {\n    if (this.typeParameters === undefined) {\n      return true;\n    }\n\n    return this.typeParameters.every(typeParam => {\n      return this.canEmitType(typeParam.constraint) && this.canEmitType(typeParam.default);\n    });\n  }\n\n  private canEmitType(type: ts.TypeNode|undefined): boolean {\n    if (type === undefined) {\n      return true;\n    }\n\n    return canEmitType(type, typeReference => this.resolveTypeReference(typeReference));\n  }\n\n  /**\n   * Emits the type parameters using the provided emitter function for `Reference`s.\n   */\n  emit(emitReference: (ref: Reference) => ts.TypeNode): ts.TypeParameterDeclaration[]|undefined {\n    if (this.typeParameters === undefined) {\n      return undefined;\n    }\n\n    const emitter = new TypeEmitter(type => this.resolveTypeReference(type), emitReference);\n\n    return this.typeParameters.map(typeParam => {\n      const constraint =\n          typeParam.constraint !== undefined ? emitter.emitType(typeParam.constraint) : undefined;\n      const defaultType =\n          typeParam.default !== undefined ? emitter.emitType(typeParam.default) : undefined;\n\n      return ts.updateTypeParameterDeclaration(\n          /* node */ typeParam,\n          /* name */ typeParam.name,\n          /* constraint */ constraint,\n          /* defaultType */ defaultType);\n    });\n  }\n\n  private resolveTypeReference(type: ts.TypeReferenceNode): ResolvedTypeReference {\n    const target = ts.isIdentifier(type.typeName) ? type.typeName : type.typeName.right;\n    const declaration = this.reflector.getDeclarationOfIdentifier(target);\n\n    // If no declaration could be resolved or does not have a `ts.Declaration`, the type cannot be\n    // resolved.\n    if (declaration === null || declaration.node === null) {\n      return null;\n    }\n\n    // If the declaration corresponds with a local type parameter, the type reference can be used\n    // as is.\n    if (this.isLocalTypeParameter(declaration.node)) {\n      return type;\n    }\n\n    let owningModule: OwningModule|null = null;\n    if (declaration.viaModule !== null) {\n      owningModule = {\n        specifier: declaration.viaModule,\n        resolutionContext: type.getSourceFile().fileName,\n      };\n    }\n\n    // If no owning module is known, the reference needs to be exported to be able to emit an import\n    // statement for it. If the declaration is not exported, null is returned to prevent emit.\n    if (owningModule === null && !this.isStaticallyExported(declaration.node)) {\n      return null;\n    }\n\n    return new Reference(declaration.node, owningModule);\n  }\n\n  private isStaticallyExported(decl: DeclarationNode): boolean {\n    return isNamedClassDeclaration(decl) && this.reflector.isStaticallyExported(decl);\n  }\n\n  private isLocalTypeParameter(decl: DeclarationNode): boolean {\n    // Checking for local type parameters only occurs during resolution of type parameters, so it is\n    // guaranteed that type parameters are present.\n    return this.typeParameters!.some(param => param === decl);\n  }\n}\n"]}

package/src/ngtsc/util/src/path.mjs

@@ -1,18 +0,0 @@
-/**
- * @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 { dirname, relative, resolve, toRelativeImport } from '../../file_system';
-import { stripExtension } from '../../file_system/src/util';
-export function relativePathBetween(from, to) {
-    const relativePath = stripExtension(relative(dirname(resolve(from)), resolve(to)));
-    return relativePath !== '' ? toRelativeImport(relativePath) : null;
-}
-export function normalizeSeparators(path) {
-    // TODO: normalize path only for OS that need it.
-    return path.replace(/\\/g, '/');
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9zcmMvbmd0c2MvdXRpbC9zcmMvcGF0aC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSCxPQUFPLEVBQUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUMsTUFBTSxtQkFBbUIsQ0FBQztBQUMvRSxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sNEJBQTRCLENBQUM7QUFFMUQsTUFBTSxVQUFVLG1CQUFtQixDQUFDLElBQVksRUFBRSxFQUFVO0lBQzFELE1BQU0sWUFBWSxHQUFHLGNBQWMsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDbkYsT0FBTyxZQUFZLEtBQUssRUFBRSxDQUFDLENBQUMsQ0FBQyxnQkFBZ0IsQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO0FBQ3JFLENBQUM7QUFFRCxNQUFNLFVBQVUsbUJBQW1CLENBQUMsSUFBWTtJQUM5QyxpREFBaUQ7SUFDakQsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQztBQUNsQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQge2Rpcm5hbWUsIHJlbGF0aXZlLCByZXNvbHZlLCB0b1JlbGF0aXZlSW1wb3J0fSBmcm9tICcuLi8uLi9maWxlX3N5c3RlbSc7XG5pbXBvcnQge3N0cmlwRXh0ZW5zaW9ufSBmcm9tICcuLi8uLi9maWxlX3N5c3RlbS9zcmMvdXRpbCc7XG5cbmV4cG9ydCBmdW5jdGlvbiByZWxhdGl2ZVBhdGhCZXR3ZWVuKGZyb206IHN0cmluZywgdG86IHN0cmluZyk6IHN0cmluZ3xudWxsIHtcbiAgY29uc3QgcmVsYXRpdmVQYXRoID0gc3RyaXBFeHRlbnNpb24ocmVsYXRpdmUoZGlybmFtZShyZXNvbHZlKGZyb20pKSwgcmVzb2x2ZSh0bykpKTtcbiAgcmV0dXJuIHJlbGF0aXZlUGF0aCAhPT0gJycgPyB0b1JlbGF0aXZlSW1wb3J0KHJlbGF0aXZlUGF0aCkgOiBudWxsO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gbm9ybWFsaXplU2VwYXJhdG9ycyhwYXRoOiBzdHJpbmcpOiBzdHJpbmcge1xuICAvLyBUT0RPOiBub3JtYWxpemUgcGF0aCBvbmx5IGZvciBPUyB0aGF0IG5lZWQgaXQuXG4gIHJldHVybiBwYXRoLnJlcGxhY2UoL1xcXFwvZywgJy8nKTtcbn1cbiJdfQ==