c387952739
Previously, the compiler performed an incremental build by analyzing and resolving all classes in the program (even unchanged ones) and then using the dependency graph information to determine which .js files were stale and needed to be re-emitted. This algorithm produced "correct" rebuilds, but the cost of re-analyzing the entire program turned out to be higher than anticipated, especially for component-heavy compilations. To achieve performant rebuilds, it is necessary to reuse previous analysis results if possible. Doing this safely requires knowing when prior work is viable and when it is stale and needs to be re-done. The new algorithm implemented by this commit is such: 1) Each incremental build starts with knowledge of the last known good dependency graph and analysis results from the last successful build, plus of course information about the set of files changed. 2) The previous dependency graph's information is used to determine the set of source files which have "logically" changed. A source file is considered logically changed if it or any of its dependencies have physically changed (on disk) since the last successful compilation. Any logically unchanged dependencies have their dependency information copied over to the new dependency graph. 3) During the `TraitCompiler`'s loop to consider all source files in the program, if a source file is logically unchanged then its previous analyses are "adopted" (and their 'register' steps are run). If the file is logically changed, then it is re-analyzed as usual. 4) Then, incremental build proceeds as before, with the new dependency graph being used to determine the set of files which require re-emitting. This analysis reuse avoids template parsing operations in many circumstances and significantly reduces the time it takes ngtsc to rebuild a large application. Future work will increase performance even more, by tackling a variety of other opportunities to reuse or avoid work. PR Close #34288
93 lines
3.9 KiB
TypeScript
93 lines
3.9 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright Google Inc. 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 {WrappedNodeExpr} from '@angular/compiler';
|
|
import {R3Reference} from '@angular/compiler/src/compiler';
|
|
import * as ts from 'typescript';
|
|
|
|
import {absoluteFrom} from '../../file_system';
|
|
import {runInEachFileSystem} from '../../file_system/testing';
|
|
import {LocalIdentifierStrategy, NOOP_DEFAULT_IMPORT_RECORDER, ReferenceEmitter} from '../../imports';
|
|
import {CompoundMetadataReader, DtsMetadataReader, LocalMetadataRegistry} from '../../metadata';
|
|
import {PartialEvaluator} from '../../partial_evaluator';
|
|
import {TypeScriptReflectionHost, isNamedClassDeclaration} from '../../reflection';
|
|
import {LocalModuleScopeRegistry, MetadataDtsModuleScopeResolver} from '../../scope';
|
|
import {getDeclaration, makeProgram} from '../../testing';
|
|
import {NgModuleDecoratorHandler} from '../src/ng_module';
|
|
import {NoopReferencesRegistry} from '../src/references_registry';
|
|
|
|
runInEachFileSystem(() => {
|
|
describe('NgModuleDecoratorHandler', () => {
|
|
it('should resolve forwardRef', () => {
|
|
const _ = absoluteFrom;
|
|
const {program} = makeProgram([
|
|
{
|
|
name: _('/node_modules/@angular/core/index.d.ts'),
|
|
contents: `
|
|
export const Component: any;
|
|
export const NgModule: any;
|
|
export declare function forwardRef(fn: () => any): any;
|
|
`,
|
|
},
|
|
{
|
|
name: _('/entry.ts'),
|
|
contents: `
|
|
import {Component, forwardRef, NgModule} from '@angular/core';
|
|
|
|
@Component({
|
|
template: '',
|
|
})
|
|
export class TestComp {}
|
|
|
|
@NgModule()
|
|
export class TestModuleDependency {}
|
|
|
|
@NgModule({
|
|
declarations: [forwardRef(() => TestComp)],
|
|
exports: [forwardRef(() => TestComp)],
|
|
imports: [forwardRef(() => TestModuleDependency)]
|
|
})
|
|
export class TestModule {}
|
|
`
|
|
},
|
|
]);
|
|
const checker = program.getTypeChecker();
|
|
const reflectionHost = new TypeScriptReflectionHost(checker);
|
|
const evaluator = new PartialEvaluator(reflectionHost, checker, /* dependencyTracker */ null);
|
|
const referencesRegistry = new NoopReferencesRegistry();
|
|
const metaRegistry = new LocalMetadataRegistry();
|
|
const metaReader = new CompoundMetadataReader([metaRegistry]);
|
|
const dtsReader = new DtsMetadataReader(checker, reflectionHost);
|
|
const scopeRegistry = new LocalModuleScopeRegistry(
|
|
metaRegistry, new MetadataDtsModuleScopeResolver(dtsReader, null),
|
|
new ReferenceEmitter([]), null);
|
|
const refEmitter = new ReferenceEmitter([new LocalIdentifierStrategy()]);
|
|
|
|
const handler = new NgModuleDecoratorHandler(
|
|
reflectionHost, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry,
|
|
/* isCore */ false, /* routeAnalyzer */ null, refEmitter, /* factoryTracker */ null,
|
|
NOOP_DEFAULT_IMPORT_RECORDER, /* annotateForClosureCompiler */ false);
|
|
const TestModule =
|
|
getDeclaration(program, _('/entry.ts'), 'TestModule', isNamedClassDeclaration);
|
|
const detected =
|
|
handler.detect(TestModule, reflectionHost.getDecoratorsOfDeclaration(TestModule));
|
|
if (detected === undefined) {
|
|
return fail('Failed to recognize @NgModule');
|
|
}
|
|
const moduleDef = handler.analyze(TestModule, detected.metadata).analysis !.mod;
|
|
|
|
expect(getReferenceIdentifierTexts(moduleDef.declarations)).toEqual(['TestComp']);
|
|
expect(getReferenceIdentifierTexts(moduleDef.exports)).toEqual(['TestComp']);
|
|
expect(getReferenceIdentifierTexts(moduleDef.imports)).toEqual(['TestModuleDependency']);
|
|
|
|
function getReferenceIdentifierTexts(references: R3Reference[]) {
|
|
return references.map(ref => (ref.value as WrappedNodeExpr<ts.Identifier>).node.text);
|
|
}
|
|
});
|
|
});
|
|
});
|