0823622202
To avoid overwhelming a user with secondary diagnostics that derive from a "root cause" error, the compiler has the notion of a "poisoned" NgModule. An NgModule becomes poisoned when its declaration contains semantic errors: declarations which are not components or pipes, imports which are not other NgModules, etc. An NgModule also becomes poisoned if it imports or exports another poisoned NgModule. Previously, the compiler tracked this poisoned status as an alternate state for each scope. Either a correct scope could be produced, or the entire scope would be set to a sentinel error value. This meant that the compiler would not track any information about a scope that was determined to be in error. This method presents several issues: 1. The compiler is unable to support the language service and return results when a component or its module scope is poisoned. This is fine for compilation, since diagnostics will be produced showing the error(s), but the language service needs to still work for incorrect code. 2. `getComponentScopes()` does not return components with a poisoned scope, which interferes with resource tracking of incremental builds. If the component isn't included in that list, then the NgModule for it will not have its dependencies properly tracked, and this can cause future incremental build steps to produce incorrect results. This commit changes the tracking of poisoned module scopes to use a flag on the scope itself, rather than a sentinel value that replaces the scope. This means that the scope itself will still be tracked, even if it contains semantic errors. A test is added to the language service which verifies that poisoned scopes can still be used in template type-checking. PR Close #39923
64 lines
2.2 KiB
TypeScript
64 lines
2.2 KiB
TypeScript
/**
|
|
* @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
|
|
*/
|
|
|
|
import {absoluteFrom} from '@angular/compiler-cli/src/ngtsc/file_system';
|
|
import {initMockFileSystem} from '@angular/compiler-cli/src/ngtsc/file_system/testing';
|
|
|
|
import {LanguageServiceTestEnvironment} from './env';
|
|
|
|
describe('language-service/compiler integration', () => {
|
|
beforeEach(() => {
|
|
initMockFileSystem('Native');
|
|
});
|
|
|
|
it('should show type-checking errors from components with poisoned scopes', () => {
|
|
// Normally, the Angular compiler suppresses errors from components that belong to NgModules
|
|
// which themselves have errors (such scopes are considered "poisoned"), to avoid overwhelming
|
|
// the user with secondary errors that stem from a primary root cause. However, this prevents
|
|
// the generation of type check blocks and other metadata within the compiler which drive the
|
|
// Language Service's understanding of components. Therefore in the Language Service, the
|
|
// compiler is configured to make use of such data even if it's "poisoned". This test verifies
|
|
// that a component declared in an NgModule with a faulty import still generates template
|
|
// diagnostics.
|
|
|
|
const file = absoluteFrom('/test.ts');
|
|
const env = LanguageServiceTestEnvironment.setup([{
|
|
name: file,
|
|
contents: `
|
|
import {Component, Directive, Input, NgModule} from '@angular/core';
|
|
|
|
@Component({
|
|
selector: 'test-cmp',
|
|
template: '<div [dir]="3"></div>',
|
|
})
|
|
export class Cmp {}
|
|
|
|
@Directive({
|
|
selector: '[dir]',
|
|
})
|
|
export class Dir {
|
|
@Input() dir!: string;
|
|
}
|
|
|
|
export class NotAModule {}
|
|
|
|
@NgModule({
|
|
declarations: [Cmp, Dir],
|
|
imports: [NotAModule],
|
|
})
|
|
export class Mod {}
|
|
`,
|
|
isRoot: true,
|
|
}]);
|
|
|
|
const diags = env.ngLS.getSemanticDiagnostics(file);
|
|
expect(diags.map(diag => diag.messageText))
|
|
.toContain(`Type 'number' is not assignable to type 'string'.`);
|
|
});
|
|
});
|