cargdev/angular
1
0
Fork 0
Code Issues 17 Pull Requests Actions Packages Projects Releases Wiki Activity

style(compiler-cli): reformat of codebase with new clang-format version (#36520)

Browse Source 
This commit reformats the packages/compiler-cli tree using the new version
of clang-format.

PR Close #36520
This commit is contained in:
Alex Rickabaugh
2020-04-07 12:43:43 -07:00
committed by atscott
parent 33eee43263
commit d5aa6b5bd6
205 changed files with 2949 additions and 2122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
packages/compiler-cli/src/transformers/api.ts
View File

@ -190,8 +190,12 @@ export interface TsEmitArguments {
customTransformers?: ts.CustomTransformers;
}
export interface TsEmitCallback { (args: TsEmitArguments): ts.EmitResult; }
export interface TsMergeEmitResultsCallback { (results: ts.EmitResult[]): ts.EmitResult; }
export interface TsEmitCallback {
(args: TsEmitArguments): ts.EmitResult;
}
export interface TsMergeEmitResultsCallback {
(results: ts.EmitResult[]): ts.EmitResult;
}
export interface LibrarySummary {
fileName: string;
@ -283,14 +287,14 @@ export interface Program {
*
* Angular structural information is required to emit files.
*/
emit({emitFlags, cancellationToken, customTransformers, emitCallback,
mergeEmitResultsCallback}?: {
emitFlags?: EmitFlags,
cancellationToken?: ts.CancellationToken,
customTransformers?: CustomTransformers,
emitCallback?: TsEmitCallback,
mergeEmitResultsCallback?: TsMergeEmitResultsCallback
}): ts.EmitResult;
emit({emitFlags, cancellationToken, customTransformers, emitCallback, mergeEmitResultsCallback}?:
{
emitFlags?: EmitFlags,
cancellationToken?: ts.CancellationToken,
customTransformers?: CustomTransformers,
emitCallback?: TsEmitCallback,
mergeEmitResultsCallback?: TsMergeEmitResultsCallback
}): ts.EmitResult;
/**
* Returns the .d.ts / .ngsummary.json / .ngfactory.d.ts files of libraries that have been emitted

59
packages/compiler-cli/src/transformers/compiler_host.ts
View File

@ -6,7 +6,7 @@
* found in the LICENSE file at https://angular.io/license
*/
import {AotCompilerHost, EmitterVisitorContext, GeneratedFile, ParseSourceSpan, TypeScriptEmitter, collectExternalReferences, syntaxError} from '@angular/compiler';
import {AotCompilerHost, collectExternalReferences, EmitterVisitorContext, GeneratedFile, ParseSourceSpan, syntaxError, TypeScriptEmitter} from '@angular/compiler';
import * as path from 'path';
import * as ts from 'typescript';
@ -15,7 +15,7 @@ import {ModuleMetadata} from '../metadata/index';
import {join} from '../ngtsc/file_system';
import {CompilerHost, CompilerOptions, LibrarySummary} from './api';
import {MetadataReaderHost, createMetadataReaderCache, readMetadata} from './metadata_reader';
import {createMetadataReaderCache, MetadataReaderHost, readMetadata} from './metadata_reader';
import {DTS, GENERATED_FILES, isInRootDir, relativeToRootDirs} from './util';
const NODE_MODULES_PACKAGE_NAME = /node_modules\/((\w|-|\.)+|(@(\w|-|\.)+\/(\w|-|\.)+))/;
@ -24,8 +24,8 @@ const CSS_PREPROCESSOR_EXT = /(\.scss|\.sass|\.less|\.styl)$/;
let wrapHostForTest: ((host: ts.CompilerHost) => ts.CompilerHost)|null = null;
export function setWrapHostForTest(wrapFn: ((host: ts.CompilerHost) => ts.CompilerHost) | null):
void {
export function setWrapHostForTest(wrapFn: ((host: ts.CompilerHost) => ts.CompilerHost)|
null): void {
wrapHostForTest = wrapFn;
}
@ -53,11 +53,11 @@ export interface CodeGenerator {
findGeneratedFileNames(fileName: string): string[];
}
function assert<T>(condition: T | null | undefined) {
function assert<T>(condition: T|null|undefined) {
if (!condition) {
// TODO(chuckjaz): do the right thing
}
return condition !;
return condition!;
}
/**
@ -67,7 +67,7 @@ function assert<T>(condition: T | null | undefined) {
* - TypeCheckHost for mapping ts errors to ng errors (via translateDiagnostics)
*/
export class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHost, AotCompilerHost,
TypeCheckHost {
TypeCheckHost {
private metadataReaderCache = createMetadataReaderCache();
private fileNameToModuleNameCache = new Map<string, string>();
private flatModuleIndexCache = new Map<string, boolean>();
@ -83,13 +83,13 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHos
private metadataReaderHost: MetadataReaderHost;
// TODO(issue/24571): remove '!'.
getCancellationToken !: () => ts.CancellationToken;
getCancellationToken!: () => ts.CancellationToken;
// TODO(issue/24571): remove '!'.
getDefaultLibLocation !: () => string;
getDefaultLibLocation!: () => string;
// TODO(issue/24571): remove '!'.
trace !: (s: string) => void;
trace!: (s: string) => void;
// TODO(issue/24571): remove '!'.
getDirectories !: (path: string) => string[];
getDirectories!: (path: string) => string[];
resolveTypeReferenceDirectives?:
(names: string[], containingFile: string) => ts.ResolvedTypeReferenceDirective[];
directoryExists?: (directoryName: string) => boolean;
@ -100,21 +100,21 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHos
private codeGenerator: CodeGenerator,
private librarySummaries = new Map<string, LibrarySummary>()) {
this.moduleResolutionCache = ts.createModuleResolutionCache(
this.context.getCurrentDirectory !(), this.context.getCanonicalFileName.bind(this.context));
const basePath = this.options.basePath !;
this.context.getCurrentDirectory!(), this.context.getCanonicalFileName.bind(this.context));
const basePath = this.options.basePath!;
this.rootDirs =
(this.options.rootDirs || [this.options.basePath !]).map(p => path.resolve(basePath, p));
(this.options.rootDirs || [this.options.basePath!]).map(p => path.resolve(basePath, p));
if (context.getDirectories) {
this.getDirectories = path => context.getDirectories !(path);
this.getDirectories = path => context.getDirectories!(path);
}
if (context.directoryExists) {
this.directoryExists = directoryName => context.directoryExists !(directoryName);
this.directoryExists = directoryName => context.directoryExists!(directoryName);
}
if (context.getCancellationToken) {
this.getCancellationToken = () => context.getCancellationToken !();
this.getCancellationToken = () => context.getCancellationToken!();
}
if (context.getDefaultLibLocation) {
this.getDefaultLibLocation = () => context.getDefaultLibLocation !();
this.getDefaultLibLocation = () => context.getDefaultLibLocation!();
}
if (context.resolveTypeReferenceDirectives) {
// Backward compatibility with TypeScript 2.9 and older since return
@ -123,11 +123,11 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHos
type ts3ResolveTypeReferenceDirectives = (names: string[], containingFile: string) =>
ts.ResolvedTypeReferenceDirective[];
this.resolveTypeReferenceDirectives = (names: string[], containingFile: string) =>
(context.resolveTypeReferenceDirectives as ts3ResolveTypeReferenceDirectives) !(
names, containingFile);
(context.resolveTypeReferenceDirectives as ts3ResolveTypeReferenceDirectives)!
(names, containingFile);
}
if (context.trace) {
this.trace = s => context.trace !(s);
this.trace = s => context.trace!(s);
}
if (context.fileNameToModuleName) {
this.fileNameToModuleName = context.fileNameToModuleName.bind(context);
@ -265,8 +265,8 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHos
}
}
} else {
throw new Error(
`Trying to import a source file from a node_modules package: import ${originalImportedFile} from ${containingFile}`);
throw new Error(`Trying to import a source file from a node_modules package: import ${
originalImportedFile} from ${containingFile}`);
}
this.fileNameToModuleNameCache.set(cacheKey, moduleName);
@ -325,7 +325,7 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHos
// Note: we need the explicit check via `has` as we also cache results
// that were null / undefined.
if (this.originalSourceFiles.has(filePath)) {
return this.originalSourceFiles.get(filePath) !;
return this.originalSourceFiles.get(filePath)!;
}
if (!languageVersion) {
languageVersion = this.options.target || ts.ScriptTarget.Latest;
@ -353,8 +353,8 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHos
newRefs.forEach(r => refsAreEqual = refsAreEqual && oldRefs.has(r));
}
if (!refsAreEqual) {
throw new Error(
`Illegal State: external references changed in ${genFile.genFileUrl}.\nOld: ${Array.from(oldRefs)}.\nNew: ${Array.from(newRefs)}`);
throw new Error(`Illegal State: external references changed in ${genFile.genFileUrl}.\nOld: ${
Array.from(oldRefs)}.\nNew: ${Array.from(newRefs)}`);
}
return this.addGeneratedFile(genFile, newRefs);
}
@ -381,7 +381,8 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHos
}
this.generatedSourceFiles.set(genFile.genFileUrl, {
sourceFile: sf,
emitCtx: context, externalReferences,
emitCtx: context,
externalReferences,
});
return sf;
}
@ -468,7 +469,7 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHos
}
// TODO(tbosch): TypeScript's typings for getSourceFile are incorrect,
// as it can very well return undefined.
return sf !;
return sf!;
}
private getGeneratedFile(fileName: string): ts.SourceFile|null {
@ -638,7 +639,7 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHos
}
function genFileExternalReferences(genFile: GeneratedFile): Set<string> {
return new Set(collectExternalReferences(genFile.stmts !).map(er => er.moduleName !));
return new Set(collectExternalReferences(genFile.stmts!).map(er => er.moduleName!));
}
function addReferencesToSourceFile(sf: ts.SourceFile, genFileNames: string[]) {

17
packages/compiler-cli/src/transformers/inline_resources.ts
View File

@ -8,7 +8,7 @@
import * as ts from 'typescript';
import {MetadataObject, MetadataValue, isClassMetadata, isMetadataImportedSymbolReferenceExpression, isMetadataSymbolicCallExpression} from '../metadata/index';
import {isClassMetadata, isMetadataImportedSymbolReferenceExpression, isMetadataSymbolicCallExpression, MetadataObject, MetadataValue} from '../metadata/index';
import {MetadataTransformer, ValueTransform} from './metadata_cache';
@ -17,27 +17,29 @@ const PRECONDITIONS_TEXT =
/** A subset of members from AotCompilerHost */
export type ResourcesHost = {
resourceNameToFileName(resourceName: string, containingFileName: string): string | null;
resourceNameToFileName(resourceName: string, containingFileName: string): string|null;
loadResource(path: string): Promise<string>| string;
};
export type StaticResourceLoader = {
get(url: string | MetadataValue): string;
get(url: string|MetadataValue): string;
};
function getResourceLoader(host: ResourcesHost, containingFileName: string): StaticResourceLoader {
return {
get(url: string | MetadataValue): string{
get(url: string|MetadataValue): string {
if (typeof url !== 'string') {
throw new Error('templateUrl and stylesUrl must be string literals. ' + PRECONDITIONS_TEXT);
} const fileName = host.resourceNameToFileName(url, containingFileName);
}
const fileName = host.resourceNameToFileName(url, containingFileName);
if (fileName) {
const content = host.loadResource(fileName);
if (typeof content !== 'string') {
throw new Error('Cannot handle async resource. ' + PRECONDITIONS_TEXT);
}
return content;
} throw new Error(`Failed to resolve ${url} from ${containingFileName}. ${PRECONDITIONS_TEXT}`);
}
throw new Error(`Failed to resolve ${url} from ${containingFileName}. ${PRECONDITIONS_TEXT}`);
}
};
}
@ -249,8 +251,7 @@ function isComponentSymbol(identifier: ts.Node, typeChecker: ts.TypeChecker) {
const name = (declaration.propertyName || declaration.name).text;
// We know that parent pointers are set because we created the SourceFile ourselves.
// The number of parent references here match the recursion depth at this point.
const moduleId =
(declaration.parent !.parent !.parent !.moduleSpecifier as ts.StringLiteral).text;
const moduleId = (declaration.parent!.parent!.parent!.moduleSpecifier as ts.StringLiteral).text;
return moduleId === '@angular/core' && name === 'Component';
}

43
packages/compiler-cli/src/transformers/lower_expressions.ts
View File

@ -9,7 +9,8 @@
import {createLoweredSymbol, isLoweredSymbol} from '@angular/compiler';
import * as ts from 'typescript';
import {CollectorOptions, MetadataCollector, MetadataValue, ModuleMetadata, isMetadataGlobalReferenceExpression} from '../metadata/index';
import {CollectorOptions, isMetadataGlobalReferenceExpression, MetadataCollector, MetadataValue, ModuleMetadata} from '../metadata/index';
import {MetadataCache, MetadataTransformer, ValueTransform} from './metadata_cache';
export interface LoweringRequest {
@ -21,7 +22,10 @@ export interface LoweringRequest {
export type RequestLocationMap = Map<number, LoweringRequest>;
const enum DeclarationOrder { BeforeStmt, AfterStmt }
const enum DeclarationOrder {
BeforeStmt,
AfterStmt
}
interface Declaration {
name: string;
@ -201,14 +205,16 @@ export function getExpressionLoweringTransformFactory(
};
}
export interface RequestsMap { getRequests(sourceFile: ts.SourceFile): RequestLocationMap; }
export interface RequestsMap {
getRequests(sourceFile: ts.SourceFile): RequestLocationMap;
}
interface MetadataAndLoweringRequests {
metadata: ModuleMetadata|undefined;
requests: RequestLocationMap;
}
function isEligibleForLowering(node: ts.Node | undefined): boolean {
function isEligibleForLowering(node: ts.Node|undefined): boolean {
if (node) {
switch (node.kind) {
case ts.SyntaxKind.SourceFile:
@ -232,10 +238,11 @@ function isEligibleForLowering(node: ts.Node | undefined): boolean {
// example) might also require lowering even if the top-level declaration is already
// properly exported.
const varNode = node as ts.VariableDeclaration;
return isExported || (varNode.initializer !== undefined &&
(ts.isObjectLiteralExpression(varNode.initializer) ||
ts.isArrayLiteralExpression(varNode.initializer) ||
ts.isCallExpression(varNode.initializer)));
return isExported ||
(varNode.initializer !== undefined &&
(ts.isObjectLiteralExpression(varNode.initializer) ||
ts.isArrayLiteralExpression(varNode.initializer) ||
ts.isCallExpression(varNode.initializer)));
}
return isEligibleForLowering(node.parent);
}
@ -264,7 +271,7 @@ function isLiteralFieldNamed(node: ts.Node, names: Set<string>): boolean {
export class LowerMetadataTransform implements RequestsMap, MetadataTransformer {
// TODO(issue/24571): remove '!'.
private cache !: MetadataCache;
private cache!: MetadataCache;
private requests = new Map<string, RequestLocationMap>();
private lowerableFieldNames: Set<string>;
@ -288,7 +295,9 @@ export class LowerMetadataTransform implements RequestsMap, MetadataTransformer
}
// MetadataTransformer
connect(cache: MetadataCache): void { this.cache = cache; }
connect(cache: MetadataCache): void {
this.cache = cache;
}
start(sourceFile: ts.SourceFile): ValueTransform|undefined {
let identNumber = 0;
@ -329,7 +338,7 @@ export class LowerMetadataTransform implements RequestsMap, MetadataTransformer
const hasLowerableParentCache = new Map<ts.Node, boolean>();
const shouldBeLowered = (node: ts.Node | undefined): boolean => {
const shouldBeLowered = (node: ts.Node|undefined): boolean => {
if (node === undefined) {
return false;
}
@ -346,7 +355,7 @@ export class LowerMetadataTransform implements RequestsMap, MetadataTransformer
return lowerable;
};
const hasLowerableParent = (node: ts.Node | undefined): boolean => {
const hasLowerableParent = (node: ts.Node|undefined): boolean => {
if (node === undefined) {
return false;
}
@ -354,10 +363,10 @@ export class LowerMetadataTransform implements RequestsMap, MetadataTransformer
hasLowerableParentCache.set(
node, shouldBeLowered(node.parent) || hasLowerableParent(node.parent));
}
return hasLowerableParentCache.get(node) !;
return hasLowerableParentCache.get(node)!;
};
const isLowerable = (node: ts.Node | undefined): boolean => {
const isLowerable = (node: ts.Node|undefined): boolean => {
if (node === undefined) {
return false;
}
@ -383,7 +392,7 @@ function createExportTableFor(sourceFile: ts.SourceFile): Set<string> {
case ts.SyntaxKind.InterfaceDeclaration:
if ((ts.getCombinedModifierFlags(node as ts.Declaration) & ts.ModifierFlags.Export) != 0) {
const classDeclaration =
node as(ts.ClassDeclaration | ts.FunctionDeclaration | ts.InterfaceDeclaration);
node as (ts.ClassDeclaration | ts.FunctionDeclaration | ts.InterfaceDeclaration);
const name = classDeclaration.name;
if (name) exportTable.add(name.text);
}
@ -406,7 +415,9 @@ function createExportTableFor(sourceFile: ts.SourceFile): Set<string> {
const exportDeclaration = node as ts.ExportDeclaration;
const {moduleSpecifier, exportClause} = exportDeclaration;
if (!moduleSpecifier && exportClause && ts.isNamedExports(exportClause)) {
exportClause.elements.forEach(spec => { exportTable.add(spec.name.text); });
exportClause.elements.forEach(spec => {
exportTable.add(spec.name.text);
});
}
}
});

193
packages/compiler-cli/src/transformers/node_emitter.ts
View File

@ -12,7 +12,9 @@ import * as ts from 'typescript';
import {error} from './util';
export interface Node { sourceSpan: ParseSourceSpan|null; }
export interface Node {
sourceSpan: ParseSourceSpan|null;
}
const METHOD_THIS_NAME = 'this';
const CATCH_ERROR_NAME = 'error';
@ -110,15 +112,16 @@ export function updateSourceFile(
// Validate that all the classes have been generated
classNames.size == 0 ||
error(
`${classNames.size == 1 ? 'Class' : 'Classes'} "${Array.from(classNames.keys()).join(', ')}" not generated`);
error(`${classNames.size == 1 ? 'Class' : 'Classes'} "${
Array.from(classNames.keys()).join(', ')}" not generated`);
// Add imports to the module required by the new methods
const imports = converter.getImports();
if (imports && imports.length) {
// Find where the new imports should go
const index = firstAfter(
newStatements, statement => statement.kind === ts.SyntaxKind.ImportDeclaration ||
newStatements,
statement => statement.kind === ts.SyntaxKind.ImportDeclaration ||
statement.kind === ts.SyntaxKind.ImportEqualsDeclaration);
newStatements =
[...newStatements.slice(0, index), ...imports, ...prefix, ...newStatements.slice(index)];
@ -152,7 +155,9 @@ function firstAfter<T>(a: T[], predicate: (value: T) => boolean) {
// A recorded node is a subtype of the node that is marked as being recorded. This is used
// to ensure that NodeEmitterVisitor.record has been called on all nodes returned by the
// NodeEmitterVisitor
export type RecordedNode<T extends ts.Node = ts.Node> = (T & { __recorded: any;}) | null;
export type RecordedNode<T extends ts.Node = ts.Node> = (T&{
__recorded: any;
})|null;
function escapeLiteral(value: string): string {
return value.replace(/(\"|\\)/g, '\\$1').replace(/(\n)|(\r)/g, function(v, n, r) {
@ -220,8 +225,9 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
.map(
([exportedFilePath, reexports]) => ts.createExportDeclaration(
/* decorators */ undefined,
/* modifiers */ undefined, ts.createNamedExports(reexports.map(
({name, as}) => ts.createExportSpecifier(name, as))),
/* modifiers */ undefined,
ts.createNamedExports(
reexports.map(({name, as}) => ts.createExportSpecifier(name, as))),
/* moduleSpecifier */ createLiteral(exportedFilePath)));
}
@ -231,13 +237,16 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
([namespace, prefix]) => ts.createImportDeclaration(
/* decorators */ undefined,
/* modifiers */ undefined,
/* importClause */ ts.createImportClause(
/* importClause */
ts.createImportClause(
/* name */<ts.Identifier>(undefined as any),
ts.createNamespaceImport(ts.createIdentifier(prefix))),
/* moduleSpecifier */ createLiteral(namespace)));
}
getNodeMap() { return this._nodeMap; }
getNodeMap() {
return this._nodeMap;
}
updateSourceMap(statements: ts.Statement[]) {
let lastRangeStartNode: ts.Node|undefined = undefined;
@ -324,7 +333,7 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
reexports = [];
this._reexports.set(moduleName, reexports);
}
reexports.push({name: name !, as: stmt.name});
reexports.push({name: name!, as: stmt.name});
return null;
}
}
@ -340,9 +349,10 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
const tsVarStmt =
this.record(stmt, ts.createVariableStatement(/* modifiers */[], varDeclList));
const exportStmt = this.record(
stmt, ts.createExportDeclaration(
/*decorators*/ undefined, /*modifiers*/ undefined,
ts.createNamedExports([ts.createExportSpecifier(stmt.name, stmt.name)])));
stmt,
ts.createExportDeclaration(
/*decorators*/ undefined, /*modifiers*/ undefined,
ts.createNamedExports([ts.createExportSpecifier(stmt.name, stmt.name)])));
return [tsVarStmt, exportStmt];
}
return this.record(stmt, ts.createVariableStatement(this.getModifiers(stmt), varDeclList));
@ -350,14 +360,15 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
visitDeclareFunctionStmt(stmt: DeclareFunctionStmt) {
return this.record(
stmt, ts.createFunctionDeclaration(
/* decorators */ undefined, this.getModifiers(stmt),
/* asteriskToken */ undefined, stmt.name, /* typeParameters */ undefined,
stmt.params.map(
p => ts.createParameter(
/* decorators */ undefined, /* modifiers */ undefined,
/* dotDotDotToken */ undefined, p.name)),
/* type */ undefined, this._visitStatements(stmt.statements)));
stmt,
ts.createFunctionDeclaration(
/* decorators */ undefined, this.getModifiers(stmt),
/* asteriskToken */ undefined, stmt.name, /* typeParameters */ undefined,
stmt.params.map(
p => ts.createParameter(
/* decorators */ undefined, /* modifiers */ undefined,
/* dotDotDotToken */ undefined, p.name)),
/* type */ undefined, this._visitStatements(stmt.statements)));
}
visitExpressionStmt(stmt: ExpressionStatement) {
@ -401,7 +412,8 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
(stmt.constructorMethod && [ts.createConstructor(
/* decorators */ undefined,
/* modifiers */ undefined,
/* parameters */ stmt.constructorMethod.params.map(
/* parameters */
stmt.constructorMethod.params.map(
p => ts.createParameter(
/* decorators */ undefined,
/* modifiers */ undefined,
@ -415,7 +427,7 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
method => ts.createMethod(
/* decorators */ undefined,
/* modifiers */ translateModifiers(method.modifiers),
/* astriskToken */ undefined, method.name !/* guarded by filter */,
/* astriskToken */ undefined, method.name!/* guarded by filter */,
/* questionToken */ undefined, /* typeParameters */ undefined,
method.params.map(
p => ts.createParameter(
@ -423,13 +435,14 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
/* dotDotDotToken */ undefined, p.name)),
/* type */ undefined, this._visitStatements(method.body)));
return this.record(
stmt, ts.createClassDeclaration(
/* decorators */ undefined, modifiers, stmt.name, /* typeParameters*/ undefined,
stmt.parent && [ts.createHeritageClause(
ts.SyntaxKind.ExtendsKeyword,
[stmt.parent.visitExpression(this, null)])] ||
[],
[...fields, ...getters, ...constructor, ...methods]));
stmt,
ts.createClassDeclaration(
/* decorators */ undefined, modifiers, stmt.name, /* typeParameters*/ undefined,
stmt.parent &&
[ts.createHeritageClause(
ts.SyntaxKind.ExtendsKeyword, [stmt.parent.visitExpression(this, null)])] ||
[],
[...fields, ...getters, ...constructor, ...methods]));
}
visitIfStmt(stmt: IfStmt) {
@ -443,19 +456,21 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
visitTryCatchStmt(stmt: TryCatchStmt): RecordedNode<ts.TryStatement> {
return this.record(
stmt, ts.createTry(
this._visitStatements(stmt.bodyStmts),
ts.createCatchClause(
CATCH_ERROR_NAME, this._visitStatementsPrefix(
[ts.createVariableStatement(
/* modifiers */ undefined,
[ts.createVariableDeclaration(
CATCH_STACK_NAME, /* type */ undefined,
ts.createPropertyAccess(
ts.createIdentifier(CATCH_ERROR_NAME),
ts.createIdentifier(CATCH_STACK_NAME)))])],
stmt.catchStmts)),
/* finallyBlock */ undefined));
stmt,
ts.createTry(
this._visitStatements(stmt.bodyStmts),
ts.createCatchClause(
CATCH_ERROR_NAME,
this._visitStatementsPrefix(
[ts.createVariableStatement(
/* modifiers */ undefined,
[ts.createVariableDeclaration(
CATCH_STACK_NAME, /* type */ undefined,
ts.createPropertyAccess(
ts.createIdentifier(CATCH_ERROR_NAME),
ts.createIdentifier(CATCH_STACK_NAME)))])],
stmt.catchStmts)),
/* finallyBlock */ undefined));
}
visitThrowStmt(stmt: ThrowStmt) {
@ -481,7 +496,9 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
}
// ExpressionVisitor
visitWrappedNodeExpr(expr: WrappedNodeExpr<any>) { return this.record(expr, expr.node); }
visitWrappedNodeExpr(expr: WrappedNodeExpr<any>) {
return this.record(expr, expr.node);
}
visitTypeofExpr(expr: TypeofExpr) {
const typeOf = ts.createTypeOf(expr.expr.visitExpression(this, null));
@ -508,8 +525,9 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
visitWriteVarExpr(expr: WriteVarExpr): RecordedNode<ts.BinaryExpression> {
return this.record(
expr, ts.createAssignment(
ts.createIdentifier(expr.name), expr.value.visitExpression(this, null)));
expr,
ts.createAssignment(
ts.createIdentifier(expr.name), expr.value.visitExpression(this, null)));
}
visitWriteKeyExpr(expr: WriteKeyExpr): RecordedNode<ts.BinaryExpression> {
@ -523,9 +541,10 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
visitWritePropExpr(expr: WritePropExpr): RecordedNode<ts.BinaryExpression> {
return this.record(
expr, ts.createAssignment(
ts.createPropertyAccess(expr.receiver.visitExpression(this, null), expr.name),
expr.value.visitExpression(this, null)));
expr,
ts.createAssignment(
ts.createPropertyAccess(expr.receiver.visitExpression(this, null), expr.name),
expr.value.visitExpression(this, null)));
}
visitInvokeMethodExpr(expr: InvokeMethodExpr): RecordedNode<ts.CallExpression> {
@ -539,19 +558,23 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
visitInvokeFunctionExpr(expr: InvokeFunctionExpr): RecordedNode<ts.CallExpression> {
return this.record(
expr, ts.createCall(
expr.fn.visitExpression(this, null), /* typeArguments */ undefined,
expr.args.map(arg => arg.visitExpression(this, null))));
expr,
ts.createCall(
expr.fn.visitExpression(this, null), /* typeArguments */ undefined,
expr.args.map(arg => arg.visitExpression(this, null))));
}
visitInstantiateExpr(expr: InstantiateExpr): RecordedNode<ts.NewExpression> {
return this.record(
expr, ts.createNew(
expr.classExpr.visitExpression(this, null), /* typeArguments */ undefined,
expr.args.map(arg => arg.visitExpression(this, null))));
expr,
ts.createNew(
expr.classExpr.visitExpression(this, null), /* typeArguments */ undefined,
expr.args.map(arg => arg.visitExpression(this, null))));
}
visitLiteralExpr(expr: LiteralExpr) { return this.record(expr, createLiteral(expr.value)); }
visitLiteralExpr(expr: LiteralExpr) {
return this.record(expr, createLiteral(expr.value));
}
visitLocalizedString(expr: LocalizedString, context: any) {
throw new Error('localized strings are not supported in pre-ivy mode.');
@ -567,13 +590,14 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
expr,
ts.createParen(ts.createConditional(
expr.condition.visitExpression(this, null), expr.trueCase.visitExpression(this, null),
expr.falseCase !.visitExpression(this, null))));
expr.falseCase!.visitExpression(this, null))));
}
visitNotExpr(expr: NotExpr): RecordedNode<ts.PrefixUnaryExpression> {
return this.record(
expr, ts.createPrefix(
ts.SyntaxKind.ExclamationToken, expr.condition.visitExpression(this, null)));
expr,
ts.createPrefix(
ts.SyntaxKind.ExclamationToken, expr.condition.visitExpression(this, null)));
}
visitAssertNotNullExpr(expr: AssertNotNull): RecordedNode<ts.Expression> {
@ -586,15 +610,16 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
visitFunctionExpr(expr: FunctionExpr) {
return this.record(
expr, ts.createFunctionExpression(
/* modifiers */ undefined, /* astriskToken */ undefined,
/* name */ expr.name || undefined,
/* typeParameters */ undefined,
expr.params.map(
p => ts.createParameter(
/* decorators */ undefined, /* modifiers */ undefined,
/* dotDotDotToken */ undefined, p.name)),
/* type */ undefined, this._visitStatements(expr.statements)));
expr,
ts.createFunctionExpression(
/* modifiers */ undefined, /* astriskToken */ undefined,
/* name */ expr.name || undefined,
/* typeParameters */ undefined,
expr.params.map(
p => ts.createParameter(
/* decorators */ undefined, /* modifiers */ undefined,
/* dotDotDotToken */ undefined, p.name)),
/* type */ undefined, this._visitStatements(expr.statements)));
}
visitBinaryOperatorExpr(expr: BinaryOperatorExpr):
@ -676,21 +701,23 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
visitLiteralMapExpr(expr: LiteralMapExpr): RecordedNode<ts.ObjectLiteralExpression> {
return this.record(
expr, ts.createObjectLiteral(expr.entries.map(
entry => ts.createPropertyAssignment(
entry.quoted || !_VALID_IDENTIFIER_RE.test(entry.key) ?
ts.createLiteral(entry.key) :
entry.key,
entry.value.visitExpression(this, null)))));
expr,
ts.createObjectLiteral(expr.entries.map(
entry => ts.createPropertyAssignment(
entry.quoted || !_VALID_IDENTIFIER_RE.test(entry.key) ?
ts.createLiteral(entry.key) :
entry.key,
entry.value.visitExpression(this, null)))));
}
visitCommaExpr(expr: CommaExpr): RecordedNode<ts.Expression> {
return this.record(
expr, expr.parts.map(e => e.visitExpression(this, null))
.reduce<ts.Expression|null>(
(left, right) =>
left ? ts.createBinary(left, ts.SyntaxKind.CommaToken, right) : right,
null));
expr,
expr.parts.map(e => e.visitExpression(this, null))
.reduce<ts.Expression|null>(
(left, right) =>
left ? ts.createBinary(left, ts.SyntaxKind.CommaToken, right) : right,
null));
}
private _visitStatements(statements: Statement[]): ts.Block {
@ -705,7 +732,7 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
private _visitIdentifier(value: ExternalReference): ts.Expression {
// name can only be null during JIT which never executes this code.
const moduleName = value.moduleName, name = value.name !;
const moduleName = value.moduleName, name = value.name!;
let prefixIdent: ts.Identifier|null = null;
if (moduleName) {
let prefix = this._importsWithPrefixes.get(moduleName);
@ -730,7 +757,7 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
}
function getMethodName(methodRef: {name: string | null; builtin: BuiltinMethod | null}): string {
function getMethodName(methodRef: {name: string|null; builtin: BuiltinMethod | null}): string {
if (methodRef.name) {
return methodRef.name;
} else {
@ -760,6 +787,6 @@ function modifierFromModifier(modifier: StmtModifier): ts.Modifier {
return error(`unknown statement modifier`);
}
function translateModifiers(modifiers: StmtModifier[] | null): ts.Modifier[]|undefined {
return modifiers == null ? undefined : modifiers !.map(modifierFromModifier);
function translateModifiers(modifiers: StmtModifier[]|null): ts.Modifier[]|undefined {
return modifiers == null ? undefined : modifiers!.map(modifierFromModifier);
}

150
packages/compiler-cli/src/transformers/program.ts
View File

@ -7,26 +7,26 @@
* found in the LICENSE file at https://angular.io/license
*/
import {AotCompiler, AotCompilerHost, AotCompilerOptions, EmitterVisitorContext, FormattedMessageChain, GeneratedFile, MessageBundle, NgAnalyzedFile, NgAnalyzedFileWithInjectables, NgAnalyzedModules, ParseSourceSpan, PartialModule, Position, Serializer, StaticSymbol, TypeScriptEmitter, Xliff, Xliff2, Xmb, core, createAotCompiler, getParseErrors, isFormattedError, isSyntaxError} from '@angular/compiler';
import {AotCompiler, AotCompilerHost, AotCompilerOptions, core, createAotCompiler, EmitterVisitorContext, FormattedMessageChain, GeneratedFile, getParseErrors, isFormattedError, isSyntaxError, MessageBundle, NgAnalyzedFile, NgAnalyzedFileWithInjectables, NgAnalyzedModules, ParseSourceSpan, PartialModule, Position, Serializer, StaticSymbol, TypeScriptEmitter, Xliff, Xliff2, Xmb} from '@angular/compiler';
import * as fs from 'fs';
import * as path from 'path';
import * as ts from 'typescript';
import {TypeCheckHost, translateDiagnostics} from '../diagnostics/translate_diagnostics';
import {MetadataCollector, ModuleMetadata, createBundleIndexHost} from '../metadata';
import {translateDiagnostics, TypeCheckHost} from '../diagnostics/translate_diagnostics';
import {createBundleIndexHost, MetadataCollector, ModuleMetadata} from '../metadata';
import {NgtscProgram} from '../ngtsc/program';
import {verifySupportedTypeScriptVersion} from '../typescript_support';
import {CompilerHost, CompilerOptions, CustomTransformers, DEFAULT_ERROR_CODE, Diagnostic, DiagnosticMessageChain, EmitFlags, LazyRoute, LibrarySummary, Program, SOURCE, TsEmitArguments, TsEmitCallback, TsMergeEmitResultsCallback} from './api';
import {CodeGenerator, TsCompilerAotCompilerTypeCheckHostAdapter, getOriginalReferences} from './compiler_host';
import {InlineResourcesMetadataTransformer, getInlineResourcesTransformFactory} from './inline_resources';
import {LowerMetadataTransform, getExpressionLoweringTransformFactory} from './lower_expressions';
import {CodeGenerator, getOriginalReferences, TsCompilerAotCompilerTypeCheckHostAdapter} from './compiler_host';
import {getInlineResourcesTransformFactory, InlineResourcesMetadataTransformer} from './inline_resources';
import {getExpressionLoweringTransformFactory, LowerMetadataTransform} from './lower_expressions';
import {MetadataCache, MetadataTransformer} from './metadata_cache';
import {getAngularEmitterTransformFactory} from './node_emitter_transform';
import {PartialModuleMetadataTransformer} from './r3_metadata_transform';
import {StripDecoratorsMetadataTransformer, getDecoratorStripTransformerFactory} from './r3_strip_decorators';
import {getDecoratorStripTransformerFactory, StripDecoratorsMetadataTransformer} from './r3_strip_decorators';
import {getAngularClassTransformerFactory} from './r3_transform';
import {DTS, GENERATED_FILES, StructureIsReused, TS, createMessageDiagnostic, isInRootDir, ngToTsDiagnostic, tsStructureIsReused, userError} from './util';
import {createMessageDiagnostic, DTS, GENERATED_FILES, isInRootDir, ngToTsDiagnostic, StructureIsReused, TS, tsStructureIsReused, userError} from './util';
/**
@ -60,18 +60,23 @@ const emptyModules: NgAnalyzedModules = {
files: []
};
const defaultEmitCallback: TsEmitCallback =
({program, targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles,
customTransformers}) =>
program.emit(
targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers);
const defaultEmitCallback: TsEmitCallback = ({
program,
targetSourceFile,
writeFile,
cancellationToken,
emitOnlyDtsFiles,
customTransformers
}) =>
program.emit(
targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers);
class AngularCompilerProgram implements Program {
private rootNames: string[];
private metadataCache: MetadataCache;
// Metadata cache used exclusively for the flat module index
// TODO(issue/24571): remove '!'.
private flatModuleMetadataCache !: MetadataCache;
private flatModuleMetadataCache!: MetadataCache;
private loweringMetadataTransform: LowerMetadataTransform;
private oldProgramLibrarySummaries: Map<string, LibrarySummary>|undefined;
private oldProgramEmittedGeneratedFiles: Map<string, GeneratedFile>|undefined;
@ -84,18 +89,18 @@ class AngularCompilerProgram implements Program {
// Lazily initialized fields
// TODO(issue/24571): remove '!'.
private _compiler !: AotCompiler;
private _compiler!: AotCompiler;
// TODO(issue/24571): remove '!'.
private _hostAdapter !: TsCompilerAotCompilerTypeCheckHostAdapter;
private _hostAdapter!: TsCompilerAotCompilerTypeCheckHostAdapter;
// TODO(issue/24571): remove '!'.
private _tsProgram !: ts.Program;
private _tsProgram!: ts.Program;
private _analyzedModules: NgAnalyzedModules|undefined;
private _analyzedInjectables: NgAnalyzedFileWithInjectables[]|undefined;
private _structuralDiagnostics: Diagnostic[]|undefined;
private _programWithStubs: ts.Program|undefined;
private _optionsDiagnostics: Diagnostic[] = [];
// TODO(issue/24571): remove '!'.
private _reifiedDecorators !: Set<StaticSymbol>;
private _reifiedDecorators!: Set<StaticSymbol>;
constructor(
rootNames: ReadonlyArray<string>, private options: CompilerOptions,
@ -124,7 +129,7 @@ class AngularCompilerProgram implements Program {
code: DEFAULT_ERROR_CODE
})));
} else {
this.rootNames.push(indexName !);
this.rootNames.push(indexName!);
this.host = bundleHost;
}
}
@ -175,7 +180,9 @@ class AngularCompilerProgram implements Program {
return result;
}
getTsProgram(): ts.Program { return this.tsProgram; }
getTsProgram(): ts.Program {
return this.tsProgram;
}
getTsOptionDiagnostics(cancellationToken?: ts.CancellationToken) {
return this.tsProgram.getOptionsDiagnostics(cancellationToken);
@ -256,17 +263,19 @@ class AngularCompilerProgram implements Program {
return this._emitRender2(parameters);
}
private _emitRender3(
{
emitFlags = EmitFlags.Default, cancellationToken, customTransformers,
emitCallback = defaultEmitCallback, mergeEmitResultsCallback = mergeEmitResults,
}: {
emitFlags?: EmitFlags,
cancellationToken?: ts.CancellationToken,
customTransformers?: CustomTransformers,
emitCallback?: TsEmitCallback,
mergeEmitResultsCallback?: TsMergeEmitResultsCallback,
} = {}): ts.EmitResult {
private _emitRender3({
emitFlags = EmitFlags.Default,
cancellationToken,
customTransformers,
emitCallback = defaultEmitCallback,
mergeEmitResultsCallback = mergeEmitResults,
}: {
emitFlags?: EmitFlags,
cancellationToken?: ts.CancellationToken,
customTransformers?: CustomTransformers,
emitCallback?: TsEmitCallback,
mergeEmitResultsCallback?: TsMergeEmitResultsCallback,
} = {}): ts.EmitResult {
const emitStart = Date.now();
if ((emitFlags & (EmitFlags.JS | EmitFlags.DTS | EmitFlags.Metadata | EmitFlags.Codegen)) ===
0) {
@ -276,7 +285,7 @@ class AngularCompilerProgram implements Program {
// analyzedModules and analyzedInjectables are created together. If one exists, so does the
// other.
const modules =
this.compiler.emitAllPartialModules(this.analyzedModules, this._analyzedInjectables !);
this.compiler.emitAllPartialModules(this.analyzedModules, this._analyzedInjectables!);
const writeTsFile: ts.WriteFileCallback =
(outFileName, outData, writeByteOrderMark, onError?, sourceFiles?) => {
@ -306,7 +315,8 @@ class AngularCompilerProgram implements Program {
program: this.tsProgram,
host: this.host,
options: this.options,
writeFile: writeTsFile, emitOnlyDtsFiles,
writeFile: writeTsFile,
emitOnlyDtsFiles,
customTransformers: tsCustomTransformers
});
} finally {
@ -319,17 +329,19 @@ class AngularCompilerProgram implements Program {
}
}
private _emitRender2(
{
emitFlags = EmitFlags.Default, cancellationToken, customTransformers,
emitCallback = defaultEmitCallback, mergeEmitResultsCallback = mergeEmitResults,
}: {
emitFlags?: EmitFlags,
cancellationToken?: ts.CancellationToken,
customTransformers?: CustomTransformers,
emitCallback?: TsEmitCallback,
mergeEmitResultsCallback?: TsMergeEmitResultsCallback,
} = {}): ts.EmitResult {
private _emitRender2({
emitFlags = EmitFlags.Default,
cancellationToken,
customTransformers,
emitCallback = defaultEmitCallback,
mergeEmitResultsCallback = mergeEmitResults,
}: {
emitFlags?: EmitFlags,
cancellationToken?: ts.CancellationToken,
customTransformers?: CustomTransformers,
emitCallback?: TsEmitCallback,
mergeEmitResultsCallback?: TsMergeEmitResultsCallback,
} = {}): ts.EmitResult {
const emitStart = Date.now();
if (emitFlags & EmitFlags.I18nBundle) {
const locale = this.options.i18nOutLocale || null;
@ -413,7 +425,8 @@ class AngularCompilerProgram implements Program {
program: this.tsProgram,
host: this.host,
options: this.options,
writeFile: writeTsFile, emitOnlyDtsFiles,
writeFile: writeTsFile,
emitOnlyDtsFiles,
customTransformers: tsCustomTransformers,
targetSourceFile: this.tsProgram.getSourceFile(fileName),
})));
@ -423,7 +436,8 @@ class AngularCompilerProgram implements Program {
program: this.tsProgram,
host: this.host,
options: this.options,
writeFile: writeTsFile, emitOnlyDtsFiles,
writeFile: writeTsFile,
emitOnlyDtsFiles,
customTransformers: tsCustomTransformers
});
emittedUserTsCount = this.tsProgram.getSourceFiles().length - genTsFiles.length;
@ -466,7 +480,7 @@ class AngularCompilerProgram implements Program {
if (emitFlags & EmitFlags.Codegen) {
genJsonFiles.forEach(gf => {
const outFileName = srcToOutPath(gf.genFileUrl);
this.writeFile(outFileName, gf.source !, false, undefined, gf);
this.writeFile(outFileName, gf.source!, false, undefined, gf);
});
}
let metadataJsonCount = 0;
@ -501,21 +515,21 @@ class AngularCompilerProgram implements Program {
if (!this._compiler) {
this._createCompiler();
}
return this._compiler !;
return this._compiler!;
}
private get hostAdapter(): TsCompilerAotCompilerTypeCheckHostAdapter {
if (!this._hostAdapter) {
this._createCompiler();
}
return this._hostAdapter !;
return this._hostAdapter!;
}
private get analyzedModules(): NgAnalyzedModules {
if (!this._analyzedModules) {
this.initSync();
}
return this._analyzedModules !;
return this._analyzedModules!;
}
private get structuralDiagnostics(): ReadonlyArray<Diagnostic> {
@ -531,7 +545,7 @@ class AngularCompilerProgram implements Program {
if (!this._tsProgram) {
this.initSync();
}
return this._tsProgram !;
return this._tsProgram!;
}
private get reifiedDecorators(): Set<StaticSymbol> {
@ -617,7 +631,7 @@ class AngularCompilerProgram implements Program {
private _createCompiler() {
const codegen: CodeGenerator = {
generateFile: (genFileName, baseFileName) =>
this._compiler.emitBasicStub(genFileName, baseFileName),
this._compiler.emitBasicStub(genFileName, baseFileName),
findGeneratedFileNames: (fileName) => this._compiler.findGeneratedFileNames(fileName),
};
@ -646,7 +660,7 @@ class AngularCompilerProgram implements Program {
const codegen: CodeGenerator = {
generateFile: (genFileName, baseFileName) =>
this.compiler.emitBasicStub(genFileName, baseFileName),
this.compiler.emitBasicStub(genFileName, baseFileName),
findGeneratedFileNames: (fileName) => this.compiler.findGeneratedFileNames(fileName),
};
@ -692,7 +706,7 @@ class AngularCompilerProgram implements Program {
if (generate) {
// Note: ! is ok as hostAdapter.shouldGenerateFile will always return a baseFileName
// for .ngfactory.ts files.
const genFile = this.compiler.emitTypeCheckStub(sf.fileName, baseFileName !);
const genFile = this.compiler.emitTypeCheckStub(sf.fileName, baseFileName!);
if (genFile) {
this.hostAdapter.updateGeneratedFile(genFile);
}
@ -782,11 +796,12 @@ class AngularCompilerProgram implements Program {
private getSourceFilesForEmit(): ts.SourceFile[]|undefined {
// TODO(tbosch): if one of the files contains a `const enum`
// always emit all files -> return undefined!
let sourceFilesToEmit = this.tsProgram.getSourceFiles().filter(
sf => { return !sf.isDeclarationFile && !GENERATED_FILES.test(sf.fileName); });
let sourceFilesToEmit = this.tsProgram.getSourceFiles().filter(sf => {
return !sf.isDeclarationFile && !GENERATED_FILES.test(sf.fileName);
});
if (this.oldProgramEmittedSourceFiles) {
sourceFilesToEmit = sourceFilesToEmit.filter(sf => {
const oldFile = this.oldProgramEmittedSourceFiles !.get(sf.fileName);
const oldFile = this.oldProgramEmittedSourceFiles!.get(sf.fileName);
return sf !== oldFile;
});
}
@ -849,7 +864,8 @@ class AngularCompilerProgram implements Program {
export function createProgram({rootNames, options, host, oldProgram}: {
rootNames: ReadonlyArray<string>,
options: CompilerOptions,
host: CompilerHost, oldProgram?: Program
host: CompilerHost,
oldProgram?: Program
}): Program {
if (options.enableIvy !== false) {
return new NgtscProgram(rootNames, options, host, oldProgram as NgtscProgram | undefined);
@ -887,7 +903,9 @@ function getAotCompilerOptions(options: CompilerOptions): AotCompilerOptions {
return {
locale: options.i18nInLocale,
i18nFormat: options.i18nInFormat || options.i18nOutFormat,
i18nUseExternalIds: options.i18nUseExternalIds, translations, missingTranslation,
i18nUseExternalIds: options.i18nUseExternalIds,
translations,
missingTranslation,
enableSummariesForJit: options.enableSummariesForJit,
preserveWhitespaces: options.preserveWhitespaces,
fullTemplateTypeCheck: options.fullTemplateTypeCheck,
@ -931,8 +949,8 @@ function normalizeSeparators(path: string): string {
* POSIX normalized paths for output paths.
*/
export function createSrcToOutPathMapper(
outDir: string | undefined, sampleSrcFileName: string | undefined,
sampleOutFileName: string | undefined, host: {
outDir: string|undefined, sampleSrcFileName: string|undefined,
sampleOutFileName: string|undefined, host: {
dirname: typeof path.dirname,
resolve: typeof path.resolve,
relative: typeof path.relative
@ -971,14 +989,14 @@ export function createSrcToOutPathMapper(
}
export function i18nExtract(
formatName: string | null, outFile: string | null, host: ts.CompilerHost,
options: CompilerOptions, bundle: MessageBundle): string[] {
formatName: string|null, outFile: string|null, host: ts.CompilerHost, options: CompilerOptions,
bundle: MessageBundle): string[] {
formatName = formatName || 'xlf';
// Checks the format and returns the extension
const ext = i18nGetExtension(formatName);
const content = i18nSerialize(bundle, formatName, options);
const dstFile = outFile || `messages.${ext}`;
const dstPath = path.resolve(options.outDir || options.basePath !, dstFile);
const dstPath = path.resolve(options.outDir || options.basePath!, dstFile);
host.writeFile(dstPath, content, false, undefined, []);
return [dstPath];
}
@ -1045,7 +1063,7 @@ function mergeEmitResults(emitResults: ts.EmitResult[]): ts.EmitResult {
function diagnosticSourceOfSpan(span: ParseSourceSpan): ts.SourceFile {
// For diagnostics, TypeScript only uses the fileName and text properties.
// The redundant '()' are here is to avoid having clang-format breaking the line incorrectly.
return ({ fileName: span.start.file.url, text: span.start.file.content } as any);
return ({fileName: span.start.file.url, text: span.start.file.content} as any);
}
function diagnosticSourceOfFileName(fileName: string, program: ts.Program): ts.SourceFile {
@ -1055,7 +1073,7 @@ function diagnosticSourceOfFileName(fileName: string, program: ts.Program): ts.S
// If we are reporting diagnostics for a source file that is not in the project then we need
// to fake a source file so the diagnostic formatting routines can emit the file name.
// The redundant '()' are here is to avoid having clang-format breaking the line incorrectly.
return ({ fileName, text: '' } as any);
return ({fileName, text: ''} as any);
}

2
packages/compiler-cli/src/transformers/r3_metadata_transform.ts
View File

@ -9,7 +9,7 @@
import {ClassStmt, PartialModule, Statement, StmtModifier} from '@angular/compiler';
import * as ts from 'typescript';
import {MetadataCollector, MetadataValue, ModuleMetadata, isClassMetadata} from '../metadata/index';
import {isClassMetadata, MetadataCollector, MetadataValue, ModuleMetadata} from '../metadata/index';
import {MetadataTransformer, ValueTransform} from './metadata_cache';

14
packages/compiler-cli/src/transformers/r3_strip_decorators.ts
View File

@ -9,7 +9,7 @@
import {StaticReflector, StaticSymbol} from '@angular/compiler';
import * as ts from 'typescript';
import {MetadataValue, isClassMetadata, isMetadataImportedSymbolReferenceExpression, isMetadataSymbolicCallExpression} from '../metadata';
import {isClassMetadata, isMetadataImportedSymbolReferenceExpression, isMetadataSymbolicCallExpression, MetadataValue} from '../metadata';
import {MetadataTransformer, ValueTransform} from './metadata_cache';
@ -39,8 +39,14 @@ export function getDecoratorStripTransformerFactory(
});
if (decorators.length !== node.decorators.length) {
return ts.updateClassDeclaration(
node, decorators, node.modifiers, node.name, node.typeParameters,
node.heritageClauses || [], node.members, );
node,
decorators,
node.modifiers,
node.name,
node.typeParameters,
node.heritageClauses || [],
node.members,
);
}
return node;
};
@ -130,7 +136,7 @@ function resolveToStaticSymbol(
if (!ts.isImportSpecifier(decl)) {
return null;
}
const moduleSpecifier = decl.parent !.parent !.parent !.moduleSpecifier;
const moduleSpecifier = decl.parent!.parent!.parent!.moduleSpecifier;
if (!ts.isStringLiteral(moduleSpecifier)) {
return null;
}

15
packages/compiler-cli/src/transformers/util.ts
View File

@ -16,7 +16,11 @@ export const GENERATED_FILES = /(.*?)\.(ngfactory|shim\.ngstyle|ngstyle|ngsummar
export const DTS = /\.d\.ts$/;
export const TS = /^(?!.*\.d\.ts$).*\.ts$/;
export const enum StructureIsReused {Not = 0, SafeModules = 1, Completely = 2}
export const enum StructureIsReused {
Not = 0,
SafeModules = 1,
Completely = 2
}
// Note: This is an internal property in TypeScript. Use it only for assertions and tests.
export function tsStructureIsReused(program: ts.Program): StructureIsReused {
@ -36,7 +40,8 @@ export function createMessageDiagnostic(messageText: string): ts.Diagnostic&Diag
file: undefined,
start: undefined,
length: undefined,
category: ts.DiagnosticCategory.Message, messageText,
category: ts.DiagnosticCategory.Message,
messageText,
code: DEFAULT_ERROR_CODE,
source: SOURCE,
};
@ -76,7 +81,7 @@ export function ngToTsDiagnostic(ng: Diagnostic): ts.Diagnostic {
// Note: We can't use a real ts.SourceFile,
// but we can at least mirror the properties `fileName` and `text`, which
// are mostly used for error reporting.
file = { fileName: ng.span.start.file.url, text: ng.span.start.file.content } as ts.SourceFile;
file = {fileName: ng.span.start.file.url, text: ng.span.start.file.content} as ts.SourceFile;
start = ng.span.start.offset;
length = ng.span.end.offset - start;
}
@ -84,6 +89,8 @@ export function ngToTsDiagnostic(ng: Diagnostic): ts.Diagnostic {
file,
messageText: ng.messageText,
category: ng.category,
code: ng.code, start, length,
code: ng.code,
start,
length,
};
}