@angular/language-service 12.2.3 → 12.2.4

package/bundles/ivy.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.2.3
+ * @license Angular v12.2.4
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -19938,7 +19938,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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
      */
-    const VERSION$1 = new Version('12.2.3');
+    const VERSION$1 = new Version('12.2.4');
 
     /**
      * @license
@@ -20577,7 +20577,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function compileDeclareClassMetadata(metadata) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-        definitionMap.set('version', literal('12.2.3'));
+        definitionMap.set('version', literal('12.2.4'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', metadata.type);
         definitionMap.set('decorators', metadata.decorators);
@@ -20617,7 +20617,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createDirectiveDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-        definitionMap.set('version', literal('12.2.3'));
+        definitionMap.set('version', literal('12.2.4'));
         // e.g. `type: MyDirective`
         definitionMap.set('type', meta.internalType);
         // e.g. `selector: 'some-dir'`
@@ -20834,7 +20834,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function compileDeclareFactoryFunction(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-        definitionMap.set('version', literal('12.2.3'));
+        definitionMap.set('version', literal('12.2.4'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('deps', compileDependencies(meta.deps));
@@ -20876,7 +20876,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createInjectableDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-        definitionMap.set('version', literal('12.2.3'));
+        definitionMap.set('version', literal('12.2.4'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         // Only generate providedIn property if it has a non-null value
@@ -20955,7 +20955,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createInjectorDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-        definitionMap.set('version', literal('12.2.3'));
+        definitionMap.set('version', literal('12.2.4'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('providers', meta.providers);
@@ -20992,7 +20992,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createNgModuleDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-        definitionMap.set('version', literal('12.2.3'));
+        definitionMap.set('version', literal('12.2.4'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         // We only generate the keys in the metadata if the arrays contain values.
@@ -21050,7 +21050,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createPipeDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-        definitionMap.set('version', literal('12.2.3'));
+        definitionMap.set('version', literal('12.2.4'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         // e.g. `type: MyPipe`
         definitionMap.set('type', meta.internalType);
@@ -21082,7 +21082,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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
      */
-    const VERSION$2 = new Version('12.2.3');
+    const VERSION$2 = new Version('12.2.4');
 
     /**
      * @license
@@ -21294,6 +21294,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          * ```
          */
         ErrorCode[ErrorCode["INVALID_BANANA_IN_BOX"] = 8101] = "INVALID_BANANA_IN_BOX";
+        /**
+         * The left side of a nullish coalescing operation is not nullable.
+         *
+         * ```
+         * {{ foo ?? bar }}
+         * ```
+         * When the type of foo doesn't include `null` or `undefined`.
+         */
+        ErrorCode[ErrorCode["NULLISH_COALESCING_NOT_NULLABLE"] = 8102] = "NULLISH_COALESCING_NOT_NULLABLE";
         /**
          * The template type-checking engine would need to generate an inline type check block for a
          * component, but the current type-checking environment doesn't support it.
@@ -40125,12 +40134,11 @@ Either add the @Injectable() decorator to '${provider.node.name
      */
     class ExtendedTemplateCheckerImpl {
         constructor(templateTypeChecker, typeChecker, templateChecks) {
-            this.templateTypeChecker = templateTypeChecker;
-            this.typeChecker = typeChecker;
             this.templateChecks = templateChecks;
+            this.ctx = { templateTypeChecker: templateTypeChecker, typeChecker: typeChecker };
         }
         getDiagnosticsForComponent(component) {
-            const template = this.templateTypeChecker.getTemplate(component);
+            const 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.
@@ -40138,66 +40146,100 @@ Either add the @Injectable() decorator to '${provider.node.name
                 return [];
             }
             const diagnostics = [];
-            const ctx = {
-                templateTypeChecker: this.templateTypeChecker,
-                typeChecker: this.typeChecker,
-                component
-            };
             for (const check of this.templateChecks) {
-                diagnostics.push(...deduplicateDiagnostics(check.run(ctx, template)));
+                diagnostics.push(...check.run(this.ctx, component, template));
             }
             return diagnostics;
         }
     }
-    // Filter out duplicated diagnostics, this is possible due to the way the compiler
-    // handles desugaring and produces `AST`s. Ex.
-    //
-    // ```
-    // <div *ngIf="true" (foo)="bar">test</div>
-    // ```
-    //
-    // Would result in the following AST:
-    //
-    // ```
-    // Template {
-    //   outputs: [
-    //    BoundEvent {
-    //      name: 'foo',
-    //      /.../
-    //    }
-    //   ],
-    //   children: [
-    //     Element {
-    //       outputs: [
-    //         BoundEvent {
-    //           name: 'foo',
-    //           /.../
-    //         }
-    //       ]
-    //     }
-    //   ],
-    //   /.../
-    // }
-    // ```
-    //
-    // In this case a duplicated diagnostic could be generated for the output `foo`.
-    // TODO(danieltrevino): handle duplicated diagnostics when they are being generated
-    // to avoid extra work (could be directly in the visitor).
-    // https://github.com/angular/angular/pull/42984#discussion_r684823926
-    function deduplicateDiagnostics(diagnostics) {
-        const result = [];
-        for (const newDiag of diagnostics) {
-            const isDuplicateDiag = result.some(existingDiag => areDiagnosticsEqual(newDiag, existingDiag));
-            if (!isDuplicateDiag) {
-                result.push(newDiag);
-            }
+
+    /**
+     * @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
+     */
+    /**
+     * This abstract class provides a base implementation for the run method.
+     */
+    class TemplateCheckWithVisitor {
+        /**
+         * Base implementation for run function, visits all nodes in template and calls
+         * `visitNode()` for each one.
+         */
+        run(ctx, component, template) {
+            const visitor = new TemplateVisitor$1(ctx, component, this);
+            return visitor.getDiagnostics(template);
         }
-        return result;
     }
-    function areDiagnosticsEqual(first, second) {
-        var _a, _b;
-        return ((_a = first.file) === null || _a === void 0 ? void 0 : _a.fileName) === ((_b = second.file) === null || _b === void 0 ? void 0 : _b.fileName) && first.start === second.start &&
-            first.length === second.length && first.code === second.code;
+    /**
+     * Visits all nodes in a template (TmplAstNode and AST) and calls `visitNode` for each one.
+     */
+    class TemplateVisitor$1 extends RecursiveAstVisitor {
+        constructor(ctx, component, check) {
+            super();
+            this.ctx = ctx;
+            this.component = component;
+            this.check = check;
+            this.diagnostics = [];
+        }
+        visit(node, context) {
+            this.diagnostics.push(...this.check.visitNode(this.ctx, this.component, node));
+            node.visit(this);
+        }
+        visitAllNodes(nodes) {
+            for (const node of nodes) {
+                this.visit(node);
+            }
+        }
+        visitAst(ast) {
+            if (ast instanceof ASTWithSource) {
+                ast = ast.ast;
+            }
+            this.visit(ast);
+        }
+        visitElement(element) {
+            this.visitAllNodes(element.attributes);
+            this.visitAllNodes(element.inputs);
+            this.visitAllNodes(element.outputs);
+            this.visitAllNodes(element.references);
+            this.visitAllNodes(element.children);
+        }
+        visitTemplate(template) {
+            this.visitAllNodes(template.attributes);
+            if (template.tagName === 'ng-template') {
+                // Only visit input/outputs/templateAttrs if this isn't an inline template node
+                // generated for a structural directive (like `<div *ngIf></div>`). These nodes
+                // would be visited when the underlying element of an inline template node is processed.
+                this.visitAllNodes(template.inputs);
+                this.visitAllNodes(template.outputs);
+                this.visitAllNodes(template.templateAttrs);
+            }
+            this.visitAllNodes(template.variables);
+            this.visitAllNodes(template.references);
+            this.visitAllNodes(template.children);
+        }
+        visitContent(content) { }
+        visitVariable(variable) { }
+        visitReference(reference) { }
+        visitTextAttribute(attribute) { }
+        visitBoundAttribute(attribute) {
+            this.visitAst(attribute.value);
+        }
+        visitBoundEvent(attribute) {
+            this.visitAst(attribute.handler);
+        }
+        visitText(text) { }
+        visitBoundText(text) {
+            this.visitAst(text.value);
+        }
+        visitIcu(icu) { }
+        getDiagnostics(template) {
+            this.diagnostics = [];
+            this.visitAllNodes(template);
+            return this.diagnostics;
+        }
     }
 
     /**
@@ -40212,42 +40254,63 @@ Either add the @Injectable() decorator to '${provider.node.name
      * Parentheses should be inside the brackets "[()]".
      * Will return diagnostic information when "([])" is found.
      */
-    class InvalidBananaInBoxCheck {
+    class InvalidBananaInBoxCheck extends TemplateCheckWithVisitor {
         constructor() {
-            this.code = 8101;
+            super(...arguments);
+            this.code = ErrorCode.INVALID_BANANA_IN_BOX;
         }
-        run(ctx, template) {
-            const visitor = new BananaVisitor(ctx);
-            return visitor.getDiagnostics(template);
+        visitNode(ctx, component, node) {
+            if (!(node instanceof BoundEvent))
+                return [];
+            const name = node.name;
+            if (!name.startsWith('[') || !name.endsWith(']'))
+                return [];
+            const boundSyntax = node.sourceSpan.toString();
+            const expectedBoundSyntax = boundSyntax.replace(`(${name})`, `[(${name.slice(1, -1)})]`);
+            const diagnostic = ctx.templateTypeChecker.makeTemplateDiagnostic(component, node.sourceSpan, ts$1.DiagnosticCategory.Warning, ErrorCode.INVALID_BANANA_IN_BOX, `In the two-way binding syntax the parentheses should be inside the brackets, ex. '${expectedBoundSyntax}'. 
+        Find more at https://angular.io/guide/two-way-binding`);
+            return [diagnostic];
         }
     }
-    class BananaVisitor extends RecursiveVisitor {
-        constructor(ctx) {
-            super();
-            this.ctx = ctx;
-            this.diagnostics = [];
+
+    /**
+     * @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
+     */
+    /**
+     * 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.
+     */
+    class NullishCoalescingNotNullableCheck extends TemplateCheckWithVisitor {
+        constructor() {
+            super(...arguments);
+            this.code = ErrorCode.NULLISH_COALESCING_NOT_NULLABLE;
         }
-        /**
-         * Check for outputs with names surrounded in brackets "[]".
-         * The syntax '([foo])="bar"' would be interpreted as an @Output()
-         * with name '[foo]'. Just like '(foo)="bar"' would have the name 'foo'.
-         * Generate diagnostic information for the cases found.
-         */
-        visitBoundEvent(boundEvent) {
-            const name = boundEvent.name;
-            if (name.startsWith('[') && name.endsWith(']')) {
-                const boundSyntax = boundEvent.sourceSpan.toString();
-                const expectedBoundSyntax = boundSyntax.replace(`(${name})`, `[(${name.slice(1, -1)})]`);
-                this.diagnostics.push(this.ctx.templateTypeChecker.makeTemplateDiagnostic(this.ctx.component, boundEvent.sourceSpan, ts$1.DiagnosticCategory.Warning, ErrorCode.INVALID_BANANA_IN_BOX, `In the two-way binding syntax the parentheses should be inside the brackets, ex. '${expectedBoundSyntax}'. 
-                Find more at https://angular.io/guide/two-way-binding`));
+        visitNode(ctx, component, node) {
+            if (!(node instanceof Binary) || node.operation !== '??')
+                return [];
+            const symbolLeft = ctx.templateTypeChecker.getSymbolOfNode(node.left, component);
+            if (symbolLeft.kind !== SymbolKind.Expression) {
+                return [];
             }
-        }
-        getDiagnostics(template) {
-            this.diagnostics = [];
-            for (const node of template) {
-                node.visit(this);
+            const 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 [];
+            const symbol = ctx.templateTypeChecker.getSymbolOfNode(node, component);
+            if (symbol.kind !== SymbolKind.Expression) {
+                return [];
             }
-            return this.diagnostics;
+            const span = ctx.templateTypeChecker.getTemplateMappingAtShimLocation(symbol.shimLocation).span;
+            const diagnostic = ctx.templateTypeChecker.makeTemplateDiagnostic(component, span, ts$1.DiagnosticCategory.Warning, 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];
         }
     }
 
@@ -41034,6 +41097,9 @@ Either add the @Injectable() decorator to '${provider.node.name
             });
             const templateTypeChecker = new TemplateTypeCheckerImpl(this.inputProgram, notifyingDriver, traitCompiler, this.getTypeCheckingConfig(), refEmitter, reflector, this.adapter, this.incrementalCompilation, scopeRegistry, typeCheckScopeRegistry, this.delegatingPerfRecorder);
             const templateChecks = [new InvalidBananaInBoxCheck()];
+            if (this.options.strictNullChecks) {
+                templateChecks.push(new NullishCoalescingNotNullableCheck());
+            }
             const extendedTemplateChecker = new ExtendedTemplateCheckerImpl(templateTypeChecker, checker, templateChecks);
             return {
                 isCore,

package/bundles/language-service.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.2.3
+ * @license Angular v12.2.4
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -21475,7 +21475,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * 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
      */
-    const VERSION$1 = new Version('12.2.3');
+    const VERSION$1 = new Version('12.2.4');
 
     /**
      * @license
@@ -37554,7 +37554,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     /**
      * @publicApi
      */
-    const VERSION$2 = new Version$1('12.2.3');
+    const VERSION$2 = new Version$1('12.2.4');
 
     /**
      * @license

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/language-service",
-  "version": "12.2.3",
+  "version": "12.2.4",
   "description": "Angular - language services",
   "main": "./index.js",
   "typings": "./index.d.ts",