@angular/compiler-cli 12.2.3 → 12.2.4

package/src/ngtsc/diagnostics/src/error_code.js

@@ -165,6 +165,15 @@
          * ```
          */
         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.
@@ -223,4 +232,4 @@
     }
     exports.ngErrorCode = ngErrorCode;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error_code.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/diagnostics/src/error_code.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;IAEH;;OAEG;IACH,IAAY,SA8MX;IA9MD,WAAY,SAAS;QACnB,sFAAgC,CAAA;QAChC,8EAA4B,CAAA;QAC5B,4EAA2B,CAAA;QAC3B,4FAAmC,CAAA;QACnC,4EAA2B,CAAA;QAE3B;;WAEG;QACH,0EAA0B,CAAA;QAE1B,4EAA2B,CAAA;QAC3B,sEAAwB,CAAA;QAExB,wFAAiC,CAAA;QACjC,sEAAwB,CAAA;QACxB,0EAA0B,CAAA;QAC1B,wFAAiC,CAAA;QAEjC,8FAA8F;QAC9F,4EAA2B,CAAA;QAE3B;;;WAGG;QACH,0GAA0C,CAAA;QAE1C;;;WAGG;QACH,oHAA+C,CAAA;QAE/C;;;WAGG;QACH,4FAAmC,CAAA;QAEnC;;;WAGG;QACH,8GAA4C,CAAA;QAE5C,0EAA0B,CAAA;QAC1B,4GAA2C,CAAA;QAC3C;;;WAGG;QACH,8EAA4B,CAAA;QAE5B,0FAAkC,CAAA;QAClC,kJAA8D,CAAA;QAE9D;;;WAGG;QACH,oFAA+B,CAAA;QAE/B;;WAEG;QACH,4EAA2B,CAAA;QAE3B;;WAEG;QACH,4FAAmC,CAAA;QAEnC;;WAEG;QACH,kFAA8B,CAAA;QAE9B;;WAEG;QACH,kFAA8B,CAAA;QAE9B;;;WAGG;QACH,sFAAgC,CAAA;QAEhC;;;WAGG;QACH,gIAAqD,CAAA;QAErD;;;WAGG;QACH,oGAAuC,CAAA;QAEvC;;WAEG;QACH,kGAAsC,CAAA;QAEtC;;;WAGG;QACH,sGAAwC,CAAA;QAExC;;WAEG;QACH,gFAA6B,CAAA;QAE7B;;WAEG;QACH,oFAA+B,CAAA;QAE/B;;WAEG;QACH,oFAA+B,CAAA;QAE/B;;WAEG;QACH,4DAAmB,CAAA;QAEnB;;;;;;;;;;;WAWG;QACH,0FAAkC,CAAA;QAElC;;;;;;;WAOG;QACH,gGAAqC,CAAA;QAErC;;;WAGG;QACH,8EAA4B,CAAA;QAE5B;;;;;;;WAOG;QACH,8EAA4B,CAAA;QAE5B;;;WAGG;QACH,0EAA0B,CAAA;QAE1B;;;WAGG;QACH,sFAAgC,CAAA;QAEhC;;WAEG;QACH,sFAAgC,CAAA;QAEhC,4EAA4E;QAC5E,iGAAiG;QACjG,sFAAsF;QAEtF;;;WAGG;QACH,qFAAgC,CAAA;QAEhC;;;;WAIG;QACH,uGAAyC,CAAA;IAC3C,CAAC,EA9MW,SAAS,GAAT,iBAAS,KAAT,iBAAS,QA8MpB;IAED;;;;;OAKG;IACU,QAAA,2BAA2B,GAAG,2BAA2B,CAAC;IAEvE;;;;OAIG;IACU,QAAA,2BAA2B,GAAG,IAAI,GAAG,CAAC;QACjD,SAAS,CAAC,yBAAyB;QACnC,SAAS,CAAC,qBAAqB;QAC/B,SAAS,CAAC,mBAAmB;QAC7B,SAAS,CAAC,sBAAsB;QAChC,SAAS,CAAC,wBAAwB;QAClC,SAAS,CAAC,wBAAwB;QAClC,SAAS,CAAC,qCAAqC;KAChD,CAAC,CAAC;IAEH;;OAEG;IACH,SAAgB,WAAW,CAAC,IAAe;QACzC,OAAO,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IAChC,CAAC;IAFD,kCAEC","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\n/**\n * @publicApi\n */\nexport enum ErrorCode {\n  DECORATOR_ARG_NOT_LITERAL = 1001,\n  DECORATOR_ARITY_WRONG = 1002,\n  DECORATOR_NOT_CALLED = 1003,\n  DECORATOR_ON_ANONYMOUS_CLASS = 1004,\n  DECORATOR_UNEXPECTED = 1005,\n\n  /**\n   * This error code indicates that there are incompatible decorators on a type or a class field.\n   */\n  DECORATOR_COLLISION = 1006,\n\n  VALUE_HAS_WRONG_TYPE = 1010,\n  VALUE_NOT_LITERAL = 1011,\n\n  COMPONENT_MISSING_TEMPLATE = 2001,\n  PIPE_MISSING_NAME = 2002,\n  PARAM_MISSING_TOKEN = 2003,\n  DIRECTIVE_MISSING_SELECTOR = 2004,\n\n  /** Raised when an undecorated class is passed in as a provider to a module or a directive. */\n  UNDECORATED_PROVIDER = 2005,\n\n  /**\n   * Raised when a Directive inherits its constructor from a base class without an Angular\n   * decorator.\n   */\n  DIRECTIVE_INHERITS_UNDECORATED_CTOR = 2006,\n\n  /**\n   * Raised when an undecorated class that is using Angular features\n   * has been discovered.\n   */\n  UNDECORATED_CLASS_USING_ANGULAR_FEATURES = 2007,\n\n  /**\n   * Raised when an component cannot resolve an external resource, such as a template or a style\n   * sheet.\n   */\n  COMPONENT_RESOURCE_NOT_FOUND = 2008,\n\n  /**\n   * Raised when a component uses `ShadowDom` view encapsulation, but its selector\n   * does not match the shadow DOM tag name requirements.\n   */\n  COMPONENT_INVALID_SHADOW_DOM_SELECTOR = 2009,\n\n  SYMBOL_NOT_EXPORTED = 3001,\n  SYMBOL_EXPORTED_UNDER_DIFFERENT_NAME = 3002,\n  /**\n   * Raised when a relationship between directives and/or pipes would cause a cyclic import to be\n   * created that cannot be handled, such as in partial compilation mode.\n   */\n  IMPORT_CYCLE_DETECTED = 3003,\n\n  CONFIG_FLAT_MODULE_NO_INDEX = 4001,\n  CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK = 4002,\n\n  /**\n   * Raised when a host expression has a parse error, such as a host listener or host binding\n   * expression containing a pipe.\n   */\n  HOST_BINDING_PARSE_ERROR = 5001,\n\n  /**\n   * Raised when the compiler cannot parse a component's template.\n   */\n  TEMPLATE_PARSE_ERROR = 5002,\n\n  /**\n   * Raised when an NgModule contains an invalid reference in `declarations`.\n   */\n  NGMODULE_INVALID_DECLARATION = 6001,\n\n  /**\n   * Raised when an NgModule contains an invalid type in `imports`.\n   */\n  NGMODULE_INVALID_IMPORT = 6002,\n\n  /**\n   * Raised when an NgModule contains an invalid type in `exports`.\n   */\n  NGMODULE_INVALID_EXPORT = 6003,\n\n  /**\n   * Raised when an NgModule contains a type in `exports` which is neither in `declarations` nor\n   * otherwise imported.\n   */\n  NGMODULE_INVALID_REEXPORT = 6004,\n\n  /**\n   * Raised when a `ModuleWithProviders` with a missing\n   * generic type argument is passed into an `NgModule`.\n   */\n  NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC = 6005,\n\n  /**\n   * Raised when an NgModule exports multiple directives/pipes of the same name and the compiler\n   * attempts to generate private re-exports within the NgModule file.\n   */\n  NGMODULE_REEXPORT_NAME_COLLISION = 6006,\n\n  /**\n   * Raised when a directive/pipe is part of the declarations of two or more NgModules.\n   */\n  NGMODULE_DECLARATION_NOT_UNIQUE = 6007,\n\n  /**\n   * Not actually raised by the compiler, but reserved for documentation of a View Engine error when\n   * a View Engine build depends on an Ivy-compiled NgModule.\n   */\n  NGMODULE_VE_DEPENDENCY_ON_IVY_LIB = 6999,\n\n  /**\n   * An element name failed validation against the DOM schema.\n   */\n  SCHEMA_INVALID_ELEMENT = 8001,\n\n  /**\n   * An element's attribute name failed validation against the DOM schema.\n   */\n  SCHEMA_INVALID_ATTRIBUTE = 8002,\n\n  /**\n   * No matching directive was found for a `#ref=\"target\"` expression.\n   */\n  MISSING_REFERENCE_TARGET = 8003,\n\n  /**\n   * No matching pipe was found for a\n   */\n  MISSING_PIPE = 8004,\n\n  /**\n   * The left-hand side of an assignment expression was a template variable. Effectively, the\n   * template looked like:\n   *\n   * ```\n   * <ng-template let-something>\n   *   <button (click)=\"something = ...\">...</button>\n   * </ng-template>\n   * ```\n   *\n   * Template variables are read-only.\n   */\n  WRITE_TO_READ_ONLY_VARIABLE = 8005,\n\n  /**\n   * A template variable was declared twice. For example:\n   *\n   * ```html\n   * <div *ngFor=\"let i of items; let i = index\">\n   * </div>\n   * ```\n   */\n  DUPLICATE_VARIABLE_DECLARATION = 8006,\n\n  /**\n   * A template has a two way binding (two bindings created by a single syntactial element)\n   * in which the input and output are going to different places.\n   */\n  SPLIT_TWO_WAY_BINDING = 8007,\n\n  /**\n   * A two way binding in a template has an incorrect syntax,\n   * parentheses outside brackets. For example:\n   *\n   * ```\n   * <div ([foo])=\"bar\" />\n   * ```\n   */\n  INVALID_BANANA_IN_BOX = 8101,\n\n  /**\n   * The template type-checking engine would need to generate an inline type check block for a\n   * component, but the current type-checking environment doesn't support it.\n   */\n  INLINE_TCB_REQUIRED = 8900,\n\n  /**\n   * The template type-checking engine would need to generate an inline type constructor for a\n   * directive or component, but the current type-checking environment doesn't support it.\n   */\n  INLINE_TYPE_CTOR_REQUIRED = 8901,\n\n  /**\n   * An injectable already has a `ɵprov` property.\n   */\n  INJECTABLE_DUPLICATE_PROV = 9001,\n\n  // 10XXX error codes are reserved for diagnostics with categories other than\n  // `ts.DiagnosticCategory.Error`. These diagnostics are generated by the compiler when configured\n  // to do so by a tool such as the Language Service, or by the Language Service itself.\n\n  /**\n   * Suggest users to enable `strictTemplates` to make use of full capabilities\n   * provided by Angular language service.\n   */\n  SUGGEST_STRICT_TEMPLATES = 10001,\n\n  /**\n   * Indicates that a particular structural directive provides advanced type narrowing\n   * functionality, but the current template type-checking configuration does not allow its usage in\n   * type inference.\n   */\n  SUGGEST_SUBOPTIMAL_TYPE_INFERENCE = 10002,\n}\n\n/**\n * @internal\n * Base URL for the error details page.\n * Keep this value in sync with a similar const in\n * `packages/core/src/render3/error_code.ts`.\n */\nexport const ERROR_DETAILS_PAGE_BASE_URL = 'https://angular.io/errors';\n\n/**\n * @internal\n * Contains a set of error messages that have detailed guides at angular.io.\n * Full list of available error guides can be found at https://angular.io/errors\n */\nexport const COMPILER_ERRORS_WITH_GUIDES = new Set([\n  ErrorCode.DECORATOR_ARG_NOT_LITERAL,\n  ErrorCode.IMPORT_CYCLE_DETECTED,\n  ErrorCode.PARAM_MISSING_TOKEN,\n  ErrorCode.SCHEMA_INVALID_ELEMENT,\n  ErrorCode.SCHEMA_INVALID_ATTRIBUTE,\n  ErrorCode.MISSING_REFERENCE_TARGET,\n  ErrorCode.COMPONENT_INVALID_SHADOW_DOM_SELECTOR,\n]);\n\n/**\n * @internal\n */\nexport function ngErrorCode(code: ErrorCode): number {\n  return parseInt('-99' + code);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error_code.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/diagnostics/src/error_code.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;IAEH;;OAEG;IACH,IAAY,SAwNX;IAxND,WAAY,SAAS;QACnB,sFAAgC,CAAA;QAChC,8EAA4B,CAAA;QAC5B,4EAA2B,CAAA;QAC3B,4FAAmC,CAAA;QACnC,4EAA2B,CAAA;QAE3B;;WAEG;QACH,0EAA0B,CAAA;QAE1B,4EAA2B,CAAA;QAC3B,sEAAwB,CAAA;QAExB,wFAAiC,CAAA;QACjC,sEAAwB,CAAA;QACxB,0EAA0B,CAAA;QAC1B,wFAAiC,CAAA;QAEjC,8FAA8F;QAC9F,4EAA2B,CAAA;QAE3B;;;WAGG;QACH,0GAA0C,CAAA;QAE1C;;;WAGG;QACH,oHAA+C,CAAA;QAE/C;;;WAGG;QACH,4FAAmC,CAAA;QAEnC;;;WAGG;QACH,8GAA4C,CAAA;QAE5C,0EAA0B,CAAA;QAC1B,4GAA2C,CAAA;QAC3C;;;WAGG;QACH,8EAA4B,CAAA;QAE5B,0FAAkC,CAAA;QAClC,kJAA8D,CAAA;QAE9D;;;WAGG;QACH,oFAA+B,CAAA;QAE/B;;WAEG;QACH,4EAA2B,CAAA;QAE3B;;WAEG;QACH,4FAAmC,CAAA;QAEnC;;WAEG;QACH,kFAA8B,CAAA;QAE9B;;WAEG;QACH,kFAA8B,CAAA;QAE9B;;;WAGG;QACH,sFAAgC,CAAA;QAEhC;;;WAGG;QACH,gIAAqD,CAAA;QAErD;;;WAGG;QACH,oGAAuC,CAAA;QAEvC;;WAEG;QACH,kGAAsC,CAAA;QAEtC;;;WAGG;QACH,sGAAwC,CAAA;QAExC;;WAEG;QACH,gFAA6B,CAAA;QAE7B;;WAEG;QACH,oFAA+B,CAAA;QAE/B;;WAEG;QACH,oFAA+B,CAAA;QAE/B;;WAEG;QACH,4DAAmB,CAAA;QAEnB;;;;;;;;;;;WAWG;QACH,0FAAkC,CAAA;QAElC;;;;;;;WAOG;QACH,gGAAqC,CAAA;QAErC;;;WAGG;QACH,8EAA4B,CAAA;QAE5B;;;;;;;WAOG;QACH,8EAA4B,CAAA;QAE5B;;;;;;;WAOG;QACH,kGAAsC,CAAA;QAEtC;;;WAGG;QACH,0EAA0B,CAAA;QAE1B;;;WAGG;QACH,sFAAgC,CAAA;QAEhC;;WAEG;QACH,sFAAgC,CAAA;QAEhC,4EAA4E;QAC5E,iGAAiG;QACjG,sFAAsF;QAEtF;;;WAGG;QACH,qFAAgC,CAAA;QAEhC;;;;WAIG;QACH,uGAAyC,CAAA;IAC3C,CAAC,EAxNW,SAAS,GAAT,iBAAS,KAAT,iBAAS,QAwNpB;IAED;;;;;OAKG;IACU,QAAA,2BAA2B,GAAG,2BAA2B,CAAC;IAEvE;;;;OAIG;IACU,QAAA,2BAA2B,GAAG,IAAI,GAAG,CAAC;QACjD,SAAS,CAAC,yBAAyB;QACnC,SAAS,CAAC,qBAAqB;QAC/B,SAAS,CAAC,mBAAmB;QAC7B,SAAS,CAAC,sBAAsB;QAChC,SAAS,CAAC,wBAAwB;QAClC,SAAS,CAAC,wBAAwB;QAClC,SAAS,CAAC,qCAAqC;KAChD,CAAC,CAAC;IAEH;;OAEG;IACH,SAAgB,WAAW,CAAC,IAAe;QACzC,OAAO,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IAChC,CAAC;IAFD,kCAEC","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\n/**\n * @publicApi\n */\nexport enum ErrorCode {\n  DECORATOR_ARG_NOT_LITERAL = 1001,\n  DECORATOR_ARITY_WRONG = 1002,\n  DECORATOR_NOT_CALLED = 1003,\n  DECORATOR_ON_ANONYMOUS_CLASS = 1004,\n  DECORATOR_UNEXPECTED = 1005,\n\n  /**\n   * This error code indicates that there are incompatible decorators on a type or a class field.\n   */\n  DECORATOR_COLLISION = 1006,\n\n  VALUE_HAS_WRONG_TYPE = 1010,\n  VALUE_NOT_LITERAL = 1011,\n\n  COMPONENT_MISSING_TEMPLATE = 2001,\n  PIPE_MISSING_NAME = 2002,\n  PARAM_MISSING_TOKEN = 2003,\n  DIRECTIVE_MISSING_SELECTOR = 2004,\n\n  /** Raised when an undecorated class is passed in as a provider to a module or a directive. */\n  UNDECORATED_PROVIDER = 2005,\n\n  /**\n   * Raised when a Directive inherits its constructor from a base class without an Angular\n   * decorator.\n   */\n  DIRECTIVE_INHERITS_UNDECORATED_CTOR = 2006,\n\n  /**\n   * Raised when an undecorated class that is using Angular features\n   * has been discovered.\n   */\n  UNDECORATED_CLASS_USING_ANGULAR_FEATURES = 2007,\n\n  /**\n   * Raised when an component cannot resolve an external resource, such as a template or a style\n   * sheet.\n   */\n  COMPONENT_RESOURCE_NOT_FOUND = 2008,\n\n  /**\n   * Raised when a component uses `ShadowDom` view encapsulation, but its selector\n   * does not match the shadow DOM tag name requirements.\n   */\n  COMPONENT_INVALID_SHADOW_DOM_SELECTOR = 2009,\n\n  SYMBOL_NOT_EXPORTED = 3001,\n  SYMBOL_EXPORTED_UNDER_DIFFERENT_NAME = 3002,\n  /**\n   * Raised when a relationship between directives and/or pipes would cause a cyclic import to be\n   * created that cannot be handled, such as in partial compilation mode.\n   */\n  IMPORT_CYCLE_DETECTED = 3003,\n\n  CONFIG_FLAT_MODULE_NO_INDEX = 4001,\n  CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK = 4002,\n\n  /**\n   * Raised when a host expression has a parse error, such as a host listener or host binding\n   * expression containing a pipe.\n   */\n  HOST_BINDING_PARSE_ERROR = 5001,\n\n  /**\n   * Raised when the compiler cannot parse a component's template.\n   */\n  TEMPLATE_PARSE_ERROR = 5002,\n\n  /**\n   * Raised when an NgModule contains an invalid reference in `declarations`.\n   */\n  NGMODULE_INVALID_DECLARATION = 6001,\n\n  /**\n   * Raised when an NgModule contains an invalid type in `imports`.\n   */\n  NGMODULE_INVALID_IMPORT = 6002,\n\n  /**\n   * Raised when an NgModule contains an invalid type in `exports`.\n   */\n  NGMODULE_INVALID_EXPORT = 6003,\n\n  /**\n   * Raised when an NgModule contains a type in `exports` which is neither in `declarations` nor\n   * otherwise imported.\n   */\n  NGMODULE_INVALID_REEXPORT = 6004,\n\n  /**\n   * Raised when a `ModuleWithProviders` with a missing\n   * generic type argument is passed into an `NgModule`.\n   */\n  NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC = 6005,\n\n  /**\n   * Raised when an NgModule exports multiple directives/pipes of the same name and the compiler\n   * attempts to generate private re-exports within the NgModule file.\n   */\n  NGMODULE_REEXPORT_NAME_COLLISION = 6006,\n\n  /**\n   * Raised when a directive/pipe is part of the declarations of two or more NgModules.\n   */\n  NGMODULE_DECLARATION_NOT_UNIQUE = 6007,\n\n  /**\n   * Not actually raised by the compiler, but reserved for documentation of a View Engine error when\n   * a View Engine build depends on an Ivy-compiled NgModule.\n   */\n  NGMODULE_VE_DEPENDENCY_ON_IVY_LIB = 6999,\n\n  /**\n   * An element name failed validation against the DOM schema.\n   */\n  SCHEMA_INVALID_ELEMENT = 8001,\n\n  /**\n   * An element's attribute name failed validation against the DOM schema.\n   */\n  SCHEMA_INVALID_ATTRIBUTE = 8002,\n\n  /**\n   * No matching directive was found for a `#ref=\"target\"` expression.\n   */\n  MISSING_REFERENCE_TARGET = 8003,\n\n  /**\n   * No matching pipe was found for a\n   */\n  MISSING_PIPE = 8004,\n\n  /**\n   * The left-hand side of an assignment expression was a template variable. Effectively, the\n   * template looked like:\n   *\n   * ```\n   * <ng-template let-something>\n   *   <button (click)=\"something = ...\">...</button>\n   * </ng-template>\n   * ```\n   *\n   * Template variables are read-only.\n   */\n  WRITE_TO_READ_ONLY_VARIABLE = 8005,\n\n  /**\n   * A template variable was declared twice. For example:\n   *\n   * ```html\n   * <div *ngFor=\"let i of items; let i = index\">\n   * </div>\n   * ```\n   */\n  DUPLICATE_VARIABLE_DECLARATION = 8006,\n\n  /**\n   * A template has a two way binding (two bindings created by a single syntactial element)\n   * in which the input and output are going to different places.\n   */\n  SPLIT_TWO_WAY_BINDING = 8007,\n\n  /**\n   * A two way binding in a template has an incorrect syntax,\n   * parentheses outside brackets. For example:\n   *\n   * ```\n   * <div ([foo])=\"bar\" />\n   * ```\n   */\n  INVALID_BANANA_IN_BOX = 8101,\n\n  /**\n   * The left side of a nullish coalescing operation is not nullable.\n   *\n   * ```\n   * {{ foo ?? bar }}\n   * ```\n   * When the type of foo doesn't include `null` or `undefined`.\n   */\n  NULLISH_COALESCING_NOT_NULLABLE = 8102,\n\n  /**\n   * The template type-checking engine would need to generate an inline type check block for a\n   * component, but the current type-checking environment doesn't support it.\n   */\n  INLINE_TCB_REQUIRED = 8900,\n\n  /**\n   * The template type-checking engine would need to generate an inline type constructor for a\n   * directive or component, but the current type-checking environment doesn't support it.\n   */\n  INLINE_TYPE_CTOR_REQUIRED = 8901,\n\n  /**\n   * An injectable already has a `ɵprov` property.\n   */\n  INJECTABLE_DUPLICATE_PROV = 9001,\n\n  // 10XXX error codes are reserved for diagnostics with categories other than\n  // `ts.DiagnosticCategory.Error`. These diagnostics are generated by the compiler when configured\n  // to do so by a tool such as the Language Service, or by the Language Service itself.\n\n  /**\n   * Suggest users to enable `strictTemplates` to make use of full capabilities\n   * provided by Angular language service.\n   */\n  SUGGEST_STRICT_TEMPLATES = 10001,\n\n  /**\n   * Indicates that a particular structural directive provides advanced type narrowing\n   * functionality, but the current template type-checking configuration does not allow its usage in\n   * type inference.\n   */\n  SUGGEST_SUBOPTIMAL_TYPE_INFERENCE = 10002,\n}\n\n/**\n * @internal\n * Base URL for the error details page.\n * Keep this value in sync with a similar const in\n * `packages/core/src/render3/error_code.ts`.\n */\nexport const ERROR_DETAILS_PAGE_BASE_URL = 'https://angular.io/errors';\n\n/**\n * @internal\n * Contains a set of error messages that have detailed guides at angular.io.\n * Full list of available error guides can be found at https://angular.io/errors\n */\nexport const COMPILER_ERRORS_WITH_GUIDES = new Set([\n  ErrorCode.DECORATOR_ARG_NOT_LITERAL,\n  ErrorCode.IMPORT_CYCLE_DETECTED,\n  ErrorCode.PARAM_MISSING_TOKEN,\n  ErrorCode.SCHEMA_INVALID_ELEMENT,\n  ErrorCode.SCHEMA_INVALID_ATTRIBUTE,\n  ErrorCode.MISSING_REFERENCE_TARGET,\n  ErrorCode.COMPONENT_INVALID_SHADOW_DOM_SELECTOR,\n]);\n\n/**\n * @internal\n */\nexport function ngErrorCode(code: ErrorCode): number {\n  return parseInt('-99' + code);\n}\n"]}

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

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended/api/api" />
-import { TmplAstNode } from '@angular/compiler';
+import { AST, TmplAstNode } from '@angular/compiler';
 import * as ts from 'typescript';
 import { ErrorCode } from '../../../diagnostics';
 import { NgTemplateDiagnostic, TemplateTypeChecker } from '../../api';
@@ -18,7 +18,7 @@ export interface TemplateCheck<T extends ErrorCode> {
     /** Unique template check code, used for configuration and searching the error. */
     code: T;
     /** Runs check and returns information about the diagnostics to be generated. */
-    run(ctx: TemplateContext, template: TmplAstNode[]): NgTemplateDiagnostic<T>[];
+    run(ctx: TemplateContext, component: ts.ClassDeclaration, template: TmplAstNode[]): NgTemplateDiagnostic<T>[];
 }
 /**
  * The TemplateContext provided to a Template Check to get diagnostic information.
@@ -31,6 +31,20 @@ export interface TemplateContext {
      * in the template (it is not to query types outside the Angular component).
      */
     typeChecker: ts.TypeChecker;
-    /** The `@Component()` class from which the template was obtained. */
-    component: ts.ClassDeclaration;
+}
+/**
+ * This abstract class provides a base implementation for the run method.
+ */
+export declare abstract class TemplateCheckWithVisitor<T extends ErrorCode> implements TemplateCheck<T> {
+    abstract code: T;
+    /**
+     * Base implementation for run function, visits all nodes in template and calls
+     * `visitNode()` for each one.
+     */
+    run(ctx: TemplateContext, component: ts.ClassDeclaration, template: TmplAstNode[]): NgTemplateDiagnostic<T>[];
+    /**
+     * Visit a TmplAstNode or AST node of the template. Authors should override this
+     * method to implement the check and return diagnostics.
+     */
+    abstract visitNode(ctx: TemplateContext, component: ts.ClassDeclaration, node: TmplAstNode | AST): NgTemplateDiagnostic<T>[];
 }

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

@@ -11,10 +11,114 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/src/ngtsc/typecheck/extended/api/api", ["require", "exports"], factory);
+        define("@angular/compiler-cli/src/ngtsc/typecheck/extended/api/api", ["require", "exports", "tslib", "@angular/compiler", "@angular/compiler/src/compiler"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TemplateCheckWithVisitor = void 0;
+    var tslib_1 = require("tslib");
+    var compiler_1 = require("@angular/compiler");
+    var compiler_2 = require("@angular/compiler/src/compiler");
+    /**
+     * This abstract class provides a base implementation for the run method.
+     */
+    var TemplateCheckWithVisitor = /** @class */ (function () {
+        function TemplateCheckWithVisitor() {
+        }
+        /**
+         * Base implementation for run function, visits all nodes in template and calls
+         * `visitNode()` for each one.
+         */
+        TemplateCheckWithVisitor.prototype.run = function (ctx, component, template) {
+            var visitor = new TemplateVisitor(ctx, component, this);
+            return visitor.getDiagnostics(template);
+        };
+        return TemplateCheckWithVisitor;
+    }());
+    exports.TemplateCheckWithVisitor = TemplateCheckWithVisitor;
+    /**
+     * Visits all nodes in a template (TmplAstNode and AST) and calls `visitNode` for each one.
+     */
+    var TemplateVisitor = /** @class */ (function (_super) {
+        tslib_1.__extends(TemplateVisitor, _super);
+        function TemplateVisitor(ctx, component, check) {
+            var _this = _super.call(this) || this;
+            _this.ctx = ctx;
+            _this.component = component;
+            _this.check = check;
+            _this.diagnostics = [];
+            return _this;
+        }
+        TemplateVisitor.prototype.visit = function (node, context) {
+            var _a;
+            (_a = this.diagnostics).push.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(this.check.visitNode(this.ctx, this.component, node))));
+            node.visit(this);
+        };
+        TemplateVisitor.prototype.visitAllNodes = function (nodes) {
+            var e_1, _a;
+            try {
+                for (var nodes_1 = tslib_1.__values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
+                    var node = nodes_1_1.value;
+                    this.visit(node);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        TemplateVisitor.prototype.visitAst = function (ast) {
+            if (ast instanceof compiler_2.ASTWithSource) {
+                ast = ast.ast;
+            }
+            this.visit(ast);
+        };
+        TemplateVisitor.prototype.visitElement = function (element) {
+            this.visitAllNodes(element.attributes);
+            this.visitAllNodes(element.inputs);
+            this.visitAllNodes(element.outputs);
+            this.visitAllNodes(element.references);
+            this.visitAllNodes(element.children);
+        };
+        TemplateVisitor.prototype.visitTemplate = function (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);
+        };
+        TemplateVisitor.prototype.visitContent = function (content) { };
+        TemplateVisitor.prototype.visitVariable = function (variable) { };
+        TemplateVisitor.prototype.visitReference = function (reference) { };
+        TemplateVisitor.prototype.visitTextAttribute = function (attribute) { };
+        TemplateVisitor.prototype.visitBoundAttribute = function (attribute) {
+            this.visitAst(attribute.value);
+        };
+        TemplateVisitor.prototype.visitBoundEvent = function (attribute) {
+            this.visitAst(attribute.handler);
+        };
+        TemplateVisitor.prototype.visitText = function (text) { };
+        TemplateVisitor.prototype.visitBoundText = function (text) {
+            this.visitAst(text.value);
+        };
+        TemplateVisitor.prototype.visitIcu = function (icu) { };
+        TemplateVisitor.prototype.getDiagnostics = function (template) {
+            this.diagnostics = [];
+            this.visitAllNodes(template);
+            return this.diagnostics;
+        };
+        return TemplateVisitor;
+    }(compiler_1.RecursiveAstVisitor));
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/extended/api/api.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;;IAEH,8CAAgS;IAChS,2DAA6D;IAiC7D;;OAEG;IACH;QAAA;QAmBA,CAAC;QAhBC;;;WAGG;QACH,sCAAG,GAAH,UAAI,GAAoB,EAAE,SAA8B,EACpD,QAAuB;YACzB,IAAM,OAAO,GAAG,IAAI,eAAe,CAAI,GAAG,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;YAC7D,OAAO,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;QAC1C,CAAC;QAQH,+BAAC;IAAD,CAAC,AAnBD,IAmBC;IAnBqB,4DAAwB;IAqB9C;;OAEG;IACH;QAAmD,2CAAmB;QAIpE,yBACqB,GAAoB,EAAmB,SAA8B,EACrE,KAAkC;YAFvD,YAGE,iBAAO,SACR;YAHoB,SAAG,GAAH,GAAG,CAAiB;YAAmB,eAAS,GAAT,SAAS,CAAqB;YACrE,WAAK,GAAL,KAAK,CAA6B;YAJvD,iBAAW,GAA8B,EAAE,CAAC;;QAM5C,CAAC;QAEQ,+BAAK,GAAd,UAAe,IAAqB,EAAE,OAAa;;YACjD,CAAA,KAAA,IAAI,CAAC,WAAW,CAAA,CAAC,IAAI,oDAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,IAAE;YAC/E,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACnB,CAAC;QAED,uCAAa,GAAb,UAAc,KAAoB;;;gBAChC,KAAmB,IAAA,UAAA,iBAAA,KAAK,CAAA,4BAAA,+CAAE;oBAArB,IAAM,IAAI,kBAAA;oBACb,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;iBAClB;;;;;;;;;QACH,CAAC;QAED,kCAAQ,GAAR,UAAS,GAAQ;YACf,IAAI,GAAG,YAAY,wBAAa,EAAE;gBAChC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;aACf;YACD,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAClB,CAAC;QAED,sCAAY,GAAZ,UAAa,OAAuB;YAClC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YACvC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YACnC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YACpC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YACvC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACvC,CAAC;QAED,uCAAa,GAAb,UAAc,QAAyB;YACrC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;YACxC,IAAI,QAAQ,CAAC,OAAO,KAAK,aAAa,EAAE;gBACtC,+EAA+E;gBAC/E,+EAA+E;gBAC/E,wFAAwF;gBACxF,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBACpC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;gBACrC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;aAC5C;YACD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;YACvC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;YACxC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACxC,CAAC;QACD,sCAAY,GAAZ,UAAa,OAAuB,IAAS,CAAC;QAC9C,uCAAa,GAAb,UAAc,QAAyB,IAAS,CAAC;QACjD,wCAAc,GAAd,UAAe,SAA2B,IAAS,CAAC;QACpD,4CAAkB,GAAlB,UAAmB,SAA+B,IAAS,CAAC;QAC5D,6CAAmB,GAAnB,UAAoB,SAAgC;YAClD,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QACD,yCAAe,GAAf,UAAgB,SAA4B;YAC1C,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QACnC,CAAC;QACD,mCAAS,GAAT,UAAU,IAAiB,IAAS,CAAC;QACrC,wCAAc,GAAd,UAAe,IAAsB;YACnC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;QACD,kCAAQ,GAAR,UAAS,GAAe,IAAS,CAAC;QAElC,wCAAc,GAAd,UAAe,QAAuB;YACpC,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;YACtB,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YAC7B,OAAO,IAAI,CAAC,WAAW,CAAC;QAC1B,CAAC;QACH,sBAAC;IAAD,CAAC,AAvED,CAAmD,8BAAmB,GAuErE","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 {AST, RecursiveAstVisitor, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstBoundText, TmplAstContent, TmplAstElement, TmplAstIcu, TmplAstNode, TmplAstRecursiveVisitor, TmplAstReference, TmplAstTemplate, TmplAstText, TmplAstTextAttribute, TmplAstVariable} from '@angular/compiler';\nimport {ASTWithSource} from '@angular/compiler/src/compiler';\nimport * as ts from 'typescript';\n\nimport {ErrorCode} from '../../../diagnostics';\nimport {NgTemplateDiagnostic, TemplateTypeChecker} from '../../api';\n\n/**\n * A Template Check receives information about the template it's checking and returns\n * information about the diagnostics to be generated.\n */\nexport interface TemplateCheck<T extends ErrorCode> {\n  /** Unique template check code, used for configuration and searching the error. */\n  code: T;\n\n  /** Runs check and returns information about the diagnostics to be generated. */\n  run(ctx: TemplateContext, component: ts.ClassDeclaration,\n      template: TmplAstNode[]): NgTemplateDiagnostic<T>[];\n}\n\n/**\n * The TemplateContext provided to a Template Check to get diagnostic information.\n */\nexport interface TemplateContext {\n  /** Interface that provides information about template nodes. */\n  templateTypeChecker: TemplateTypeChecker;\n\n  /**\n   * TypeScript interface that provides type information about symbols that appear\n   * in the template (it is not to query types outside the Angular component).\n   */\n  typeChecker: ts.TypeChecker;\n}\n\n/**\n * This abstract class provides a base implementation for the run method.\n */\nexport abstract class TemplateCheckWithVisitor<T extends ErrorCode> implements TemplateCheck<T> {\n  abstract code: T;\n\n  /**\n   * Base implementation for run function, visits all nodes in template and calls\n   * `visitNode()` for each one.\n   */\n  run(ctx: TemplateContext, component: ts.ClassDeclaration,\n      template: TmplAstNode[]): NgTemplateDiagnostic<T>[] {\n    const visitor = new TemplateVisitor<T>(ctx, component, this);\n    return visitor.getDiagnostics(template);\n  }\n\n  /**\n   * Visit a TmplAstNode or AST node of the template. Authors should override this\n   * method to implement the check and return diagnostics.\n   */\n  abstract visitNode(ctx: TemplateContext, component: ts.ClassDeclaration, node: TmplAstNode|AST):\n      NgTemplateDiagnostic<T>[];\n}\n\n/**\n * Visits all nodes in a template (TmplAstNode and AST) and calls `visitNode` for each one.\n */\nclass TemplateVisitor<T extends ErrorCode> extends RecursiveAstVisitor implements\n    TmplAstRecursiveVisitor {\n  diagnostics: NgTemplateDiagnostic<T>[] = [];\n\n  constructor(\n      private readonly ctx: TemplateContext, private readonly component: ts.ClassDeclaration,\n      private readonly check: TemplateCheckWithVisitor<T>) {\n    super();\n  }\n\n  override visit(node: AST|TmplAstNode, context?: any) {\n    this.diagnostics.push(...this.check.visitNode(this.ctx, this.component, node));\n    node.visit(this);\n  }\n\n  visitAllNodes(nodes: TmplAstNode[]) {\n    for (const node of nodes) {\n      this.visit(node);\n    }\n  }\n\n  visitAst(ast: AST) {\n    if (ast instanceof ASTWithSource) {\n      ast = ast.ast;\n    }\n    this.visit(ast);\n  }\n\n  visitElement(element: TmplAstElement) {\n    this.visitAllNodes(element.attributes);\n    this.visitAllNodes(element.inputs);\n    this.visitAllNodes(element.outputs);\n    this.visitAllNodes(element.references);\n    this.visitAllNodes(element.children);\n  }\n\n  visitTemplate(template: TmplAstTemplate) {\n    this.visitAllNodes(template.attributes);\n    if (template.tagName === 'ng-template') {\n      // Only visit input/outputs/templateAttrs if this isn't an inline template node\n      // generated for a structural directive (like `<div *ngIf></div>`). These nodes\n      // would be visited when the underlying element of an inline template node is processed.\n      this.visitAllNodes(template.inputs);\n      this.visitAllNodes(template.outputs);\n      this.visitAllNodes(template.templateAttrs);\n    }\n    this.visitAllNodes(template.variables);\n    this.visitAllNodes(template.references);\n    this.visitAllNodes(template.children);\n  }\n  visitContent(content: TmplAstContent): void {}\n  visitVariable(variable: TmplAstVariable): void {}\n  visitReference(reference: TmplAstReference): void {}\n  visitTextAttribute(attribute: TmplAstTextAttribute): void {}\n  visitBoundAttribute(attribute: TmplAstBoundAttribute): void {\n    this.visitAst(attribute.value);\n  }\n  visitBoundEvent(attribute: TmplAstBoundEvent): void {\n    this.visitAst(attribute.handler);\n  }\n  visitText(text: TmplAstText): void {}\n  visitBoundText(text: TmplAstBoundText): void {\n    this.visitAst(text.value);\n  }\n  visitIcu(icu: TmplAstIcu): void {}\n\n  getDiagnostics(template: TmplAstNode[]): NgTemplateDiagnostic<T>[] {\n    this.diagnostics = [];\n    this.visitAllNodes(template);\n    return this.diagnostics;\n  }\n}\n"]}

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

@@ -0,0 +1,22 @@
+/**
+ * @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/invalid_banana_in_box" />
+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 two-way binding syntax is correct.
+ * Parentheses should be inside the brackets "[()]".
+ * Will return diagnostic information when "([])" is found.
+ */
+export declare class InvalidBananaInBoxCheck extends TemplateCheckWithVisitor<ErrorCode.INVALID_BANANA_IN_BOX> {
+    code: ErrorCode.INVALID_BANANA_IN_BOX;
+    visitNode(ctx: TemplateContext, component: ts.ClassDeclaration, node: TmplAstNode | AST): NgTemplateDiagnostic<ErrorCode.INVALID_BANANA_IN_BOX>[];
+}

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

@@ -0,0 +1,52 @@
+/**
+ * @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/invalid_banana_in_box", ["require", "exports", "tslib", "@angular/compiler", "typescript", "@angular/compiler-cli/src/ngtsc/diagnostics", "@angular/compiler-cli/src/ngtsc/typecheck/extended/api"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.InvalidBananaInBoxCheck = 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/extended/api");
+    /**
+     * Ensures the two-way binding syntax is correct.
+     * Parentheses should be inside the brackets "[()]".
+     * Will return diagnostic information when "([])" is found.
+     */
+    var InvalidBananaInBoxCheck = /** @class */ (function (_super) {
+        tslib_1.__extends(InvalidBananaInBoxCheck, _super);
+        function InvalidBananaInBoxCheck() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.code = diagnostics_1.ErrorCode.INVALID_BANANA_IN_BOX;
+            return _this;
+        }
+        InvalidBananaInBoxCheck.prototype.visitNode = function (ctx, component, node) {
+            if (!(node instanceof compiler_1.TmplAstBoundEvent))
+                return [];
+            var name = node.name;
+            if (!name.startsWith('[') || !name.endsWith(']'))
+                return [];
+            var boundSyntax = node.sourceSpan.toString();
+            var expectedBoundSyntax = boundSyntax.replace("(" + name + ")", "[(" + name.slice(1, -1) + ")]");
+            var diagnostic = ctx.templateTypeChecker.makeTemplateDiagnostic(component, node.sourceSpan, ts.DiagnosticCategory.Warning, diagnostics_1.ErrorCode.INVALID_BANANA_IN_BOX, "In the two-way binding syntax the parentheses should be inside the brackets, ex. '" + expectedBoundSyntax + "'. \n        Find more at https://angular.io/guide/two-way-binding");
+            return [diagnostic];
+        };
+        return InvalidBananaInBoxCheck;
+    }(api_1.TemplateCheckWithVisitor));
+    exports.InvalidBananaInBoxCheck = InvalidBananaInBoxCheck;
+});
+//# sourceMappingURL=data:application/json;base64,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

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/src/extended_template_checker.d.ts

@@ -11,9 +11,8 @@ import { ErrorCode } from '../../../diagnostics';
 import { TemplateDiagnostic, TemplateTypeChecker } from '../../api';
 import { ExtendedTemplateChecker, TemplateCheck } from '../api';
 export declare class ExtendedTemplateCheckerImpl implements ExtendedTemplateChecker {
-    private readonly templateTypeChecker;
-    private readonly typeChecker;
     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

@@ -20,13 +20,12 @@
     var tslib_1 = require("tslib");
     var ExtendedTemplateCheckerImpl = /** @class */ (function () {
         function ExtendedTemplateCheckerImpl(templateTypeChecker, typeChecker, templateChecks) {
-            this.templateTypeChecker = templateTypeChecker;
-            this.typeChecker = typeChecker;
             this.templateChecks = templateChecks;
+            this.ctx = { templateTypeChecker: templateTypeChecker, typeChecker: typeChecker };
         }
         ExtendedTemplateCheckerImpl.prototype.getDiagnosticsForComponent = function (component) {
             var e_1, _a;
-            var template = this.templateTypeChecker.getTemplate(component);
+            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.
@@ -34,15 +33,10 @@
                 return [];
             }
             var diagnostics = [];
-            var ctx = {
-                templateTypeChecker: this.templateTypeChecker,
-                typeChecker: this.typeChecker,
-                component: component
-            };
             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(deduplicateDiagnostics(check.run(ctx, template)))));
+                    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 }; }
@@ -57,69 +51,5 @@
         return ExtendedTemplateCheckerImpl;
     }());
     exports.ExtendedTemplateCheckerImpl = ExtendedTemplateCheckerImpl;
-    // 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) {
-        var e_2, _a;
-        var result = [];
-        var _loop_1 = function (newDiag) {
-            var isDuplicateDiag = result.some(function (existingDiag) { return areDiagnosticsEqual(newDiag, existingDiag); });
-            if (!isDuplicateDiag) {
-                result.push(newDiag);
-            }
-        };
-        try {
-            for (var diagnostics_1 = tslib_1.__values(diagnostics), diagnostics_1_1 = diagnostics_1.next(); !diagnostics_1_1.done; diagnostics_1_1 = diagnostics_1.next()) {
-                var newDiag = diagnostics_1_1.value;
-                _loop_1(newDiag);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (diagnostics_1_1 && !diagnostics_1_1.done && (_a = diagnostics_1.return)) _a.call(diagnostics_1);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        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;
-    }
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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