Elgato_dark/angular
1
0
Fork 0
mirror of https://github.com/angular/angular synced 2026-05-24 09:28:37 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
angular/goldens/public-api/compiler-cli/error_code.api.md

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

126 lines
4.5 KiB
Markdown
Raw Normal View History

build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
## API Report File for "angular-srcs"
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
```ts
// @public (undocumented)
export enum ErrorCode {
feat(compiler-cli): initial implementation of standalone components (#44812) This commit implements the first phase of standalone components in the Angular compiler. This mainly includes the scoping rules for standalone components (`@Component({imports})`). Significant functionality from the design is _not_ implemented by this PR, including: * imports of standalone components into NgModules. * the provider aspect of standalone components Future commits will address these issues, as we proceed with the design of this feature. PR Close #44812
2022-01-10 19:57:41 +00:00
COMPONENT_IMPORT_NOT_STANDALONE = 2011,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
COMPONENT_INVALID_SHADOW_DOM_SELECTOR = 2009,
feat(core): support styles and styleUrl as strings (#51715) Adds support for passing in `@Component.styles` as a string. Also introduces a new `styleUrl` property on `@Component` for providing a single stylesheet. This is more convenient for the most common case where a component only has one stylesheet associated with it. PR Close #51715
2023-09-11 11:56:37 +00:00
COMPONENT_INVALID_STYLE_URLS = 2021,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
// (undocumented)
COMPONENT_MISSING_TEMPLATE = 2001,
feat(compiler-cli): initial implementation of standalone components (#44812) This commit implements the first phase of standalone components in the Angular compiler. This mainly includes the scoping rules for standalone components (`@Component({imports})`). Significant functionality from the design is _not_ implemented by this PR, including: * imports of standalone components into NgModules. * the provider aspect of standalone components Future commits will address these issues, as we proceed with the design of this feature. PR Close #44812
2022-01-10 19:57:41 +00:00
COMPONENT_NOT_STANDALONE = 2010,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
COMPONENT_RESOURCE_NOT_FOUND = 2008,
refactor(compiler): add support for internal `deferredImports` field (#53591) This commit updates the logic to add support for internal `deferredImports` field in compiler. PR Close #53591
2023-12-15 20:03:01 +00:00
COMPONENT_UNKNOWN_DEFERRED_IMPORT = 2022,
feat(compiler-cli): initial implementation of standalone components (#44812) This commit implements the first phase of standalone components in the Angular compiler. This mainly includes the scoping rules for standalone components (`@Component({imports})`). Significant functionality from the design is _not_ implemented by this PR, including: * imports of standalone components into NgModules. * the provider aspect of standalone components Future commits will address these issues, as we proceed with the design of this feature. PR Close #44812
2022-01-10 19:57:41 +00:00
COMPONENT_UNKNOWN_IMPORT = 2012,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
// (undocumented)
refactor(compiler-cli): add validation to extended template diagnostics configuration (#44391) Refs #42966. This validates the `tsconfig.json` options for extended template diagnostics. It verifies: * `strictTemplates` must be enabled if `extendedDiagnostics` have any explicit configuration. * `extendedDiagnostics.defaultCategory` must be a valid `DiagnosticCategoryLabel`. * `extendedDiagnostics.checks` keys must all be real diagnostics. * `extendedDiagnostics.checks` values must all be valid `DiagnosticCategoryLabel`s. These include new error codes, each of which prints out the exact property that was the issue and what the available options are to fix them. It does disallow the config: ```json { "angularCompilerOptions": { "strictTemplates": false, "extendedDiagnostics": { "defaultCategory": "suppress" } } } ``` Such a configuration is technically valid and could be executed, but will be rejected by this verification logic. There isn't much reason to ever do this, since users could just drop `extendedDiagnostics` altogether and get the intended effect. This is unlikely to be a significant issue for users, so it is considered invalid for now to keep the implementation simple. PR Close #44391
2021-12-04 03:17:30 +00:00
CONFIG_EXTENDED_DIAGNOSTICS_IMPLIES_STRICT_TEMPLATES = 4003,
// (undocumented)
CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CATEGORY_LABEL = 4004,
// (undocumented)
CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CHECK = 4005,
// (undocumented)
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
CONFIG_FLAT_MODULE_NO_INDEX = 4001,
// (undocumented)
CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK = 4002,
refactor(compiler): introduce compiler infrastructure for input transforms (#50225) Adds the necessary compiler changes to support input transform functions. The compiler output has changed in the following ways: ### Directive handler The directive handler now extracts a reference to the input transform function and it resolves the type of its first parameter. It also asserts that the type can be referenced in the compiled output and that it doesn't clash with any pre-existing `ngAcceptInputType_` members. ### .d.ts In the generated declaration files the compiler now inserts an `ngAcceptInputType_` member for each input with a `transform` function. The member's type corresponds to the type of the first parameter of the function, e.g. ```typescript // foo.directive.ts @Directive() export class Foo { @Input({transform: (incomingValue: string) => parseInt(incomingValue)}) value: number; } // foo.directive.d.ts export class Foo { value: number; static ngAcceptInputType_value: string; } ``` ### Type check block If an input has `transform` function, the TCB will use the type of its first parameter for the setter type. This uses the same infrastructure as the `ngAcceptInputType_` members. ### Directive declaration The generated runtime directive declaration call now includes the `transform` function in the `inputs` map, if the input is being transformed. The function will be picked up by the runtime in the next commit to do the actual transformation. ```typescript // foo.directive.ts @Directive() export class Foo { @Input({transform: (incomingValue: string) => parseInt(incomingValue)}) value: number; } // foo.directive.js export class Foo { ɵdir = ɵɵdefineDirective({ inputs: { value: ['value', 'value', incomingValue => parseInt(incomingValue)] } }); } ``` PR Close #50225
2023-05-10 07:37:57 +00:00
CONFLICTING_INPUT_TRANSFORM = 2020,
fix(compiler-cli): flag all conflicts between let declarations and local symbols (#56752) Expands the check around conflicting `@let` declarations to also cover template variables and local references. PR Close #56752
2024-06-28 12:35:54 +00:00
CONFLICTING_LET_DECLARATION = 8017,
fix(compiler-cli): add diagnostic for control flow that prevents content projection (#53190) This is a follow-up to the fix from #52414. It adds a diagnostic that will tell users when a control flow is preventing its direct descendants from being projected into a specific component slot. PR Close #53190
2023-11-27 09:29:20 +00:00
CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION = 8011,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
// (undocumented)
test: add the error code of ngc/ngtsc under api guard (#35067) We should not change these error code without a good reason, so they should be guarded. PR Close #35067
2020-01-30 21:04:17 +00:00
DECORATOR_ARG_NOT_LITERAL = 1001,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
// (undocumented)
test: add the error code of ngc/ngtsc under api guard (#35067) We should not change these error code without a good reason, so they should be guarded. PR Close #35067
2020-01-30 21:04:17 +00:00
DECORATOR_ARITY_WRONG = 1002,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
DECORATOR_COLLISION = 1006,
// (undocumented)
test: add the error code of ngc/ngtsc under api guard (#35067) We should not change these error code without a good reason, so they should be guarded. PR Close #35067
2020-01-30 21:04:17 +00:00
DECORATOR_NOT_CALLED = 1003,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
// (undocumented)
test: add the error code of ngc/ngtsc under api guard (#35067) We should not change these error code without a good reason, so they should be guarded. PR Close #35067
2020-01-30 21:04:17 +00:00
DECORATOR_UNEXPECTED = 1005,
refactor(compiler): add support for internal `deferredImports` field (#53591) This commit updates the logic to add support for internal `deferredImports` field in compiler. PR Close #53591
2023-12-15 20:03:01 +00:00
DEFERRED_DEPENDENCY_IMPORTED_EAGERLY = 8014,
DEFERRED_DIRECTIVE_USED_EAGERLY = 8013,
DEFERRED_PIPE_USED_EAGERLY = 8012,
test: add the error code of ngc/ngtsc under api guard (#35067) We should not change these error code without a good reason, so they should be guarded. PR Close #35067
2020-01-30 21:04:17 +00:00
DIRECTIVE_INHERITS_UNDECORATED_CTOR = 2006,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
// (undocumented)
DIRECTIVE_MISSING_SELECTOR = 2004,
fix(compiler-cli): Produce fatal diagnostic on duplicate decorated properties (#60376) This prevents the compilation and language service from crashing. fixes https://github.com/angular/vscode-ng-language-service/issues/2091 PR Close #60376
2025-03-13 18:01:14 +00:00
// (undocumented)
DUPLICATE_DECORATED_PROPERTIES = 1012,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
DUPLICATE_VARIABLE_DECLARATION = 8006,
test: add the error code of ngc/ngtsc under api guard (#35067) We should not change these error code without a good reason, so they should be guarded. PR Close #35067
2020-01-30 21:04:17 +00:00
HOST_BINDING_PARSE_ERROR = 5001,
refactor(compiler): add support for host directives (#46868) This is the compile-time implementation of the `hostDirectives` feature plus a little bit of runtime code to illustrate how the newly-generated code will plug into the runtime. It works by creating a call to the new `ɵɵHostDirectivesFeature` feature whenever a directive has a `hostDirectives` field. Afterwards `ɵɵHostDirectivesFeature` will patch a new function onto the directive definition that will be invoked during directive matching. For example, if we take the following definition: ```ts @Directive({ hostDirectives: [HostA, {directive: HostB, inputs: ['input: alias']}] }) class MyDir {} ``` Will compile to: ```js MyDir.ɵdir = ɵɵdefineComponent({ features: [ɵɵHostDirectivesFeature([HostA, { directive: HostB, inputs: { input: "alias" } }])] }); ``` The template type checking is implemented during directive matching by adding the host directives applied on the host to the array of matched directives whenever the host is matched in a template. Relates to #8785. PR Close #46868
2022-07-22 11:33:09 +00:00
HOST_DIRECTIVE_COMPONENT = 2015,
fix(compiler-cli): implement more host directive validations as diagnostics (#47768) Implements more of the runtime validations for host directives as compiler diagnostics so that they can be caught earlier. Also does some minor cleanup. PR Close #47768
2022-10-14 08:01:07 +00:00
HOST_DIRECTIVE_CONFLICTING_ALIAS = 2018,
refactor(compiler): add support for host directives (#46868) This is the compile-time implementation of the `hostDirectives` feature plus a little bit of runtime code to illustrate how the newly-generated code will plug into the runtime. It works by creating a call to the new `ɵɵHostDirectivesFeature` feature whenever a directive has a `hostDirectives` field. Afterwards `ɵɵHostDirectivesFeature` will patch a new function onto the directive definition that will be invoked during directive matching. For example, if we take the following definition: ```ts @Directive({ hostDirectives: [HostA, {directive: HostB, inputs: ['input: alias']}] }) class MyDir {} ``` Will compile to: ```js MyDir.ɵdir = ɵɵdefineComponent({ features: [ɵɵHostDirectivesFeature([HostA, { directive: HostB, inputs: { input: "alias" } }])] }); ``` The template type checking is implemented during directive matching by adding the host directives applied on the host to the array of matched directives whenever the host is matched in a template. Relates to #8785. PR Close #46868
2022-07-22 11:33:09 +00:00
HOST_DIRECTIVE_INVALID = 2013,
feat(compiler): add support for compile-time required inputs (#49468) Adds support for marking a directive input as required. During template type checking, the compiler will verify that all required inputs have been specified and will raise a diagnostic if one or more are missing. Some specifics: * Inputs are marked as required by passing an object literal with a `required: true` property to the `Input` decorator or into the `inputs` array. * Required inputs imply that the directive can't work without them. This is why there's a new check that enforces that all required inputs of a host directive are exposed on the host. * Required input diagnostics are reported through the `OutOfBandDiagnosticRecorder`, rather than generating a new structure in the TCB, because it allows us to provide a better error message. * Currently required inputs are only supported during AOT compilation, because knowing which bindings are present during JIT can be tricky and may lead to increased bundle sizes. Fixes #37706. PR Close #49468
2023-03-17 19:15:08 +00:00
HOST_DIRECTIVE_MISSING_REQUIRED_BINDING = 2019,
refactor(compiler): add support for host directives (#46868) This is the compile-time implementation of the `hostDirectives` feature plus a little bit of runtime code to illustrate how the newly-generated code will plug into the runtime. It works by creating a call to the new `ɵɵHostDirectivesFeature` feature whenever a directive has a `hostDirectives` field. Afterwards `ɵɵHostDirectivesFeature` will patch a new function onto the directive definition that will be invoked during directive matching. For example, if we take the following definition: ```ts @Directive({ hostDirectives: [HostA, {directive: HostB, inputs: ['input: alias']}] }) class MyDir {} ``` Will compile to: ```js MyDir.ɵdir = ɵɵdefineComponent({ features: [ɵɵHostDirectivesFeature([HostA, { directive: HostB, inputs: { input: "alias" } }])] }); ``` The template type checking is implemented during directive matching by adding the host directives applied on the host to the array of matched directives whenever the host is matched in a template. Relates to #8785. PR Close #46868
2022-07-22 11:33:09 +00:00
HOST_DIRECTIVE_NOT_STANDALONE = 2014,
fix(compiler-cli): implement more host directive validations as diagnostics (#47768) Implements more of the runtime validations for host directives as compiler diagnostics so that they can be caught earlier. Also does some minor cleanup. PR Close #47768
2022-10-14 08:01:07 +00:00
HOST_DIRECTIVE_UNDEFINED_BINDING = 2017,
refactor(compiler): implement template type checking for tracking expressions (#51690) Adds support for template type checking of the `track` expression of a `for` loop block. Tracking expressions are treated as any other expression for type checking, however we have some special validation that doesn't allow them to access template variables and local references. PR Close #51690
2023-09-07 11:49:12 +00:00
ILLEGAL_FOR_LOOP_TRACK_ACCESS = 8009,
refactor(compiler-cli): integrate let declarations into the template type checker (#56199) Integrates let declarations into the template type checker by producing corresponding constants in the TCB. This also includes a couple of custom diagnostics to flag usages of let before they're declared and illegal writes to let declarations. We can't rely on TS for these checks, because it includes the variable name in the diagnostic. PR Close #56199
2024-05-03 07:58:40 +00:00
ILLEGAL_LET_WRITE = 8015,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
IMPORT_CYCLE_DETECTED = 3003,
refactor(compiler-cli): improve DX for reference emit failures (#44587) In certain scenarios, the compiler may have crashed with an `Unable to write a reference` error which would be particularly hard to diagnose. One of the primary reasons for this failure is when the `rootDir` option is configured---typically the case for libraries--- and a source file is imported using a relative import from an external entry-point. This would normally report TS6059 for the invalid relative import, but the crash prevents this error from being surfaced. This commit refactors the reference emit logic to result in an explicit `Failure` state with a reason as to why the failure occurred. This state is then used to report a `FatalDiagnosticException`, preventing a hard crash. Closes #44414 PR Close #44587
2021-12-29 22:11:18 +00:00
IMPORT_GENERATION_FAILURE = 3004,
fix(compiler): add diagnostic for inaccessible deferred trigger (#51922) If a trigger element can't be accessed from the defer block, we don't generate any instructions for it. These changes add a diagnostic that will surface the error to users. PR Close #51922
2023-09-27 08:00:24 +00:00
INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT = 8010,
refactor(compiler-cli): additional diagnostics for signal-based queries (#54019) This commit introduces three additional diagnostics for queries: - If a query (either using decorator or signal-based) is declared on a static class member, a diagnostic is raised. - If a signal-based query is mixed with a query decorator, a diagnostic is raised. Similar to signal inputs. - If a singal-based query is also declared in the directive/component class decorator metadata, a diagnostic is raised. PR Close #54019
2024-01-22 12:57:09 +00:00
INCORRECTLY_DECLARED_ON_STATIC_MEMBER = 1100,
INITIALIZER_API_DECORATOR_METADATA_COLLISION = 1051,
refactor(compiler-cli): support enforcing field access for initializer APIs (#54981) An initializer API like `input`, `output`, or signal queries may not be compatible with certain access levels. E.g. queries cannot work with ES private class fields. This commit introduces a check for access levels into the initializer API recognition— enforcing that every initializer API *clearly* specifies what type of access is allowed. PR Close #54981
2024-03-21 16:05:34 +00:00
INITIALIZER_API_DISALLOWED_MEMBER_VISIBILITY = 1053,
refactor(compiler-cli): detect `output()` function (#54217) As we are introducing the new `output()` function as an inituive alternative to `@Output()` that matches with signal-based inputs, this commit prepares the compiler to detect such initializer-based outputs. PR Close #54217
2024-02-02 14:26:52 +00:00
INITIALIZER_API_NO_REQUIRED_FUNCTION = 1052,
refactor(compiler-cli): additional diagnostics for signal-based queries (#54019) This commit introduces three additional diagnostics for queries: - If a query (either using decorator or signal-based) is declared on a static class member, a diagnostic is raised. - If a signal-based query is mixed with a query decorator, a diagnostic is raised. Similar to signal inputs. - If a singal-based query is also declared in the directive/component class decorator metadata, a diagnostic is raised. PR Close #54019
2024-01-22 12:57:09 +00:00
INITIALIZER_API_WITH_DISALLOWED_DECORATOR = 1050,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
INJECTABLE_DUPLICATE_PROV = 9001,
fix(compiler-cli): exclude abstract classes from `strictInjectionParameters` requirement (#44615) In AOT compilations, the `strictInjectionParameters` compiler option can be enabled to report errors when an `@Injectable` annotated class has a constructor with parameters that do not provide an injection token, e.g. only a primitive type or interface. Since Ivy it's become required that any class with Angular behavior (e.g. the `ngOnDestroy` lifecycle hook) is decorated using an Angular decorator, which meant that `@Injectable()` may need to have been added to abstract base classes. Doing so would then report an error if `strictInjectionParameters` is enabled, if the abstract class has an incompatible constructor for DI purposes. This may be fine though, as a subclass may call the constructor explicitly without relying on Angular's DI mechanism. Therefore, this commit excludes abstract classes from the `strictInjectionParameters` check. This avoids an error from being reported at compile time. If the constructor ends up being used by Angular's DI system at runtime, then the factory function of the abstract class will throw an error by means of the `ɵɵinvalidFactory` instruction. In addition to the runtime error, this commit also analyzes the inheritance chain of an injectable without a constructor to verify that their inherited constructor is valid. BREAKING CHANGE: Invalid constructors for DI may now report compilation errors When a class inherits its constructor from a base class, the compiler may now report an error when that constructor cannot be used for DI purposes. This may either be because the base class is missing an Angular decorator such as `@Injectable()` or `@Directive()`, or because the constructor contains parameters which do not have an associated token (such as primitive types like `string`). These situations used to behave unexpectedly at runtime, where the class may be constructed without any of its constructor parameters, so this is now reported as an error during compilation. Any new errors that may be reported because of this change can be resolved either by decorating the base class from which the constructor is inherited, or by adding an explicit constructor to the class for which the error is reported. Closes #37914 PR Close #44615
2022-01-04 18:03:30 +00:00
INJECTABLE_INHERITS_INVALID_CONSTRUCTOR = 2016,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
INLINE_TCB_REQUIRED = 8900,
INLINE_TYPE_CTOR_REQUIRED = 8901,
feat(core): Provide a diagnostic for missing Signal invocation in template interpolation. (#49660) To improve DX for beginners, this commit adds an extended diagnostic for Signals in template interpolations. PR Close #49660
2023-03-31 16:22:28 +00:00
INTERPOLATED_SIGNAL_NOT_INVOKED = 8109,
refactor(compiler-cli): add `BananaInBoxCheck` to the template checks (#42984) Add the implementation of a Template Check that ensures the correct use of two-way binding syntax. Generates a warning when '([foo])="bar"' is found instead of '[(foo)]="bar"'. Refs #42966 PR Close #42984
2021-07-26 18:21:46 +00:00
INVALID_BANANA_IN_BOX = 8101,
refactor(compiler-cli): integrate let declarations into the template type checker (#56199) Integrates let declarations into the template type checker by producing corresponding constants in the TCB. This also includes a couple of custom diagnostics to flag usages of let before they're declared and illegal writes to let declarations. We can't rely on TS for these checks, because it includes the variable name in the diagnostic. PR Close #56199
2024-05-03 07:58:40 +00:00
LET_USED_BEFORE_DEFINITION = 8016,
refactor(compiler-cli): upgrade error codes and messages for unresolved symbol errors in local compilation mode (#54230) A single error code is created to unify the common error pattern in local compilation mode where an imported const cannot be resolved, but needs to be resolved. This mainly happens for Angular decorator fields such as @Component.template. The error messages are also upgraded to be more centered around this unifying theme. PR Close #54230
2024-02-03 06:36:19 +00:00
LOCAL_COMPILATION_UNRESOLVED_CONST = 11001,
refactor(compiler-cli): use a more generic error for unsupported expressions in local compilation mode (#54366) A new error code `LOCAL_COMPILATION_UNSUPPORTED_EXPRESSION` is added for this purpose, replacing a narrow one. PR Close #54366
2024-02-09 16:00:19 +00:00
LOCAL_COMPILATION_UNSUPPORTED_EXPRESSION = 11003,
feat(compiler-cli): detect missing control flow directive imports in standalone components (#46146) This commit adds an extended diagnostics check that verifies that all control flow directives (such as `ngIf`, `ngFor`) have the necessary directives imported in standalone components. Currently there is no diagnostics produced for such cases, which makes it harder to detect and find problems. PR Close #46146
2022-05-25 23:58:13 +00:00
MISSING_CONTROL_FLOW_DIRECTIVE = 8103,
feat(compiler): Add extended diagnostic to warn when missing let on ngForOf (#46683) In the case that a user accidentally forgot the let keyword, they dont get a very clear indicator of there being a problem. They get an issue in the template iteration at runtime. This diagnostic will warn the user when the let keyword is missing. PR Close #46683
2022-07-02 00:07:34 +00:00
MISSING_NGFOROF_LET = 8105,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
MISSING_PIPE = 8004,
MISSING_REFERENCE_TARGET = 8003,
feat(compiler): add support for compile-time required inputs (#49468) Adds support for marking a directive input as required. During template type checking, the compiler will verify that all required inputs have been specified and will raise a diagnostic if one or more are missing. Some specifics: * Inputs are marked as required by passing an object literal with a `required: true` property to the `Input` decorator or into the `inputs` array. * Required inputs imply that the directive can't work without them. This is why there's a new check that enforces that all required inputs of a host directive are exposed on the host. * Required input diagnostics are reported through the `OutOfBandDiagnosticRecorder`, rather than generating a new structure in the TCB, because it allows us to provide a better error message. * Currently required inputs are only supported during AOT compilation, because knowing which bindings are present during JIT can be tricky and may lead to increased bundle sizes. Fixes #37706. PR Close #49468
2023-03-17 19:15:08 +00:00
MISSING_REQUIRED_INPUTS = 8008,
fix(core): throw if standalone components are present in `@NgModule.bootstrap` (#45825) This commit updates the logic to detect a situation when a standalone component is used in the NgModule-based bootstrap (`@NgModule.bootstrap`). Both AOT and JIT compilers are updated to handle this situation. PR Close #45825
2022-04-30 01:00:05 +00:00
NGMODULE_BOOTSTRAP_IS_STANDALONE = 6009,
feat(compiler-cli): initial implementation of standalone components (#44812) This commit implements the first phase of standalone components in the Angular compiler. This mainly includes the scoping rules for standalone components (`@Component({imports})`). Significant functionality from the design is _not_ implemented by this PR, including: * imports of standalone components into NgModules. * the provider aspect of standalone components Future commits will address these issues, as we proceed with the design of this feature. PR Close #44812
2022-01-10 19:57:41 +00:00
NGMODULE_DECLARATION_IS_STANDALONE = 6008,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
NGMODULE_DECLARATION_NOT_UNIQUE = 6007,
test: add the error code of ngc/ngtsc under api guard (#35067) We should not change these error code without a good reason, so they should be guarded. PR Close #35067
2020-01-30 21:04:17 +00:00
NGMODULE_INVALID_DECLARATION = 6001,
NGMODULE_INVALID_EXPORT = 6003,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
NGMODULE_INVALID_IMPORT = 6002,
test: add the error code of ngc/ngtsc under api guard (#35067) We should not change these error code without a good reason, so they should be guarded. PR Close #35067
2020-01-30 21:04:17 +00:00
NGMODULE_INVALID_REEXPORT = 6004,
NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC = 6005,
NGMODULE_REEXPORT_NAME_COLLISION = 6006,
feat(compiler-cli): 'strictStandalone' flag enforces standalone (#57935) Add the `strictStandalone` flag to `angularCompilerOptions`. When set to true, the compiler will require that all declarations of components, directive, and pipes be standalone. When `standalone: false` is provided, an error is raised. Note that until the default value of the standalone flag is flipped, this does not catch the case where a declaration does not specify a value for `standalone`. The default value of the `strictStandalone` flag is `false`. PR Close #57935
2024-09-23 22:20:57 +00:00
NON_STANDALONE_NOT_ALLOWED = 2023,
refactor(compiler-cli): add `NullishCoalescingNotNullableCheck` (#43232) Add a template check that returns diagnostics if the left side of a nullish coalescing operation is not nullable. Refs #42966 PR Close #43232
2021-08-13 19:46:00 +00:00
NULLISH_COALESCING_NOT_NULLABLE = 8102,
feat(compiler-cli): add extended diagnostic for non-nullable optional chains (#46686) This commit adds an extended diagnostics check that is similar to the nullish coalescing check, but targeting optional chains. If the receiver expression of the optional chain is non-nullable, then the extended diagnostic can report an error or warning that can be fixed by changing the optional chain into a regular access. Closes #44870 PR Close #46686
2022-07-02 16:25:42 +00:00
OPTIONAL_CHAIN_NOT_NULLABLE = 8107,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
// (undocumented)
PARAM_MISSING_TOKEN = 2003,
// (undocumented)
PIPE_MISSING_NAME = 2002,
test: add the error code of ngc/ngtsc under api guard (#35067) We should not change these error code without a good reason, so they should be guarded. PR Close #35067
2020-01-30 21:04:17 +00:00
SCHEMA_INVALID_ATTRIBUTE = 8002,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
SCHEMA_INVALID_ELEMENT = 8001,
feat(compiler-cli): Add an extended diagnostic for `nSkipHydration` (#49512) This diagnostic ensures that the special attribute `ngSkipHydration` is not a binding and has no other value than `"true"` or an empty value. Fixes #49501 PR Close #49512
2023-03-21 12:24:08 +00:00
SKIP_HYDRATION_NOT_STATIC = 8108,
fix(compiler-cli): check split two way binding (#42601) Check for split two way binding when output is not declared to make error message clearer. PR Close #42601
2021-06-22 15:48:27 +00:00
SPLIT_TWO_WAY_BINDING = 8007,
feat(compiler): warn when style suffixes are used with attribute bindings (#46651) This commit adds an extended diagnostic which warns when style suffixes such as '.px' are used with attribute bindings (attr.width.px). Fixes #36256 PR Close #46651
2022-06-30 20:10:34 +00:00
SUFFIX_NOT_SUPPORTED = 8106,
fix(language-service): show suggestion when type inference is suboptimal (#41072) The Ivy Language Service uses the compiler's template type-checking engine, which honors the configuration in the user's tsconfig.json. We recommend that users upgrade to `strictTemplates` mode in their projects to take advantage of the best possible type inference, and thus to have the best experience in Language Service. If a project is not using `strictTemplates`, then the compiler will not leverage certain type inference options it has. One case where this is very noticeable is the inference of let- variables for structural directives that provide a template context guard (such as NgFor). Without `strictTemplates`, these guards will not be applied and such variables will be inferred as 'any', degrading the user experience within Language Service. This is working as designed, since the Language Service _should_ reflect types exactly as the compiler sees them. However, the View Engine Language Service used its own type system that _would_ infer these types even when the compiler did not. As a result, it's confusing to some users why the Ivy Language Service has "worse" type inference. To address this confusion, this commit implements a suggestion diagnostic which is shown in the Language Service for variables which could have been narrowed via a context guard, but the type checking configuration didn't allow it. This should make the reason why variables receive the 'any' type as well as the action needed to improve the typings much more obvious, improving the Language Service experience. Fixes angular/vscode-ng-language-service#1155 Closes #41042 PR Close #41072
2021-03-03 23:06:21 +00:00
SUGGEST_STRICT_TEMPLATES = 10001,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
SUGGEST_SUBOPTIMAL_TYPE_INFERENCE = 10002,
// (undocumented)
SYMBOL_NOT_EXPORTED = 3001,
TEMPLATE_PARSE_ERROR = 5002,
feat(compiler): Add extended diagnostic to warn when text attributes are intended to be bindings (#46161) https://angular.io/guide/attribute-binding#attribute-class-and-style-bindings Angular supports `attr.`, `style.`, and `class.` binding prefixes to bind attributes, styles, and classes. If the key does not have the binding syntax `[]` or the value does not have an interpolation `{{}}`, the attribute will not be interpreted as a binding. This diagnostic warns the user when the attributes listed above will not be interpreted as bindings. resolves #46137 PR Close #46161
2022-05-26 20:12:31 +00:00
TEXT_ATTRIBUTE_NOT_BINDING = 8104,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
UNDECORATED_CLASS_USING_ANGULAR_FEATURES = 2007,
UNDECORATED_PROVIDER = 2005,
feat(compiler): Add extended diagnostic to warn when there are uncalled functions in event bindings (#56295) (#56295) The diagnostic will catch issues like: ```html <button (click)="increment"></button> <button (click)="increment; decrement"></button> <button (click)="true ? increment : decrement"></button> <button (click)="nested.nested1.nested2.increment"></button> ``` PR Close #56295 (cherry picked from commit fd6cd0422d2d761d2c6cc0cd41838fbba8a3f010) PR Close #56295
2024-06-05 23:57:09 +00:00
UNINVOKED_FUNCTION_IN_EVENT_BINDING = 8111,
feat(compiler): add extended diagnostic for uninvoked track function on @for blocks (#60495) The compiler will warn devs when they haven't invoked the track function passed to track in @for blocks PR Close #60495
2025-03-20 20:02:05 +00:00
UNINVOKED_TRACK_FUNCTION = 8115,
feat(compiler-cli): add extended diagnostic for invalid nullish coalescing (#60279) The semantics for nullish coalescing (`??`) in Javascript/Typescript differ slightly from the semantics in Angular templates. Mixing nullish coalescing with logical and/or without parentheses is an error in Javascript. This PR adds an extended diagnostic that can be enabled to treat it as an error in Angular templates as well. PR Close #60279
2025-03-07 17:28:41 +00:00
UNPARENTHESIZED_NULLISH_COALESCING = 8114,
fix(compiler-cli): add diagnostic if initializer API is used outside of an initializer (#54993) Adds a rule that will produce a diagnostic when an initializer-based API is used outside of an initializer. Fixes #54381. PR Close #54993
2024-03-28 08:28:10 +00:00
UNSUPPORTED_INITIALIZER_API_USAGE = 8110,
fix(compiler-cli): add warning for unused let declarations (#57033) Adds a new extended diagnostic that will flag `@let` declarations that aren't used within the template. The diagnostic can be turned off through the `extendedDiagnostics` compiler option. PR Close #57033
2024-07-23 04:19:37 +00:00
UNUSED_LET_DECLARATION = 8112,
feat(compiler): add diagnostic for unused standalone imports (#57605) Adds a new diagnostic that will report cases where a declaration is in the `imports` array, but isn't being used anywhere. The diagnostic is reported as a warning by default and can be controlled using the following option in the tsconfig: ``` { "angularCompilerOptions": { "extendedDiagnostics": { "checks": { "unusedStandaloneImports": "suppress" } } } } ``` **Note:** I'll look into a codefix for the language service in a follow-up. Fixes #46766. PR Close #57605
2024-09-03 19:17:33 +00:00
UNUSED_STANDALONE_IMPORTS = 8113,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
// (undocumented)
VALUE_HAS_WRONG_TYPE = 1010,
// (undocumented)
VALUE_NOT_LITERAL = 1011,
perf(compiler-cli): ignore the module.id anti-pattern for NgModule ids (#45024) In early versions of Angular, it was sometimes necessary to provide a `moduleId` to `@Component` metadata, and the common pattern for doing this was to set `moduleId: module.id`. This relied on the bundler to fill in a value for `module.id`. However, due to the superficial similarity between `Component.moduleId` and `NgModule.id`, many users ended up setting `id: module.id` in their NgModules. This is an anti-pattern that has a few negative effects, including preventing the NgModule from tree-shaking properly. This commit changes the compiler to ignore `id: module.id` in NgModules, and instead provide a warning which suggests removing the line entirely. PR Close #45024
2022-02-09 01:09:20 +00:00
WARN_NGMODULE_ID_UNNECESSARY = 6100,
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
WRITE_TO_READ_ONLY_VARIABLE = 8005
test: add the error code of ngc/ngtsc under api guard (#35067) We should not change these error code without a good reason, so they should be guarded. PR Close #35067
2020-01-30 21:04:17 +00:00
}
build: update API goldens to reflect new tool (#42688) Updates the TS API guardian goldens with their equivalents based on the new shared dev-infra tool. PR Close #42688
2021-06-28 17:54:20 +00:00
// (No @packageDocumentation comment for this package)
```
Reference in a new issue Copy permalink