f0688b4d18
ngcc creates typically two `ts.Program` instances for each entry-point, one for processing sources and another one for processing the typings. The creation of these programs is somewhat expensive, as it concerns module resolution and parsing of source files. This commit implements several layers of caching to optimize the creation of programs: 1. A shared module resolution cache across all entry-points within a single invocation of ngcc. Both the sources and typings program benefit from this cache. 2. Sharing the parsed `ts.SourceFile` for a single entry-point between the sources and typings program. 3. Sharing parsed `ts.SourceFile`s of TypeScript's default libraries across all entry-points within a single invocation. Some of these default library typings are large and therefore expensive to parse, so sharing the parsed source files across all entry-points offers a significant performance improvement. Using a bare CLI app created using `ng new` + `ng add @angular/material`, the above changes offer a 3-4x improvement in ngcc's processing time when running synchronously and ~2x improvement for asynchronous runs. PR Close #38840
91 lines
4.0 KiB
TypeScript
91 lines
4.0 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 * as ts from 'typescript';
|
|
|
|
import {replaceTsWithNgInErrors} from '../../../src/ngtsc/diagnostics';
|
|
import {FileSystem} from '../../../src/ngtsc/file_system';
|
|
import {Logger} from '../../../src/ngtsc/logging';
|
|
import {ParsedConfiguration} from '../../../src/perform_compile';
|
|
import {getEntryPointFormat} from '../packages/entry_point';
|
|
import {makeEntryPointBundle} from '../packages/entry_point_bundle';
|
|
import {createModuleResolutionCache, SharedFileCache} from '../packages/source_file_cache';
|
|
import {PathMappings} from '../path_mappings';
|
|
import {FileWriter} from '../writing/file_writer';
|
|
|
|
import {CreateCompileFn} from './api';
|
|
import {Task, TaskProcessingOutcome} from './tasks/api';
|
|
|
|
/**
|
|
* The function for creating the `compile()` function.
|
|
*/
|
|
export function getCreateCompileFn(
|
|
fileSystem: FileSystem, logger: Logger, fileWriter: FileWriter,
|
|
enableI18nLegacyMessageIdFormat: boolean, tsConfig: ParsedConfiguration|null,
|
|
pathMappings: PathMappings|undefined): CreateCompileFn {
|
|
return (beforeWritingFiles, onTaskCompleted) => {
|
|
const {Transformer} = require('../packages/transformer');
|
|
const transformer = new Transformer(fileSystem, logger, tsConfig);
|
|
const sharedFileCache = new SharedFileCache(fileSystem);
|
|
const moduleResolutionCache = createModuleResolutionCache(fileSystem);
|
|
|
|
return (task: Task) => {
|
|
const {entryPoint, formatProperty, formatPropertiesToMarkAsProcessed, processDts} = task;
|
|
|
|
const isCore = entryPoint.name === '@angular/core'; // Are we compiling the Angular core?
|
|
const packageJson = entryPoint.packageJson;
|
|
const formatPath = packageJson[formatProperty];
|
|
const format = getEntryPointFormat(fileSystem, entryPoint, formatProperty);
|
|
|
|
// All properties listed in `propertiesToProcess` are guaranteed to point to a format-path
|
|
// (i.e. they are defined in `entryPoint.packageJson`). Furthermore, they are also guaranteed
|
|
// to be among `SUPPORTED_FORMAT_PROPERTIES`.
|
|
// Based on the above, `formatPath` should always be defined and `getEntryPointFormat()`
|
|
// should always return a format here (and not `undefined`).
|
|
if (!formatPath || !format) {
|
|
// This should never happen.
|
|
throw new Error(
|
|
`Invariant violated: No format-path or format for ${entryPoint.path} : ` +
|
|
`${formatProperty} (formatPath: ${formatPath} | format: ${format})`);
|
|
}
|
|
|
|
logger.info(`Compiling ${entryPoint.name} : ${formatProperty} as ${format}`);
|
|
|
|
const bundle = makeEntryPointBundle(
|
|
fileSystem, entryPoint, sharedFileCache, moduleResolutionCache, formatPath, isCore,
|
|
format, processDts, pathMappings, true, enableI18nLegacyMessageIdFormat);
|
|
|
|
const result = transformer.transform(bundle);
|
|
if (result.success) {
|
|
if (result.diagnostics.length > 0) {
|
|
logger.warn(replaceTsWithNgInErrors(
|
|
ts.formatDiagnosticsWithColorAndContext(result.diagnostics, bundle.src.host)));
|
|
}
|
|
|
|
const writeBundle = () => {
|
|
fileWriter.writeBundle(
|
|
bundle, result.transformedFiles, formatPropertiesToMarkAsProcessed);
|
|
|
|
logger.debug(` Successfully compiled ${entryPoint.name} : ${formatProperty}`);
|
|
onTaskCompleted(task, TaskProcessingOutcome.Processed, null);
|
|
};
|
|
|
|
const beforeWritingResult = beforeWritingFiles(result.transformedFiles);
|
|
|
|
return (beforeWritingResult instanceof Promise) ?
|
|
beforeWritingResult.then(writeBundle) as ReturnType<typeof beforeWritingFiles>:
|
|
writeBundle();
|
|
} else {
|
|
const errors = replaceTsWithNgInErrors(
|
|
ts.formatDiagnosticsWithColorAndContext(result.diagnostics, bundle.src.host));
|
|
onTaskCompleted(task, TaskProcessingOutcome.Failed, `compilation errors:\n${errors}`);
|
|
}
|
|
};
|
|
};
|
|
}
|