@angular/compiler-cli 12.2.0 → 12.2.4

package/src/ngtsc/typecheck/extended/checks/nullish_coalescing_not_nullable/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended/checks/nullish_coalescing_not_nullable" />
+import { AST, TmplAstNode } from '@angular/compiler';
+import * as ts from 'typescript';
+import { ErrorCode } from '../../../../diagnostics';
+import { NgTemplateDiagnostic } from '../../../api';
+import { TemplateCheckWithVisitor, TemplateContext } from '../../api';
+/**
+ * Ensures the left side of a nullish coalescing operation is nullable.
+ * Returns diagnostics for the cases where the operator is useless.
+ * This check should only be use if `strictNullChecks` is enabled,
+ * otherwise it would produce inaccurate results.
+ */
+export declare class NullishCoalescingNotNullableCheck extends TemplateCheckWithVisitor<ErrorCode.NULLISH_COALESCING_NOT_NULLABLE> {
+    code: ErrorCode.NULLISH_COALESCING_NOT_NULLABLE;
+    visitNode(ctx: TemplateContext, component: ts.ClassDeclaration, node: TmplAstNode | AST): NgTemplateDiagnostic<ErrorCode.NULLISH_COALESCING_NOT_NULLABLE>[];
+}

package/src/ngtsc/typecheck/extended/checks/nullish_coalescing_not_nullable/index.js

@@ -0,0 +1,64 @@
+/**
+ * @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
+ */
+(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/extended/checks/nullish_coalescing_not_nullable", ["require", "exports", "tslib", "@angular/compiler", "typescript", "@angular/compiler-cli/src/ngtsc/diagnostics", "@angular/compiler-cli/src/ngtsc/typecheck/api", "@angular/compiler-cli/src/ngtsc/typecheck/extended/api"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NullishCoalescingNotNullableCheck = void 0;
+    var tslib_1 = require("tslib");
+    var compiler_1 = require("@angular/compiler");
+    var ts = require("typescript");
+    var diagnostics_1 = require("@angular/compiler-cli/src/ngtsc/diagnostics");
+    var api_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/api");
+    var api_2 = require("@angular/compiler-cli/src/ngtsc/typecheck/extended/api");
+    /**
+     * Ensures the left side of a nullish coalescing operation is nullable.
+     * Returns diagnostics for the cases where the operator is useless.
+     * This check should only be use if `strictNullChecks` is enabled,
+     * otherwise it would produce inaccurate results.
+     */
+    var NullishCoalescingNotNullableCheck = /** @class */ (function (_super) {
+        tslib_1.__extends(NullishCoalescingNotNullableCheck, _super);
+        function NullishCoalescingNotNullableCheck() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.code = diagnostics_1.ErrorCode.NULLISH_COALESCING_NOT_NULLABLE;
+            return _this;
+        }
+        NullishCoalescingNotNullableCheck.prototype.visitNode = function (ctx, component, node) {
+            if (!(node instanceof compiler_1.Binary) || node.operation !== '??')
+                return [];
+            var symbolLeft = ctx.templateTypeChecker.getSymbolOfNode(node.left, component);
+            if (symbolLeft.kind !== api_1.SymbolKind.Expression) {
+                return [];
+            }
+            var typeLeft = symbolLeft.tsType;
+            // If the left operand's type is different from its non-nullable self, then it must
+            // contain a null or undefined so this nullish coalescing operator is useful. No diagnostic to
+            // report.
+            if (typeLeft.getNonNullableType() !== typeLeft)
+                return [];
+            var symbol = ctx.templateTypeChecker.getSymbolOfNode(node, component);
+            if (symbol.kind !== api_1.SymbolKind.Expression) {
+                return [];
+            }
+            var span = ctx.templateTypeChecker.getTemplateMappingAtShimLocation(symbol.shimLocation).span;
+            var diagnostic = ctx.templateTypeChecker.makeTemplateDiagnostic(component, span, ts.DiagnosticCategory.Warning, diagnostics_1.ErrorCode.NULLISH_COALESCING_NOT_NULLABLE, "The left side of this nullish coalescing operation does not include 'null' or 'undefined' in its type, therefore the '??' operator can be safely removed.");
+            return [diagnostic];
+        };
+        return NullishCoalescingNotNullableCheck;
+    }(api_2.TemplateCheckWithVisitor));
+    exports.NullishCoalescingNotNullableCheck = NullishCoalescingNotNullableCheck;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngtsc/typecheck/extended/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended" />
+export { ExtendedTemplateCheckerImpl } from './src/extended_template_checker';

package/src/ngtsc/typecheck/extended/index.js

@@ -0,0 +1,23 @@
+/**
+ * @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
+ */
+(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/extended", ["require", "exports", "@angular/compiler-cli/src/ngtsc/typecheck/extended/src/extended_template_checker"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ExtendedTemplateCheckerImpl = void 0;
+    var extended_template_checker_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/extended/src/extended_template_checker");
+    Object.defineProperty(exports, "ExtendedTemplateCheckerImpl", { enumerable: true, get: function () { return extended_template_checker_1.ExtendedTemplateCheckerImpl; } });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL3R5cGVjaGVjay9leHRlbmRlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7Ozs7SUFFSCw4SEFBNEU7SUFBcEUsd0lBQUEsMkJBQTJCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IHtFeHRlbmRlZFRlbXBsYXRlQ2hlY2tlckltcGx9IGZyb20gJy4vc3JjL2V4dGVuZGVkX3RlbXBsYXRlX2NoZWNrZXInO1xuIl19

package/src/ngtsc/typecheck/extended/src/extended_template_checker.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended/src/extended_template_checker" />
+import * as ts from 'typescript';
+import { ErrorCode } from '../../../diagnostics';
+import { TemplateDiagnostic, TemplateTypeChecker } from '../../api';
+import { ExtendedTemplateChecker, TemplateCheck } from '../api';
+export declare class ExtendedTemplateCheckerImpl implements ExtendedTemplateChecker {
+    private readonly templateChecks;
+    private ctx;
+    constructor(templateTypeChecker: TemplateTypeChecker, typeChecker: ts.TypeChecker, templateChecks: TemplateCheck<ErrorCode>[]);
+    getDiagnosticsForComponent(component: ts.ClassDeclaration): TemplateDiagnostic[];
+}

package/src/ngtsc/typecheck/extended/src/extended_template_checker.js

@@ -0,0 +1,55 @@
+/**
+ * @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
+ */
+(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/extended/src/extended_template_checker", ["require", "exports", "tslib"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ExtendedTemplateCheckerImpl = void 0;
+    var tslib_1 = require("tslib");
+    var ExtendedTemplateCheckerImpl = /** @class */ (function () {
+        function ExtendedTemplateCheckerImpl(templateTypeChecker, typeChecker, templateChecks) {
+            this.templateChecks = templateChecks;
+            this.ctx = { templateTypeChecker: templateTypeChecker, typeChecker: typeChecker };
+        }
+        ExtendedTemplateCheckerImpl.prototype.getDiagnosticsForComponent = function (component) {
+            var e_1, _a;
+            var template = this.ctx.templateTypeChecker.getTemplate(component);
+            // Skip checks if component has no template. This can happen if the user writes a
+            // `@Component()` but doesn't add the template, could happen in the language service
+            // when users are in the middle of typing code.
+            if (template === null) {
+                return [];
+            }
+            var diagnostics = [];
+            try {
+                for (var _b = tslib_1.__values(this.templateChecks), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var check = _c.value;
+                    diagnostics.push.apply(diagnostics, tslib_1.__spreadArray([], tslib_1.__read(check.run(this.ctx, component, template))));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return diagnostics;
+        };
+        return ExtendedTemplateCheckerImpl;
+    }());
+    exports.ExtendedTemplateCheckerImpl = ExtendedTemplateCheckerImpl;
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -17,8 +17,7 @@ import { PerfRecorder } from '../../perf';
 import { ProgramDriver } from '../../program_driver';
 import { ReflectionHost } from '../../reflection';
 import { ComponentScopeReader, TypeCheckScopeRegistry } from '../../scope';
-import { DirectiveInScope, ElementSymbol, FullTemplateMapping, GlobalCompletion, OptimizeFor, PipeInScope, ProgramTypeCheckAdapter, ShimLocation, TemplateSymbol, TemplateTypeChecker, TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
-import { TemplateDiagnostic } from '../diagnostics';
+import { DirectiveInScope, ElementSymbol, FullTemplateMapping, GlobalCompletion, NgTemplateDiagnostic, OptimizeFor, PipeInScope, ProgramTypeCheckAdapter, ShimLocation, TemplateSymbol, TemplateTypeChecker, TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
 import { ShimTypeCheckingData } from './context';
 import { TemplateSourceManager } from './source';
 /**
@@ -91,12 +90,12 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     getExpressionCompletionLocation(ast: PropertyRead | SafePropertyRead | MethodCall | SafeMethodCall, component: ts.ClassDeclaration): ShimLocation | null;
     getLiteralCompletionLocation(node: LiteralPrimitive | TextAttribute, component: ts.ClassDeclaration): ShimLocation | null;
     invalidateClass(clazz: ts.ClassDeclaration): void;
-    makeTemplateDiagnostic(clazz: ts.ClassDeclaration, sourceSpan: ParseSourceSpan, category: ts.DiagnosticCategory, errorCode: ErrorCode, message: string, relatedInformation?: {
+    makeTemplateDiagnostic<T extends ErrorCode>(clazz: ts.ClassDeclaration, sourceSpan: ParseSourceSpan, category: ts.DiagnosticCategory, errorCode: T, message: string, relatedInformation?: {
         text: string;
         start: number;
         end: number;
         sourceFile: ts.SourceFile;
-    }[]): TemplateDiagnostic;
+    }[]): NgTemplateDiagnostic<T>;
     private getOrCreateCompletionEngine;
     private maybeAdoptPriorResultsForFile;
     private ensureAllShimsForAllFiles;