@angular/compiler-cli 12.1.0-next.5 → 12.1.2

package/src/ngtsc/typecheck/src/environment.mjs

@@ -1,146 +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 { ExpressionType, ExternalExpr } from '@angular/compiler';
-import * as ts from 'typescript';
-import { ImportFlags } from '../../imports';
-import { translateExpression, translateType } from '../../translator';
-import { tsDeclareVariable } from './ts_util';
-import { generateTypeCtorDeclarationFn, requiresInlineTypeCtor } from './type_constructor';
-import { TypeParameterEmitter } from './type_parameter_emitter';
-/**
- * A context which hosts one or more Type Check Blocks (TCBs).
- *
- * An `Environment` supports the generation of TCBs by tracking necessary imports, declarations of
- * type constructors, and other statements beyond the type-checking code within the TCB itself.
- * Through method calls on `Environment`, the TCB generator can request `ts.Expression`s which
- * reference declarations in the `Environment` for these artifacts`.
- *
- * `Environment` can be used in a standalone fashion, or can be extended to support more specialized
- * usage.
- */
-export class Environment {
-    constructor(config, importManager, refEmitter, reflector, contextFile) {
-        this.config = config;
-        this.importManager = importManager;
-        this.refEmitter = refEmitter;
-        this.reflector = reflector;
-        this.contextFile = contextFile;
-        this.nextIds = {
-            pipeInst: 1,
-            typeCtor: 1,
-        };
-        this.typeCtors = new Map();
-        this.typeCtorStatements = [];
-        this.pipeInsts = new Map();
-        this.pipeInstStatements = [];
-    }
-    /**
-     * Get an expression referring to a type constructor for the given directive.
-     *
-     * Depending on the shape of the directive itself, this could be either a reference to a declared
-     * type constructor, or to an inline type constructor.
-     */
-    typeCtorFor(dir) {
-        const dirRef = dir.ref;
-        const node = dirRef.node;
-        if (this.typeCtors.has(node)) {
-            return this.typeCtors.get(node);
-        }
-        if (requiresInlineTypeCtor(node, this.reflector)) {
-            // The constructor has already been created inline, we just need to construct a reference to
-            // it.
-            const ref = this.reference(dirRef);
-            const typeCtorExpr = ts.createPropertyAccess(ref, 'ngTypeCtor');
-            this.typeCtors.set(node, typeCtorExpr);
-            return typeCtorExpr;
-        }
-        else {
-            const fnName = `_ctor${this.nextIds.typeCtor++}`;
-            const nodeTypeRef = this.referenceType(dirRef);
-            if (!ts.isTypeReferenceNode(nodeTypeRef)) {
-                throw new Error(`Expected TypeReferenceNode from reference to ${dirRef.debugName}`);
-            }
-            const meta = {
-                fnName,
-                body: true,
-                fields: {
-                    inputs: dir.inputs.classPropertyNames,
-                    outputs: dir.outputs.classPropertyNames,
-                    // TODO: support queries
-                    queries: dir.queries,
-                },
-                coercedInputFields: dir.coercedInputFields,
-            };
-            const typeParams = this.emitTypeParameters(node);
-            const typeCtor = generateTypeCtorDeclarationFn(node, meta, nodeTypeRef.typeName, typeParams, this.reflector);
-            this.typeCtorStatements.push(typeCtor);
-            const fnId = ts.createIdentifier(fnName);
-            this.typeCtors.set(node, fnId);
-            return fnId;
-        }
-    }
-    /*
-     * Get an expression referring to an instance of the given pipe.
-     */
-    pipeInst(ref) {
-        if (this.pipeInsts.has(ref.node)) {
-            return this.pipeInsts.get(ref.node);
-        }
-        const pipeType = this.referenceType(ref);
-        const pipeInstId = ts.createIdentifier(`_pipe${this.nextIds.pipeInst++}`);
-        this.pipeInstStatements.push(tsDeclareVariable(pipeInstId, pipeType));
-        this.pipeInsts.set(ref.node, pipeInstId);
-        return pipeInstId;
-    }
-    /**
-     * Generate a `ts.Expression` that references the given node.
-     *
-     * This may involve importing the node into the file if it's not declared there already.
-     */
-    reference(ref) {
-        // Disable aliasing for imports generated in a template type-checking context, as there is no
-        // guarantee that any alias re-exports exist in the .d.ts files. It's safe to use direct imports
-        // in these cases as there is no strict dependency checking during the template type-checking
-        // pass.
-        const ngExpr = this.refEmitter.emit(ref, this.contextFile, ImportFlags.NoAliasing);
-        // Use `translateExpression` to convert the `Expression` into a `ts.Expression`.
-        return translateExpression(ngExpr.expression, this.importManager);
-    }
-    /**
-     * Generate a `ts.TypeNode` that references the given node as a type.
-     *
-     * This may involve importing the node into the file if it's not declared there already.
-     */
-    referenceType(ref) {
-        const ngExpr = this.refEmitter.emit(ref, this.contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports);
-        // Create an `ExpressionType` from the `Expression` and translate it via `translateType`.
-        // TODO(alxhub): support references to types with generic arguments in a clean way.
-        return translateType(new ExpressionType(ngExpr.expression), this.importManager);
-    }
-    emitTypeParameters(declaration) {
-        const emitter = new TypeParameterEmitter(declaration.typeParameters, this.reflector);
-        return emitter.emit(ref => this.referenceType(ref));
-    }
-    /**
-     * Generate a `ts.TypeNode` that references a given type from the provided module.
-     *
-     * This will involve importing the type into the file, and will also add type parameters if
-     * provided.
-     */
-    referenceExternalType(moduleName, name, typeParams) {
-        const external = new ExternalExpr({ moduleName, name });
-        return translateType(new ExpressionType(external, [ /* modifiers */], typeParams), this.importManager);
-    }
-    getPreludeStatements() {
-        return [
-            ...this.pipeInstStatements,
-            ...this.typeCtorStatements,
-        ];
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/environment.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 */\n\nimport {ExpressionType, ExternalExpr, Type, WrappedNodeExpr} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {ImportFlags, Reference, ReferenceEmitter} from '../../imports';\nimport {ClassDeclaration, ReflectionHost} from '../../reflection';\nimport {ImportManager, translateExpression, translateType} from '../../translator';\nimport {TypeCheckableDirectiveMeta, TypeCheckingConfig, TypeCtorMetadata} from '../api';\n\nimport {tsDeclareVariable} from './ts_util';\nimport {generateTypeCtorDeclarationFn, requiresInlineTypeCtor} from './type_constructor';\nimport {TypeParameterEmitter} from './type_parameter_emitter';\n\n/**\n * A context which hosts one or more Type Check Blocks (TCBs).\n *\n * An `Environment` supports the generation of TCBs by tracking necessary imports, declarations of\n * type constructors, and other statements beyond the type-checking code within the TCB itself.\n * Through method calls on `Environment`, the TCB generator can request `ts.Expression`s which\n * reference declarations in the `Environment` for these artifacts`.\n *\n * `Environment` can be used in a standalone fashion, or can be extended to support more specialized\n * usage.\n */\nexport class Environment {\n  private nextIds = {\n    pipeInst: 1,\n    typeCtor: 1,\n  };\n\n  private typeCtors = new Map<ClassDeclaration, ts.Expression>();\n  protected typeCtorStatements: ts.Statement[] = [];\n\n  private pipeInsts = new Map<ClassDeclaration, ts.Expression>();\n  protected pipeInstStatements: ts.Statement[] = [];\n\n  constructor(\n      readonly config: TypeCheckingConfig, protected importManager: ImportManager,\n      private refEmitter: ReferenceEmitter, readonly reflector: ReflectionHost,\n      protected contextFile: ts.SourceFile) {}\n\n  /**\n   * Get an expression referring to a type constructor for the given directive.\n   *\n   * Depending on the shape of the directive itself, this could be either a reference to a declared\n   * type constructor, or to an inline type constructor.\n   */\n  typeCtorFor(dir: TypeCheckableDirectiveMeta): ts.Expression {\n    const dirRef = dir.ref as Reference<ClassDeclaration<ts.ClassDeclaration>>;\n    const node = dirRef.node;\n    if (this.typeCtors.has(node)) {\n      return this.typeCtors.get(node)!;\n    }\n\n    if (requiresInlineTypeCtor(node, this.reflector)) {\n      // The constructor has already been created inline, we just need to construct a reference to\n      // it.\n      const ref = this.reference(dirRef);\n      const typeCtorExpr = ts.createPropertyAccess(ref, 'ngTypeCtor');\n      this.typeCtors.set(node, typeCtorExpr);\n      return typeCtorExpr;\n    } else {\n      const fnName = `_ctor${this.nextIds.typeCtor++}`;\n      const nodeTypeRef = this.referenceType(dirRef);\n      if (!ts.isTypeReferenceNode(nodeTypeRef)) {\n        throw new Error(`Expected TypeReferenceNode from reference to ${dirRef.debugName}`);\n      }\n      const meta: TypeCtorMetadata = {\n        fnName,\n        body: true,\n        fields: {\n          inputs: dir.inputs.classPropertyNames,\n          outputs: dir.outputs.classPropertyNames,\n          // TODO: support queries\n          queries: dir.queries,\n        },\n        coercedInputFields: dir.coercedInputFields,\n      };\n      const typeParams = this.emitTypeParameters(node);\n      const typeCtor = generateTypeCtorDeclarationFn(\n          node, meta, nodeTypeRef.typeName, typeParams, this.reflector);\n      this.typeCtorStatements.push(typeCtor);\n      const fnId = ts.createIdentifier(fnName);\n      this.typeCtors.set(node, fnId);\n      return fnId;\n    }\n  }\n\n  /*\n   * Get an expression referring to an instance of the given pipe.\n   */\n  pipeInst(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>): ts.Expression {\n    if (this.pipeInsts.has(ref.node)) {\n      return this.pipeInsts.get(ref.node)!;\n    }\n\n    const pipeType = this.referenceType(ref);\n    const pipeInstId = ts.createIdentifier(`_pipe${this.nextIds.pipeInst++}`);\n\n    this.pipeInstStatements.push(tsDeclareVariable(pipeInstId, pipeType));\n    this.pipeInsts.set(ref.node, pipeInstId);\n\n    return pipeInstId;\n  }\n\n  /**\n   * Generate a `ts.Expression` that references the given node.\n   *\n   * This may involve importing the node into the file if it's not declared there already.\n   */\n  reference(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>): ts.Expression {\n    // Disable aliasing for imports generated in a template type-checking context, as there is no\n    // guarantee that any alias re-exports exist in the .d.ts files. It's safe to use direct imports\n    // in these cases as there is no strict dependency checking during the template type-checking\n    // pass.\n    const ngExpr = this.refEmitter.emit(ref, this.contextFile, ImportFlags.NoAliasing);\n\n    // Use `translateExpression` to convert the `Expression` into a `ts.Expression`.\n    return translateExpression(ngExpr.expression, this.importManager);\n  }\n\n  /**\n   * Generate a `ts.TypeNode` that references the given node as a type.\n   *\n   * This may involve importing the node into the file if it's not declared there already.\n   */\n  referenceType(ref: Reference): ts.TypeNode {\n    const ngExpr = this.refEmitter.emit(\n        ref, this.contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports);\n\n    // Create an `ExpressionType` from the `Expression` and translate it via `translateType`.\n    // TODO(alxhub): support references to types with generic arguments in a clean way.\n    return translateType(new ExpressionType(ngExpr.expression), this.importManager);\n  }\n\n  private emitTypeParameters(declaration: ClassDeclaration<ts.ClassDeclaration>):\n      ts.TypeParameterDeclaration[]|undefined {\n    const emitter = new TypeParameterEmitter(declaration.typeParameters, this.reflector);\n    return emitter.emit(ref => this.referenceType(ref));\n  }\n\n  /**\n   * Generate a `ts.TypeNode` that references a given type from the provided module.\n   *\n   * This will involve importing the type into the file, and will also add type parameters if\n   * provided.\n   */\n  referenceExternalType(moduleName: string, name: string, typeParams?: Type[]): ts.TypeNode {\n    const external = new ExternalExpr({moduleName, name});\n    return translateType(\n        new ExpressionType(external, [/* modifiers */], typeParams), this.importManager);\n  }\n\n  getPreludeStatements(): ts.Statement[] {\n    return [\n      ...this.pipeInstStatements,\n      ...this.typeCtorStatements,\n    ];\n  }\n}\n"]}