@angular/compiler-cli 9.0.0-rc.6 → 9.0.0

package/src/ngtsc/typecheck/src/oob.js

@@ -35,18 +35,29 @@
             var errorMsg = "No directive found with exportAs '" + value + "'.";
             this._diagnostics.push(diagnostics_2.makeTemplateDiagnostic(mapping, ref.valueSpan || ref.sourceSpan, ts.DiagnosticCategory.Error, diagnostics_1.ngErrorCode(diagnostics_1.ErrorCode.MISSING_REFERENCE_TARGET), errorMsg));
         };
-        OutOfBandDiagnosticRecorderImpl.prototype.missingPipe = function (templateId, ast, absSpan) {
+        OutOfBandDiagnosticRecorderImpl.prototype.missingPipe = function (templateId, ast) {
             var mapping = this.resolver.getSourceMapping(templateId);
             var errorMsg = "No pipe found with name '" + ast.name + "'.";
-            var location = diagnostics_2.absoluteSourceSpanToSourceLocation(templateId, absSpan);
-            var sourceSpan = this.resolver.sourceLocationToSpan(location);
+            var sourceSpan = this.resolver.toParseSourceSpan(templateId, ast.nameSpan);
             if (sourceSpan === null) {
                 throw new Error("Assertion failure: no SourceLocation found for usage of pipe '" + ast.name + "'.");
             }
             this._diagnostics.push(diagnostics_2.makeTemplateDiagnostic(mapping, sourceSpan, ts.DiagnosticCategory.Error, diagnostics_1.ngErrorCode(diagnostics_1.ErrorCode.MISSING_PIPE), errorMsg));
         };
+        OutOfBandDiagnosticRecorderImpl.prototype.illegalAssignmentToTemplateVar = function (templateId, assignment, target) {
+            var mapping = this.resolver.getSourceMapping(templateId);
+            var errorMsg = "Cannot use variable '" + assignment.name + "' as the left-hand side of an assignment expression. Template variables are read-only.";
+            var sourceSpan = this.resolver.toParseSourceSpan(templateId, assignment.sourceSpan);
+            if (sourceSpan === null) {
+                throw new Error("Assertion failure: no SourceLocation found for property binding.");
+            }
+            this._diagnostics.push(diagnostics_2.makeTemplateDiagnostic(mapping, sourceSpan, ts.DiagnosticCategory.Error, diagnostics_1.ngErrorCode(diagnostics_1.ErrorCode.WRITE_TO_READ_ONLY_VARIABLE), errorMsg, {
+                text: "The variable " + assignment.name + " is declared here.",
+                span: target.valueSpan || target.sourceSpan,
+            }));
+        };
         return OutOfBandDiagnosticRecorderImpl;
     }());
     exports.OutOfBandDiagnosticRecorderImpl = OutOfBandDiagnosticRecorderImpl;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oob.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/oob.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;IAGH,+BAAiC;IAEjC,2EAAyD;IAGzD,yFAA6E;IAwC7E;QAGE,yCAAoB,QAAgC;YAAhC,aAAQ,GAAR,QAAQ,CAAwB;YAF5C,iBAAY,GAAoB,EAAE,CAAC;QAEY,CAAC;QAExD,sBAAI,wDAAW;iBAAf,cAAkD,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;;;WAAA;QAE7E,gEAAsB,GAAtB,UAAuB,UAAsB,EAAE,GAAqB;YAClE,IAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;YAC3D,IAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;YAE/B,IAAM,QAAQ,GAAG,uCAAqC,KAAK,OAAI,CAAC;YAChE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,oCAAsB,CACzC,OAAO,EAAE,GAAG,CAAC,SAAS,IAAI,GAAG,CAAC,UAAU,EAAE,EAAE,CAAC,kBAAkB,CAAC,KAAK,EACrE,yBAAW,CAAC,uBAAS,CAAC,wBAAwB,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;QAClE,CAAC;QAED,qDAAW,GAAX,UAAY,UAAsB,EAAE,GAAgB;YAClD,IAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;YAC3D,IAAM,QAAQ,GAAG,8BAA4B,GAAG,CAAC,IAAI,OAAI,CAAC;YAE1D,IAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,UAAU,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC;YAC7E,IAAI,UAAU,KAAK,IAAI,EAAE;gBACvB,MAAM,IAAI,KAAK,CACX,mEAAiE,GAAG,CAAC,IAAI,OAAI,CAAC,CAAC;aACpF;YACD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,oCAAsB,CACzC,OAAO,EAAE,UAAU,EAAE,EAAE,CAAC,kBAAkB,CAAC,KAAK,EAAE,yBAAW,CAAC,uBAAS,CAAC,YAAY,CAAC,EACrF,QAAQ,CAAC,CAAC,CAAC;QACjB,CAAC;QAED,wEAA8B,GAA9B,UACI,UAAsB,EAAE,UAAyB,EAAE,MAAuB;YAC5E,IAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;YAC3D,IAAM,QAAQ,GACV,0BAAwB,UAAU,CAAC,IAAI,2FAAwF,CAAC;YAEpI,IAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,UAAU,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;YACtF,IAAI,UAAU,KAAK,IAAI,EAAE;gBACvB,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAC;aACrF;YACD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,oCAAsB,CACzC,OAAO,EAAE,UAAU,EAAE,EAAE,CAAC,kBAAkB,CAAC,KAAK,EAChD,yBAAW,CAAC,uBAAS,CAAC,2BAA2B,CAAC,EAAE,QAAQ,EAAE;gBAC5D,IAAI,EAAE,kBAAgB,UAAU,CAAC,IAAI,uBAAoB;gBACzD,IAAI,EAAE,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,UAAU;aAC5C,CAAC,CAAC,CAAC;QACV,CAAC;QACH,sCAAC;IAAD,CAAC,AAhDD,IAgDC;IAhDY,0EAA+B","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 {BindingPipe, PropertyWrite, TmplAstReference, TmplAstVariable} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {ErrorCode, ngErrorCode} from '../../diagnostics';\n\nimport {TemplateId} from './api';\nimport {TemplateSourceResolver, makeTemplateDiagnostic} from './diagnostics';\n\n\n\n/**\n * Collects `ts.Diagnostic`s on problems which occur in the template which aren't directly sourced\n * from Type Check Blocks.\n *\n * During the creation of a Type Check Block, the template is traversed and the\n * `OutOfBandDiagnosticRecorder` is called to record cases when a correct interpretation for the\n * template cannot be found. These operations create `ts.Diagnostic`s which are stored by the\n * recorder for later display.\n */\nexport interface OutOfBandDiagnosticRecorder {\n  readonly diagnostics: ReadonlyArray<ts.Diagnostic>;\n\n  /**\n   * Reports a `#ref=\"target\"` expression in the template for which a target directive could not be\n   * found.\n   *\n   * @param templateId the template type-checking ID of the template which contains the broken\n   * reference.\n   * @param ref the `TmplAstReference` which could not be matched to a directive.\n   */\n  missingReferenceTarget(templateId: TemplateId, ref: TmplAstReference): void;\n\n  /**\n   * Reports usage of a `| pipe` expression in the template for which the named pipe could not be\n   * found.\n   *\n   * @param templateId the template type-checking ID of the template which contains the unknown\n   * pipe.\n   * @param ast the `BindingPipe` invocation of the pipe which could not be found.\n   */\n  missingPipe(templateId: TemplateId, ast: BindingPipe): void;\n\n  illegalAssignmentToTemplateVar(\n      templateId: TemplateId, assignment: PropertyWrite, target: TmplAstVariable): void;\n}\n\nexport class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnosticRecorder {\n  private _diagnostics: ts.Diagnostic[] = [];\n\n  constructor(private resolver: TemplateSourceResolver) {}\n\n  get diagnostics(): ReadonlyArray<ts.Diagnostic> { return this._diagnostics; }\n\n  missingReferenceTarget(templateId: TemplateId, ref: TmplAstReference): void {\n    const mapping = this.resolver.getSourceMapping(templateId);\n    const value = ref.value.trim();\n\n    const errorMsg = `No directive found with exportAs '${value}'.`;\n    this._diagnostics.push(makeTemplateDiagnostic(\n        mapping, ref.valueSpan || ref.sourceSpan, ts.DiagnosticCategory.Error,\n        ngErrorCode(ErrorCode.MISSING_REFERENCE_TARGET), errorMsg));\n  }\n\n  missingPipe(templateId: TemplateId, ast: BindingPipe): void {\n    const mapping = this.resolver.getSourceMapping(templateId);\n    const errorMsg = `No pipe found with name '${ast.name}'.`;\n\n    const sourceSpan = this.resolver.toParseSourceSpan(templateId, ast.nameSpan);\n    if (sourceSpan === null) {\n      throw new Error(\n          `Assertion failure: no SourceLocation found for usage of pipe '${ast.name}'.`);\n    }\n    this._diagnostics.push(makeTemplateDiagnostic(\n        mapping, sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(ErrorCode.MISSING_PIPE),\n        errorMsg));\n  }\n\n  illegalAssignmentToTemplateVar(\n      templateId: TemplateId, assignment: PropertyWrite, target: TmplAstVariable): void {\n    const mapping = this.resolver.getSourceMapping(templateId);\n    const errorMsg =\n        `Cannot use variable '${assignment.name}' as the left-hand side of an assignment expression. Template variables are read-only.`;\n\n    const sourceSpan = this.resolver.toParseSourceSpan(templateId, assignment.sourceSpan);\n    if (sourceSpan === null) {\n      throw new Error(`Assertion failure: no SourceLocation found for property binding.`);\n    }\n    this._diagnostics.push(makeTemplateDiagnostic(\n        mapping, sourceSpan, ts.DiagnosticCategory.Error,\n        ngErrorCode(ErrorCode.WRITE_TO_READ_ONLY_VARIABLE), errorMsg, {\n          text: `The variable ${assignment.name} is declared here.`,\n          span: target.valueSpan || target.sourceSpan,\n        }));\n  }\n}\n"]}

package/src/ngtsc/typecheck/src/source.d.ts

@@ -6,9 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/src/source" />
-import { ParseSourceFile, ParseSourceSpan } from '@angular/compiler';
-import { TemplateSourceMapping } from './api';
-import { SourceLocation, TcbSourceResolver } from './diagnostics';
+import { AbsoluteSourceSpan, ParseSourceFile, ParseSourceSpan } from '@angular/compiler';
+import { TemplateId, TemplateSourceMapping } from './api';
+import { TemplateSourceResolver } from './diagnostics';
 /**
  * Represents the source of a template that was processed during type-checking. This information is
  * used when translating parse offsets in diagnostics back to their original line/column location.
@@ -25,17 +25,17 @@ export declare class TemplateSource {
 /**
  * Assigns IDs to templates and keeps track of their origins.
  *
- * Implements `TcbSourceResolver` to resolve the source of a template based on these IDs.
+ * Implements `TemplateSourceResolver` to resolve the source of a template based on these IDs.
  */
-export declare class TcbSourceManager implements TcbSourceResolver {
-    private nextTcbId;
+export declare class TemplateSourceManager implements TemplateSourceResolver {
+    private nextTemplateId;
     /**
      * This map keeps track of all template sources that have been type-checked by the id that is
      * attached to a TCB's function declaration as leading trivia. This enables translation of
      * diagnostics produced for TCB code to their source location in the template.
      */
     private templateSources;
-    captureSource(mapping: TemplateSourceMapping, file: ParseSourceFile): string;
-    getSourceMapping(id: string): TemplateSourceMapping;
-    sourceLocationToSpan(location: SourceLocation): ParseSourceSpan | null;
+    captureSource(mapping: TemplateSourceMapping, file: ParseSourceFile): TemplateId;
+    getSourceMapping(id: TemplateId): TemplateSourceMapping;
+    toParseSourceSpan(id: TemplateId, span: AbsoluteSourceSpan): ParseSourceSpan | null;
 }

package/src/ngtsc/typecheck/src/source.js

@@ -50,11 +50,11 @@
     /**
      * Assigns IDs to templates and keeps track of their origins.
      *
-     * Implements `TcbSourceResolver` to resolve the source of a template based on these IDs.
+     * Implements `TemplateSourceResolver` to resolve the source of a template based on these IDs.
      */
-    var TcbSourceManager = /** @class */ (function () {
-        function TcbSourceManager() {
-            this.nextTcbId = 1;
+    var TemplateSourceManager = /** @class */ (function () {
+        function TemplateSourceManager() {
+            this.nextTemplateId = 1;
             /**
              * This map keeps track of all template sources that have been type-checked by the id that is
              * attached to a TCB's function declaration as leading trivia. This enables translation of
@@ -62,26 +62,26 @@
              */
             this.templateSources = new Map();
         }
-        TcbSourceManager.prototype.captureSource = function (mapping, file) {
-            var id = "tcb" + this.nextTcbId++;
+        TemplateSourceManager.prototype.captureSource = function (mapping, file) {
+            var id = "tcb" + this.nextTemplateId++;
             this.templateSources.set(id, new TemplateSource(mapping, file));
             return id;
         };
-        TcbSourceManager.prototype.getSourceMapping = function (id) {
+        TemplateSourceManager.prototype.getSourceMapping = function (id) {
             if (!this.templateSources.has(id)) {
-                throw new Error("Unexpected unknown TCB ID: " + id);
+                throw new Error("Unexpected unknown template ID: " + id);
             }
             return this.templateSources.get(id).mapping;
         };
-        TcbSourceManager.prototype.sourceLocationToSpan = function (location) {
-            if (!this.templateSources.has(location.id)) {
+        TemplateSourceManager.prototype.toParseSourceSpan = function (id, span) {
+            if (!this.templateSources.has(id)) {
                 return null;
             }
-            var templateSource = this.templateSources.get(location.id);
-            return templateSource.toParseSourceSpan(location.start, location.end);
+            var templateSource = this.templateSources.get(id);
+            return templateSource.toParseSourceSpan(span.start, span.end);
         };
-        return TcbSourceManager;
+        return TemplateSourceManager;
     }());
-    exports.TcbSourceManager = TcbSourceManager;
+    exports.TemplateSourceManager = TemplateSourceManager;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngtsc/typecheck/src/template_semantics.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/src/template_semantics" />
+import { AST, BoundTarget, PropertyWrite, RecursiveAstVisitor } from '@angular/compiler';
+import { TemplateId } from './api';
+import { OutOfBandDiagnosticRecorder } from './oob';
+/**
+ * Visits a template and records any semantic errors within its expressions.
+ */
+export declare class ExpressionSemanticVisitor extends RecursiveAstVisitor {
+    private templateId;
+    private boundTarget;
+    private oob;
+    constructor(templateId: TemplateId, boundTarget: BoundTarget<any>, oob: OutOfBandDiagnosticRecorder);
+    visitPropertyWrite(ast: PropertyWrite, context: any): void;
+    static visit(ast: AST, id: TemplateId, boundTarget: BoundTarget<any>, oob: OutOfBandDiagnosticRecorder): void;
+}

package/src/ngtsc/typecheck/src/template_semantics.js

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngtsc/typecheck/src/template_semantics", ["require", "exports", "tslib", "@angular/compiler"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    var compiler_1 = require("@angular/compiler");
+    /**
+     * Visits a template and records any semantic errors within its expressions.
+     */
+    var ExpressionSemanticVisitor = /** @class */ (function (_super) {
+        tslib_1.__extends(ExpressionSemanticVisitor, _super);
+        function ExpressionSemanticVisitor(templateId, boundTarget, oob) {
+            var _this = _super.call(this) || this;
+            _this.templateId = templateId;
+            _this.boundTarget = boundTarget;
+            _this.oob = oob;
+            return _this;
+        }
+        ExpressionSemanticVisitor.prototype.visitPropertyWrite = function (ast, context) {
+            _super.prototype.visitPropertyWrite.call(this, ast, context);
+            if (!(ast.receiver instanceof compiler_1.ImplicitReceiver)) {
+                return;
+            }
+            var target = this.boundTarget.getExpressionTarget(ast);
+            if (target instanceof compiler_1.TmplAstVariable) {
+                // Template variables are read-only.
+                this.oob.illegalAssignmentToTemplateVar(this.templateId, ast, target);
+            }
+        };
+        ExpressionSemanticVisitor.visit = function (ast, id, boundTarget, oob) {
+            ast.visit(new ExpressionSemanticVisitor(id, boundTarget, oob));
+        };
+        return ExpressionSemanticVisitor;
+    }(compiler_1.RecursiveAstVisitor));
+    exports.ExpressionSemanticVisitor = ExpressionSemanticVisitor;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngtsc/typecheck/src/ts_util.js

@@ -18,7 +18,42 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     var tslib_1 = require("tslib");
     var ts = require("typescript");
+    /**
+     * A `Set` of `ts.SyntaxKind`s of `ts.Expression` which are safe to wrap in a `ts.AsExpression`
+     * without needing to be wrapped in parentheses.
+     *
+     * For example, `foo.bar()` is a `ts.CallExpression`, and can be safely cast to `any` with
+     * `foo.bar() as any`. however, `foo !== bar` is a `ts.BinaryExpression`, and attempting to cast
+     * without the parentheses yields the expression `foo !== bar as any`. This is semantically
+     * equivalent to `foo !== (bar as any)`, which is not what was intended. Thus,
+     * `ts.BinaryExpression`s need to be wrapped in parentheses before casting.
+     */
+    //
+    var SAFE_TO_CAST_WITHOUT_PARENS = new Set([
+        // Expressions which are already parenthesized can be cast without further wrapping.
+        ts.SyntaxKind.ParenthesizedExpression,
+        // Expressions which form a single lexical unit leave no room for precedence issues with the cast.
+        ts.SyntaxKind.Identifier,
+        ts.SyntaxKind.CallExpression,
+        ts.SyntaxKind.NonNullExpression,
+        ts.SyntaxKind.ElementAccessExpression,
+        ts.SyntaxKind.PropertyAccessExpression,
+        ts.SyntaxKind.ArrayLiteralExpression,
+        ts.SyntaxKind.ObjectLiteralExpression,
+        // The same goes for various literals.
+        ts.SyntaxKind.StringLiteral,
+        ts.SyntaxKind.NumericLiteral,
+        ts.SyntaxKind.TrueKeyword,
+        ts.SyntaxKind.FalseKeyword,
+        ts.SyntaxKind.NullKeyword,
+        ts.SyntaxKind.UndefinedKeyword,
+    ]);
     function tsCastToAny(expr) {
+        // Wrap `expr` in parentheses if needed (see `SAFE_TO_CAST_WITHOUT_PARENS` above).
+        if (!SAFE_TO_CAST_WITHOUT_PARENS.has(expr.kind)) {
+            expr = ts.createParen(expr);
+        }
+        // The outer expression is always wrapped in parentheses.
         return ts.createParen(ts.createAsExpression(expr, ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)));
     }
     exports.tsCastToAny = tsCastToAny;
@@ -145,4 +180,4 @@
     }
     exports.checkIfGenericTypesAreUnbound = checkIfGenericTypesAreUnbound;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ts_util.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/ts_util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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';\nimport {ClassDeclaration} from '../../reflection';\n\nexport function tsCastToAny(expr: ts.Expression): ts.Expression {\n  return ts.createParen(\n      ts.createAsExpression(expr, ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)));\n}\n\n\n/**\n * Create an expression which instantiates an element by its HTML tagName.\n *\n * Thanks to narrowing of `document.createElement()`, this expression will have its type inferred\n * based on the tag name, including for custom elements that have appropriate .d.ts definitions.\n */\nexport function tsCreateElement(tagName: string): ts.Expression {\n  const createElement = ts.createPropertyAccess(\n      /* expression */ ts.createIdentifier('document'), 'createElement');\n  return ts.createCall(\n      /* expression */ createElement,\n      /* typeArguments */ undefined,\n      /* argumentsArray */[ts.createLiteral(tagName)]);\n}\n\n/**\n * Create a `ts.VariableStatement` which declares a variable without explicit initialization.\n *\n * The initializer `null!` is used to bypass strict variable initialization checks.\n *\n * Unlike with `tsCreateVariable`, the type of the variable is explicitly specified.\n */\nexport function tsDeclareVariable(id: ts.Identifier, type: ts.TypeNode): ts.VariableStatement {\n  const decl = ts.createVariableDeclaration(\n      /* name */ id,\n      /* type */ type,\n      /* initializer */ ts.createNonNullExpression(ts.createNull()));\n  return ts.createVariableStatement(\n      /* modifiers */ undefined,\n      /* declarationList */[decl]);\n}\n\n/**\n * Create a `ts.VariableStatement` that initializes a variable with a given expression.\n *\n * Unlike with `tsDeclareVariable`, the type of the variable is inferred from the initializer\n * expression.\n */\nexport function tsCreateVariable(\n    id: ts.Identifier, initializer: ts.Expression): ts.VariableStatement {\n  const decl = ts.createVariableDeclaration(\n      /* name */ id,\n      /* type */ undefined,\n      /* initializer */ initializer);\n  return ts.createVariableStatement(\n      /* modifiers */ undefined,\n      /* declarationList */[decl]);\n}\n\n/**\n * Construct a `ts.CallExpression` that calls a method on a receiver.\n */\nexport function tsCallMethod(\n    receiver: ts.Expression, methodName: string, args: ts.Expression[] = []): ts.CallExpression {\n  const methodAccess = ts.createPropertyAccess(receiver, methodName);\n  return ts.createCall(\n      /* expression */ methodAccess,\n      /* typeArguments */ undefined,\n      /* argumentsArray */ args);\n}\n\nexport function checkIfClassIsExported(node: ClassDeclaration): boolean {\n  // A class is exported if one of two conditions is met:\n  // 1) it has the 'export' modifier.\n  // 2) it's declared at the top level, and there is an export statement for the class.\n  if (node.modifiers !== undefined &&\n      node.modifiers.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword)) {\n    // Condition 1 is true, the class has an 'export' keyword attached.\n    return true;\n  } else if (\n      node.parent !== undefined && ts.isSourceFile(node.parent) &&\n      checkIfFileHasExport(node.parent, node.name.text)) {\n    // Condition 2 is true, the class is exported via an 'export {}' statement.\n    return true;\n  }\n  return false;\n}\n\nfunction checkIfFileHasExport(sf: ts.SourceFile, name: string): boolean {\n  for (const stmt of sf.statements) {\n    if (ts.isExportDeclaration(stmt) && stmt.exportClause !== undefined) {\n      for (const element of stmt.exportClause.elements) {\n        if (element.propertyName === undefined && element.name.text === name) {\n          // The named declaration is directly exported.\n          return true;\n        } else if (element.propertyName !== undefined && element.propertyName.text == name) {\n          // The named declaration is exported via an alias.\n          return true;\n        }\n      }\n    }\n  }\n  return false;\n}\n\nexport function checkIfGenericTypesAreUnbound(node: ClassDeclaration<ts.ClassDeclaration>):\n    boolean {\n  if (node.typeParameters === undefined) {\n    return true;\n  }\n  return node.typeParameters.every(param => param.constraint === undefined);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ts_util.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/ts_util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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';\nimport {ClassDeclaration} from '../../reflection';\n\n/**\n * A `Set` of `ts.SyntaxKind`s of `ts.Expression` which are safe to wrap in a `ts.AsExpression`\n * without needing to be wrapped in parentheses.\n *\n * For example, `foo.bar()` is a `ts.CallExpression`, and can be safely cast to `any` with\n * `foo.bar() as any`. however, `foo !== bar` is a `ts.BinaryExpression`, and attempting to cast\n * without the parentheses yields the expression `foo !== bar as any`. This is semantically\n * equivalent to `foo !== (bar as any)`, which is not what was intended. Thus,\n * `ts.BinaryExpression`s need to be wrapped in parentheses before casting.\n */\n//\nconst SAFE_TO_CAST_WITHOUT_PARENS: Set<ts.SyntaxKind> = new Set([\n  // Expressions which are already parenthesized can be cast without further wrapping.\n  ts.SyntaxKind.ParenthesizedExpression,\n\n  // Expressions which form a single lexical unit leave no room for precedence issues with the cast.\n  ts.SyntaxKind.Identifier,\n  ts.SyntaxKind.CallExpression,\n  ts.SyntaxKind.NonNullExpression,\n  ts.SyntaxKind.ElementAccessExpression,\n  ts.SyntaxKind.PropertyAccessExpression,\n  ts.SyntaxKind.ArrayLiteralExpression,\n  ts.SyntaxKind.ObjectLiteralExpression,\n\n  // The same goes for various literals.\n  ts.SyntaxKind.StringLiteral,\n  ts.SyntaxKind.NumericLiteral,\n  ts.SyntaxKind.TrueKeyword,\n  ts.SyntaxKind.FalseKeyword,\n  ts.SyntaxKind.NullKeyword,\n  ts.SyntaxKind.UndefinedKeyword,\n]);\n\nexport function tsCastToAny(expr: ts.Expression): ts.Expression {\n  // Wrap `expr` in parentheses if needed (see `SAFE_TO_CAST_WITHOUT_PARENS` above).\n  if (!SAFE_TO_CAST_WITHOUT_PARENS.has(expr.kind)) {\n    expr = ts.createParen(expr);\n  }\n\n  // The outer expression is always wrapped in parentheses.\n  return ts.createParen(\n      ts.createAsExpression(expr, ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)));\n}\n\n\n/**\n * Create an expression which instantiates an element by its HTML tagName.\n *\n * Thanks to narrowing of `document.createElement()`, this expression will have its type inferred\n * based on the tag name, including for custom elements that have appropriate .d.ts definitions.\n */\nexport function tsCreateElement(tagName: string): ts.Expression {\n  const createElement = ts.createPropertyAccess(\n      /* expression */ ts.createIdentifier('document'), 'createElement');\n  return ts.createCall(\n      /* expression */ createElement,\n      /* typeArguments */ undefined,\n      /* argumentsArray */[ts.createLiteral(tagName)]);\n}\n\n/**\n * Create a `ts.VariableStatement` which declares a variable without explicit initialization.\n *\n * The initializer `null!` is used to bypass strict variable initialization checks.\n *\n * Unlike with `tsCreateVariable`, the type of the variable is explicitly specified.\n */\nexport function tsDeclareVariable(id: ts.Identifier, type: ts.TypeNode): ts.VariableStatement {\n  const decl = ts.createVariableDeclaration(\n      /* name */ id,\n      /* type */ type,\n      /* initializer */ ts.createNonNullExpression(ts.createNull()));\n  return ts.createVariableStatement(\n      /* modifiers */ undefined,\n      /* declarationList */[decl]);\n}\n\n/**\n * Create a `ts.VariableStatement` that initializes a variable with a given expression.\n *\n * Unlike with `tsDeclareVariable`, the type of the variable is inferred from the initializer\n * expression.\n */\nexport function tsCreateVariable(\n    id: ts.Identifier, initializer: ts.Expression): ts.VariableStatement {\n  const decl = ts.createVariableDeclaration(\n      /* name */ id,\n      /* type */ undefined,\n      /* initializer */ initializer);\n  return ts.createVariableStatement(\n      /* modifiers */ undefined,\n      /* declarationList */[decl]);\n}\n\n/**\n * Construct a `ts.CallExpression` that calls a method on a receiver.\n */\nexport function tsCallMethod(\n    receiver: ts.Expression, methodName: string, args: ts.Expression[] = []): ts.CallExpression {\n  const methodAccess = ts.createPropertyAccess(receiver, methodName);\n  return ts.createCall(\n      /* expression */ methodAccess,\n      /* typeArguments */ undefined,\n      /* argumentsArray */ args);\n}\n\nexport function checkIfClassIsExported(node: ClassDeclaration): boolean {\n  // A class is exported if one of two conditions is met:\n  // 1) it has the 'export' modifier.\n  // 2) it's declared at the top level, and there is an export statement for the class.\n  if (node.modifiers !== undefined &&\n      node.modifiers.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword)) {\n    // Condition 1 is true, the class has an 'export' keyword attached.\n    return true;\n  } else if (\n      node.parent !== undefined && ts.isSourceFile(node.parent) &&\n      checkIfFileHasExport(node.parent, node.name.text)) {\n    // Condition 2 is true, the class is exported via an 'export {}' statement.\n    return true;\n  }\n  return false;\n}\n\nfunction checkIfFileHasExport(sf: ts.SourceFile, name: string): boolean {\n  for (const stmt of sf.statements) {\n    if (ts.isExportDeclaration(stmt) && stmt.exportClause !== undefined) {\n      for (const element of stmt.exportClause.elements) {\n        if (element.propertyName === undefined && element.name.text === name) {\n          // The named declaration is directly exported.\n          return true;\n        } else if (element.propertyName !== undefined && element.propertyName.text == name) {\n          // The named declaration is exported via an alias.\n          return true;\n        }\n      }\n    }\n  }\n  return false;\n}\n\nexport function checkIfGenericTypesAreUnbound(node: ClassDeclaration<ts.ClassDeclaration>):\n    boolean {\n  if (node.typeParameters === undefined) {\n    return true;\n  }\n  return node.typeParameters.every(param => param.constraint === undefined);\n}\n"]}

package/src/ngtsc/typecheck/src/type_check_block.d.ts

@@ -10,7 +10,7 @@ import { BoundTarget, SchemaMetadata } from '@angular/compiler';
 import * as ts from 'typescript';
 import { Reference } from '../../imports';
 import { ClassDeclaration } from '../../reflection';
-import { TypeCheckBlockMetadata, TypeCheckableDirectiveMeta } from './api';
+import { TemplateId, TypeCheckBlockMetadata, TypeCheckableDirectiveMeta } from './api';
 import { DomSchemaChecker } from './dom';
 import { Environment } from './environment';
 import { OutOfBandDiagnosticRecorder } from './oob';
@@ -48,12 +48,12 @@ export declare class Context {
     readonly env: Environment;
     readonly domSchemaChecker: DomSchemaChecker;
     readonly oobRecorder: OutOfBandDiagnosticRecorder;
-    readonly id: string;
+    readonly id: TemplateId;
     readonly boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;
     private pipes;
     readonly schemas: SchemaMetadata[];
     private nextId;
-    constructor(env: Environment, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, id: string, boundTarget: BoundTarget<TypeCheckableDirectiveMeta>, pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, schemas: SchemaMetadata[]);
+    constructor(env: Environment, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, id: TemplateId, boundTarget: BoundTarget<TypeCheckableDirectiveMeta>, pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, schemas: SchemaMetadata[]);
     /**
      * Allocate a new variable name for use within the `Context`.
      *