honeymoose
/
angular-cn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor(compiler-cli): implement `DeclarationNode` node type (#38959) 

Previously the `ConcreteDeclaration` and `InlineDeclaration` had
different properties for the underlying node type. And the `InlineDeclaration`
did not store a value that represented its declaration.

It turns out that a natural declaration node for an inline type is the
expression. For example in UMD/CommonJS this would be the `exports.<name>`
property access node.

So this expression is now used for the `node` of `InlineDeclaration` types
and the `expression` property is dropped.

To support this the codebase has been refactored to use a new `DeclarationNode`
type which is a union of `ts.Declaration|ts.Expression` instead of `ts.Declaration`
throughout.

PR Close #38959
This commit is contained in:
Pete Bacon Darwin 2020-09-29 20:42:20 +01:00 committed by atscott
parent 2c0282f4c2
commit 0accd1e68d
54 changed files with 276 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
packages/compiler-cli/ngcc/src/analysis/module_with_providers_analyzer.ts
View File

@ -10,7 +10,7 @@ import * as ts from 'typescript';
import {ReferencesRegistry} from '../../../src/ngtsc/annotations';
import {Reference} from '../../../src/ngtsc/imports';
import {PartialEvaluator} from '../../../src/ngtsc/partial_evaluator';
import {ClassDeclaration, isNamedClassDeclaration, isNamedVariableDeclaration} from '../../../src/ngtsc/reflection';
import {ClassDeclaration, DeclarationNode, isNamedClassDeclaration, isNamedVariableDeclaration} from '../../../src/ngtsc/reflection';
import {NgccReflectionHost} from '../host/ngcc_host';
import {hasNameIdentifier, isDefined} from '../utils';
@ -30,7 +30,7 @@ export interface ModuleWithProvidersInfo {
/**
* Declaration of the containing class (if this is a method)
*/
container: ts.Declaration|null;
container: DeclarationNode|null;
/**
* The declaration of the class that the `ngModule` property on the `ModuleWithProviders` object
* refers to.
@ -125,7 +125,7 @@ export class ModuleWithProvidersAnalyzer {
*/
private parseForModuleWithProviders(
name: string, node: ts.Node|null, implementation: ts.Node|null = node,
container: ts.Declaration|null = null): ModuleWithProvidersInfo|null {
container: DeclarationNode|null = null): ModuleWithProvidersInfo|null {
if (implementation === null ||
(!ts.isFunctionDeclaration(implementation) && !ts.isMethodDeclaration(implementation) &&
!ts.isFunctionExpression(implementation))) {

10
packages/compiler-cli/ngcc/src/analysis/ngcc_references_registry.ts
View File

@ -9,7 +9,7 @@
import * as ts from 'typescript';
import {ReferencesRegistry} from '../../../src/ngtsc/annotations';
import {Reference} from '../../../src/ngtsc/imports';
import {ConcreteDeclaration, ReflectionHost} from '../../../src/ngtsc/reflection';
import {Declaration, DeclarationNode, ReflectionHost} from '../../../src/ngtsc/reflection';
import {hasNameIdentifier} from '../utils';
/**
@ -20,7 +20,7 @@ import {hasNameIdentifier} from '../utils';
* from libraries that are compiled by ngcc.
*/
export class NgccReferencesRegistry implements ReferencesRegistry {
private map = new Map<ts.Identifier, ConcreteDeclaration>();
private map = new Map<ts.Identifier, Declaration>();
constructor(private host: ReflectionHost) {}
@ -29,12 +29,12 @@ export class NgccReferencesRegistry implements ReferencesRegistry {
* Only `ResolveReference` references are stored. Other types are ignored.
* @param references A collection of references to register.
*/
add(source: ts.Declaration, ...references: Reference<ts.Declaration>[]): void {
add(source: DeclarationNode, ...references: Reference<DeclarationNode>[]): void {
references.forEach(ref => {
// Only store relative references. We are not interested in literals.
if (ref.bestGuessOwningModule === null && hasNameIdentifier(ref.node)) {
const declaration = this.host.getDeclarationOfIdentifier(ref.node.name);
if (declaration && declaration.node !== null && hasNameIdentifier(declaration.node)) {
if (declaration && hasNameIdentifier(declaration.node)) {
this.map.set(declaration.node.name, declaration);
}
}
@ -45,7 +45,7 @@ export class NgccReferencesRegistry implements ReferencesRegistry {
* Create and return a mapping for the registered resolved references.
* @returns A map of reference identifiers to reference declarations.
*/
getDeclarationMap(): Map<ts.Identifier, ConcreteDeclaration> {
getDeclarationMap(): Map<ts.Identifier, Declaration> {
return this.map;
}
}

6
packages/compiler-cli/ngcc/src/analysis/private_declarations_analyzer.ts
View File

@ -8,7 +8,7 @@
import * as ts from 'typescript';
import {absoluteFromSourceFile, AbsoluteFsPath} from '../../../src/ngtsc/file_system';
import {ConcreteDeclaration} from '../../../src/ngtsc/reflection';
import {Declaration} from '../../../src/ngtsc/reflection';
import {NgccReflectionHost} from '../host/ngcc_host';
import {hasNameIdentifier, isDefined} from '../utils';
@ -40,8 +40,8 @@ export class PrivateDeclarationsAnalyzer {
private getPrivateDeclarations(
rootFiles: ts.SourceFile[],
declarations: Map<ts.Identifier, ConcreteDeclaration>): PrivateDeclarationsAnalyses {
const privateDeclarations: Map<ts.Identifier, ConcreteDeclaration> = new Map(declarations);
declarations: Map<ts.Identifier, Declaration>): PrivateDeclarationsAnalyses {
const privateDeclarations: Map<ts.Identifier, Declaration> = new Map(declarations);
rootFiles.forEach(f => {
const exports = this.host.getExportsOfModule(f);

6
packages/compiler-cli/ngcc/src/host/commonjs_host.ts
View File

@ -10,7 +10,7 @@ import * as ts from 'typescript';
import {absoluteFrom} from '../../../src/ngtsc/file_system';
import {Logger} from '../../../src/ngtsc/logging';
import {Declaration, Import} from '../../../src/ngtsc/reflection';
import {Declaration, DeclarationKind, Import} from '../../../src/ngtsc/reflection';
import {BundleProgram} from '../packages/bundle_program';
import {FactoryMap, isDefined} from '../utils';
@ -181,7 +181,7 @@ export class CommonJsReflectionHost extends Esm5ReflectionHost {
} else {
return {
name,
declaration: {node: null, known: null, expression, viaModule: null},
declaration: {node: expression, known: null, kind: DeclarationKind.Inline, viaModule: null},
};
}
}
@ -204,7 +204,7 @@ export class CommonJsReflectionHost extends Esm5ReflectionHost {
return null;
}
const viaModule = isExternalImport(importPath) ? importPath : null;
return {node: module, known: null, viaModule, identity: null};
return {node: module, known: null, viaModule, identity: null, kind: DeclarationKind.Concrete};
}
private resolveModuleName(moduleName: string, containingFile: ts.SourceFile): ts.SourceFile

6
packages/compiler-cli/ngcc/src/host/delegating_host.ts
View File

@ -8,7 +8,7 @@
import * as ts from 'typescript';
import {ClassDeclaration, ClassMember, CtorParameter, Declaration, Decorator, FunctionDefinition, Import, ReflectionHost} from '../../../src/ngtsc/reflection';
import {ClassDeclaration, ClassMember, CtorParameter, Declaration, DeclarationNode, Decorator, FunctionDefinition, Import, ReflectionHost} from '../../../src/ngtsc/reflection';
import {isFromDtsFile} from '../../../src/ngtsc/util/src/typescript';
import {NgccClassSymbol, NgccReflectionHost, SwitchableVariableDeclaration} from './ngcc_host';
@ -38,7 +38,7 @@ export class DelegatingReflectionHost implements NgccReflectionHost {
return this.ngccHost.getDeclarationOfIdentifier(id);
}
getDecoratorsOfDeclaration(declaration: ts.Declaration): Decorator[]|null {
getDecoratorsOfDeclaration(declaration: DeclarationNode): Decorator[]|null {
if (isFromDtsFile(declaration)) {
return this.tsHost.getDecoratorsOfDeclaration(declaration);
}
@ -52,7 +52,7 @@ export class DelegatingReflectionHost implements NgccReflectionHost {
return this.ngccHost.getDefinitionOfFunction(fn);
}
getDtsDeclaration(declaration: ts.Declaration): ts.Declaration|null {
getDtsDeclaration(declaration: DeclarationNode): ts.Declaration|null {
if (isFromDtsFile(declaration)) {
return this.tsHost.getDtsDeclaration(declaration);
}

64
packages/compiler-cli/ngcc/src/host/esm2015_host.ts
View File

@ -10,7 +10,7 @@ import * as ts from 'typescript';
import {absoluteFromSourceFile} from '../../../src/ngtsc/file_system';
import {Logger} from '../../../src/ngtsc/logging';
import {ClassDeclaration, ClassMember, ClassMemberKind, CtorParameter, Declaration, Decorator, EnumMember, Import, isDecoratorIdentifier, isNamedClassDeclaration, isNamedFunctionDeclaration, isNamedVariableDeclaration, KnownDeclaration, reflectObjectLiteral, SpecialDeclarationKind, TypeScriptReflectionHost, TypeValueReference, TypeValueReferenceKind, ValueUnavailableKind} from '../../../src/ngtsc/reflection';
import {ClassDeclaration, ClassMember, ClassMemberKind, CtorParameter, Declaration, DeclarationNode, Decorator, EnumMember, Import, isConcreteDeclaration, isDecoratorIdentifier, isNamedClassDeclaration, isNamedFunctionDeclaration, isNamedVariableDeclaration, KnownDeclaration, reflectObjectLiteral, SpecialDeclarationKind, TypeScriptReflectionHost, TypeValueReference, TypeValueReferenceKind, ValueUnavailableKind} from '../../../src/ngtsc/reflection';
import {isWithinPackage} from '../analysis/util';
import {BundleProgram} from '../packages/bundle_program';
import {findAll, getNameText, hasNameIdentifier, isDefined, stripDollarSuffix} from '../utils';
@ -58,7 +58,7 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
* tree. Note that by definition the key and value declarations will not be in the same TS
* program.
*/
protected publicDtsDeclarationMap: Map<ts.Declaration, ts.Declaration>|null = null;
protected publicDtsDeclarationMap: Map<DeclarationNode, ts.Declaration>|null = null;
/**
* A mapping from source declarations to typings declarations, which are not publicly exported.
*
@ -66,7 +66,7 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
* the same name in both the source and the dts file. Note that by definition the key and value
* declarations will not be in the same TS program.
*/
protected privateDtsDeclarationMap: Map<ts.Declaration, ts.Declaration>|null = null;
protected privateDtsDeclarationMap: Map<DeclarationNode, ts.Declaration>|null = null;
/**
* The set of source files that have already been preprocessed.
@ -88,7 +88,7 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
*
* This map is populated during the preprocessing of each source file.
*/
protected aliasedClassDeclarations = new Map<ts.Declaration, ts.Identifier>();
protected aliasedClassDeclarations = new Map<DeclarationNode, ts.Identifier>();
/**
* Caches the information of the decorators on a class, as the work involved with extracting
@ -140,16 +140,17 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
* Examine a declaration (for example, of a class or function) and return metadata about any
* decorators present on the declaration.
*
* @param declaration a TypeScript `ts.Declaration` node representing the class or function over
* which to reflect. For example, if the intent is to reflect the decorators of a class and the
* source is in ES6 format, this will be a `ts.ClassDeclaration` node. If the source is in ES5
* format, this might be a `ts.VariableDeclaration` as classes in ES5 are represented as the
* result of an IIFE execution.
* @param declaration a TypeScript node representing the class or function over which to reflect.
* For example, if the intent is to reflect the decorators of a class and the source is in ES6
* format, this will be a `ts.ClassDeclaration` node. If the source is in ES5 format, this
* might be a `ts.VariableDeclaration` as classes in ES5 are represented as the result of an
* IIFE execution.
*
* @returns an array of `Decorator` metadata if decorators are present on the declaration, or
* `null` if either no decorators were present or if the declaration is not of a decoratable type.
* `null` if either no decorators were present or if the declaration is not of a decoratable
* type.
*/
getDecoratorsOfDeclaration(declaration: ts.Declaration): Decorator[]|null {
getDecoratorsOfDeclaration(declaration: DeclarationNode): Decorator[]|null {
const symbol = this.getClassSymbol(declaration);
if (!symbol) {
return null;
@ -280,13 +281,14 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
getDeclarationOfIdentifier(id: ts.Identifier): Declaration|null {
const superDeclaration = super.getDeclarationOfIdentifier(id);
// If no declaration was found or it's an inline declaration, return as is.
if (superDeclaration === null || superDeclaration.node === null) {
// If no declaration was found, return.
if (superDeclaration === null) {
return superDeclaration;
}
// If the declaration already has traits assigned to it, return as is.
if (superDeclaration.known !== null || superDeclaration.identity !== null) {
if (superDeclaration.known !== null ||
isConcreteDeclaration(superDeclaration) && superDeclaration.identity !== null) {
return superDeclaration;
}
@ -302,7 +304,8 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
const declaration = outerNode !== null && isNamedVariableDeclaration(outerNode) ?
this.getDeclarationOfIdentifier(outerNode.name) :
superDeclaration;
if (declaration === null || declaration.node === null || declaration.known !== null) {
if (declaration === null || declaration.known !== null ||
isConcreteDeclaration(declaration) && declaration.identity !== null) {
return declaration;
}
@ -314,7 +317,7 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
}
// Variable declarations may represent an enum declaration, so attempt to resolve its members.
if (ts.isVariableDeclaration(declaration.node)) {
if (isConcreteDeclaration(declaration) && ts.isVariableDeclaration(declaration.node)) {
const enumMembers = this.resolveEnumMembers(declaration.node);
if (enumMembers !== null) {
declaration.identity = {kind: SpecialDeclarationKind.DownleveledEnum, enumMembers};
@ -450,7 +453,7 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
* Note that the `ts.ClassDeclaration` returned from this function may not be from the same
* `ts.Program` as the input declaration.
*/
getDtsDeclaration(declaration: ts.Declaration): ts.Declaration|null {
getDtsDeclaration(declaration: DeclarationNode): ts.Declaration|null {
if (this.dts === null) {
return null;
}
@ -777,7 +780,7 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
* @returns The original identifier that the given class declaration resolves to, or `undefined`
* if the declaration does not represent an aliased class.
*/
protected resolveAliasedClassIdentifier(declaration: ts.Declaration): ts.Identifier|null {
protected resolveAliasedClassIdentifier(declaration: DeclarationNode): ts.Identifier|null {
this.ensurePreprocessed(declaration.getSourceFile());
return this.aliasedClassDeclarations.has(declaration) ?
this.aliasedClassDeclarations.get(declaration)! :
@ -829,7 +832,7 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
const aliasedIdentifier = initializer.left;
const aliasedDeclaration = this.getDeclarationOfIdentifier(aliasedIdentifier);
if (aliasedDeclaration === null || aliasedDeclaration.node === null) {
if (aliasedDeclaration === null) {
throw new Error(
`Unable to locate declaration of ${aliasedIdentifier.text} in "${statement.getText()}"`);
}
@ -1628,7 +1631,7 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
const imp = this.getImportOfExpression(typeExpression);
const decl = this.getDeclarationOfExpression(typeExpression);
if (imp === null || decl === null || decl.node === null) {
if (imp === null || decl === null) {
return {
kind: TypeValueReferenceKind.LOCAL,
expression: typeExpression,
@ -1788,8 +1791,8 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
* @returns a map of source declarations to typings declarations.
*/
protected computePublicDtsDeclarationMap(src: BundleProgram, dts: BundleProgram):
Map<ts.Declaration, ts.Declaration> {
const declarationMap = new Map<ts.Declaration, ts.Declaration>();
Map<DeclarationNode, ts.Declaration> {
const declarationMap = new Map<DeclarationNode, ts.Declaration>();
const dtsDeclarationMap = new Map<string, ts.Declaration>();
const rootDts = getRootFileOrFail(dts);
this.collectDtsExportedDeclarations(dtsDeclarationMap, rootDts, dts.program.getTypeChecker());
@ -1812,8 +1815,8 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
* @returns a map of source declarations to typings declarations.
*/
protected computePrivateDtsDeclarationMap(src: BundleProgram, dts: BundleProgram):
Map<ts.Declaration, ts.Declaration> {
const declarationMap = new Map<ts.Declaration, ts.Declaration>();
Map<DeclarationNode, ts.Declaration> {
const declarationMap = new Map<DeclarationNode, ts.Declaration>();
const dtsDeclarationMap = new Map<string, ts.Declaration>();
const typeChecker = dts.program.getTypeChecker();
@ -1855,13 +1858,13 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
protected collectSrcExportedDeclarations(
declarationMap: Map<ts.Declaration, ts.Declaration>,
declarationMap: Map<DeclarationNode, ts.Declaration>,
dtsDeclarationMap: Map<string, ts.Declaration>, srcFile: ts.SourceFile): void {
const fileExports = this.getExportsOfModule(srcFile);
if (fileExports !== null) {
for (const [exportName, {node: declaration}] of fileExports) {
if (declaration !== null && dtsDeclarationMap.has(exportName)) {
declarationMap.set(declaration, dtsDeclarationMap.get(exportName)!);
for (const [exportName, {node: declarationNode}] of fileExports) {
if (dtsDeclarationMap.has(exportName)) {
declarationMap.set(declarationNode, dtsDeclarationMap.get(exportName)!);
}
}
}
@ -1877,7 +1880,7 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
}
const namespaceDecl = this.getDeclarationOfIdentifier(expression.expression);
if (!namespaceDecl || namespaceDecl.node === null || !ts.isSourceFile(namespaceDecl.node)) {
if (!namespaceDecl || !ts.isSourceFile(namespaceDecl.node)) {
return null;
}
@ -1896,9 +1899,6 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
/** Checks if the specified declaration resolves to the known JavaScript global `Object`. */
protected isJavaScriptObjectDeclaration(decl: Declaration): boolean {
if (decl.node === null) {
return false;
}
const node = decl.node;
// The default TypeScript library types the global `Object` variable through
// a variable declaration with a type reference resolving to `ObjectConstructor`.

6
packages/compiler-cli/ngcc/src/host/esm5_host.ts
View File

@ -8,7 +8,7 @@
import * as ts from 'typescript';
import {ClassDeclaration, ClassMember, ClassMemberKind, Declaration, Decorator, FunctionDefinition, isNamedFunctionDeclaration, KnownDeclaration, Parameter, reflectObjectLiteral} from '../../../src/ngtsc/reflection';
import {ClassDeclaration, ClassMember, ClassMemberKind, Declaration, DeclarationKind, Decorator, FunctionDefinition, isNamedFunctionDeclaration, KnownDeclaration, Parameter, reflectObjectLiteral} from '../../../src/ngtsc/reflection';
import {getTsHelperFnFromDeclaration, getTsHelperFnFromIdentifier, hasNameIdentifier} from '../utils';
import {Esm2015ReflectionHost, getOuterNodeFromInnerDeclaration, getPropertyValueFromSymbol, isAssignmentStatement, ParamInfo} from './esm2015_host';
@ -82,9 +82,9 @@ export class Esm5ReflectionHost extends Esm2015ReflectionHost {
// `importHelpers: false` (the default). This is, for example, the case with
// `@nativescript/angular@9.0.0-next-2019-11-12-155500-01`.
return {
expression: id,
kind: DeclarationKind.Inline,
node: id,
known: nonEmittedNorImportedTsHelperDeclaration,
node: null,
viaModule: null,
};
}

50
packages/compiler-cli/ngcc/src/host/umd_host.ts
View File

@ -10,7 +10,7 @@ import * as ts from 'typescript';
import {absoluteFrom} from '../../../src/ngtsc/file_system';
import {Logger} from '../../../src/ngtsc/logging';
import {Declaration, Import} from '../../../src/ngtsc/reflection';
import {Declaration, DeclarationKind, Import} from '../../../src/ngtsc/reflection';
import {BundleProgram} from '../packages/bundle_program';
import {FactoryMap, getTsHelperFnFromIdentifier, stripExtension} from '../utils';
@ -172,17 +172,8 @@ export class UmdReflectionHost extends Esm5ReflectionHost {
const viaModule = stripExtension(importedFile.fileName);
const reexports: ExportDeclaration[] = [];
importedExports.forEach((decl, name) => {
if (decl.node !== null) {
reexports.push({
name,
declaration: {node: decl.node, known: null, viaModule, identity: decl.identity}
});
} else {
reexports.push(
{name, declaration: {node: null, known: null, expression: decl.expression, viaModule}});
}
});
importedExports.forEach(
(decl, name) => reexports.push({name, declaration: {...decl, viaModule}}));
return reexports;
}
@ -204,7 +195,7 @@ export class UmdReflectionHost extends Esm5ReflectionHost {
}
return {
name,
declaration: {node: null, known: null, expression, viaModule: null},
declaration: {kind: DeclarationKind.Inline, node: expression, known: null, viaModule: null},
};
}
@ -255,22 +246,31 @@ export class UmdReflectionHost extends Esm5ReflectionHost {
return null;
}
// Sadly, in the case of `exports.foo = bar`, we can't use `this.findUmdImportParameter(id)` to
// check whether this `exports` is from the IIFE body arguments, because
// `this.checker.getSymbolAtLocation(id)` will return the symbol for the `foo` identifier rather
// than the `exports` identifier.
// Sadly, in the case of `exports.foo = bar`, we can't use `this.findUmdImportParameter(id)`
// to check whether this `exports` is from the IIFE body arguments, because
// `this.checker.getSymbolAtLocation(id)` will return the symbol for the `foo` identifier
// rather than the `exports` identifier.
//
// Instead we search the symbols in the current local scope.
const exportsSymbol = this.checker.getSymbolsInScope(id, ts.SymbolFlags.Variable)
.find(symbol => symbol.name === 'exports');
if (exportsSymbol !== undefined &&
!ts.isFunctionExpression(exportsSymbol.valueDeclaration.parent)) {
// There is an `exports` symbol in the local scope that is not a function parameter.
// So this `exports` identifier must be a local variable and does not represent the module.
return {node: exportsSymbol.valueDeclaration, viaModule: null, known: null, identity: null};
}
return {node: id.getSourceFile(), viaModule: null, known: null, identity: null};
const node = exportsSymbol !== undefined &&
!ts.isFunctionExpression(exportsSymbol.valueDeclaration.parent) ?
// There is a locally defined `exports` variable that is not a function parameter.
// So this `exports` identifier must be a local variable and does not represent the module.
exportsSymbol.valueDeclaration :
// There is no local symbol or it is a parameter of an IIFE.
// So this `exports` represents the current "module".
id.getSourceFile();
return {
kind: DeclarationKind.Concrete,
node,
viaModule: null,
known: null,
identity: null,
};
}
private getUmdModuleDeclaration(id: ts.Identifier): Declaration|null {
@ -285,7 +285,7 @@ export class UmdReflectionHost extends Esm5ReflectionHost {
}
const viaModule = isExternalImport(importPath) ? importPath : null;
return {node: module, viaModule, known: null, identity: null};
return {kind: DeclarationKind.Concrete, node: module, viaModule, known: null, identity: null};
}
private getImportPathFromParameter(id: ts.Identifier): string|null {

2
packages/compiler-cli/ngcc/src/migrations/missing_injectable_migration.ts
View File

@ -151,7 +151,7 @@ function migrateProviderClass(provider: ResolvedValue, host: MigrationHost): voi
return;
}
const clazz = provider.node as ts.Declaration;
const clazz = provider.node;
if (isClassDeclaration(clazz) && host.isInScope(clazz) && needsInjectableDecorator(clazz, host)) {
host.injectSyntheticDecorator(clazz, createInjectableDecorator(clazz));
}

2
packages/compiler-cli/ngcc/src/migrations/undecorated_parent_migration.ts
View File

@ -101,7 +101,7 @@ function determineBaseClass(
}
const baseClass = host.evaluator.evaluate(baseClassExpr);
if (!(baseClass instanceof Reference) || !isClassDeclaration(baseClass.node as ts.Declaration)) {
if (!(baseClass instanceof Reference) || !isClassDeclaration(baseClass.node)) {
return null;
}

2
packages/compiler-cli/ngcc/src/migrations/utils.ts
View File

@ -10,7 +10,7 @@ import {Reference} from '../../../src/ngtsc/imports';
import {ClassDeclaration, Decorator, isNamedClassDeclaration, isNamedFunctionDeclaration, isNamedVariableDeclaration} from '../../../src/ngtsc/reflection';
import {MigrationHost} from './migration';
export function isClassDeclaration(clazz: ts.Declaration): clazz is ClassDeclaration {
export function isClassDeclaration(clazz: ts.Node): clazz is ClassDeclaration<ts.Declaration> {
return isNamedClassDeclaration(clazz) || isNamedFunctionDeclaration(clazz) ||
isNamedVariableDeclaration(clazz);
}

6
packages/compiler-cli/ngcc/src/utils.ts
View File

@ -8,7 +8,7 @@
import * as ts from 'typescript';
import {absoluteFrom, AbsoluteFsPath, FileSystem, isRooted} from '../../src/ngtsc/file_system';
import {KnownDeclaration} from '../../src/ngtsc/reflection';
import {DeclarationNode, KnownDeclaration} from '../../src/ngtsc/reflection';
/**
* A list (`Array`) of partially ordered `T` items.
@ -71,7 +71,7 @@ export function findAll<T>(node: ts.Node, test: (node: ts.Node) => node is ts.No
* @param declaration The declaration to test.
* @returns true if the declaration has an identifier for a name.
*/
export function hasNameIdentifier(declaration: ts.Node): declaration is ts.Declaration&
export function hasNameIdentifier(declaration: ts.Node): declaration is DeclarationNode&
{name: ts.Identifier} {
const namedDeclaration: ts.Node&{name?: ts.Node} = declaration;
return namedDeclaration.name !== undefined && ts.isIdentifier(namedDeclaration.name);
@ -136,7 +136,7 @@ export function resolveFileWithPostfixes(
* Determine whether a function declaration corresponds with a TypeScript helper function, returning
* its kind if so or null if the declaration does not seem to correspond with such a helper.
*/
export function getTsHelperFnFromDeclaration(decl: ts.Declaration): KnownDeclaration|null {
export function getTsHelperFnFromDeclaration(decl: DeclarationNode): KnownDeclaration|null {
if (!ts.isFunctionDeclaration(decl) && !ts.isVariableDeclaration(decl)) {
return null;
}

12
packages/compiler-cli/ngcc/test/analysis/decoration_analyzer_spec.ts
View File

@ -11,7 +11,7 @@ import {FatalDiagnosticError, makeDiagnostic} from '../../../src/ngtsc/diagnosti
import {absoluteFrom, getFileSystem, getSourceFileOrError} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {MockLogger} from '../../../src/ngtsc/logging/testing';
import {ClassDeclaration, Decorator} from '../../../src/ngtsc/reflection';
import {ClassDeclaration, DeclarationNode, Decorator} from '../../../src/ngtsc/reflection';
import {AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerPrecedence} from '../../../src/ngtsc/transform';
import {loadFakeCore, loadTestFiles} from '../../../test/helpers';
import {DecorationAnalyzer} from '../../src/analysis/decoration_analyzer';
@ -52,7 +52,7 @@ runInEachFileSystem(() => {
]);
// Only detect the Component and Directive decorators
handler.detect.and.callFake(
(node: ts.Declaration, decorators: Decorator[]|null): DetectResult<unknown>|
(node: DeclarationNode, decorators: Decorator[]|null): DetectResult<unknown>|
undefined => {
const className = (node as any).name.text;
if (decorators === null) {
@ -76,7 +76,7 @@ runInEachFileSystem(() => {
}
});
// The "test" analysis is an object with the name of the decorator being analyzed
handler.analyze.and.callFake((decl: ts.Declaration, dec: Decorator) => {
handler.analyze.and.callFake((decl: DeclarationNode, dec: Decorator) => {
logs.push(`analyze: ${(decl as any).name.text}@${dec.name}`);
return {
analysis: {decoratorName: dec.name},
@ -85,7 +85,7 @@ runInEachFileSystem(() => {
};
});
// The "test" resolution is just setting `resolved: true` on the analysis
handler.resolve.and.callFake((decl: ts.Declaration, analysis: any) => {
handler.resolve.and.callFake((decl: DeclarationNode, analysis: any) => {
logs.push(`resolve: ${(decl as any).name.text}@${analysis.decoratorName}`);
analysis.resolved = true;
return {
@ -95,10 +95,10 @@ runInEachFileSystem(() => {
});
// The "test" compilation result is just the name of the decorator being compiled
// (suffixed with `(compiled)`)
(handler.compileFull as any).and.callFake((decl: ts.Declaration, analysis: any) => {
handler.compileFull.and.callFake((decl: DeclarationNode, analysis: any) => {
logs.push(`compile: ${(decl as any).name.text}@${analysis.decoratorName} (resolved: ${
analysis.resolved})`);
return `@${analysis.decoratorName} (compiled)`;
return `@${analysis.decoratorName} (compiled)` as any;
});
return handler;
};

4
packages/compiler-cli/ngcc/test/analysis/module_with_providers_analyzer_spec.ts
View File

@ -10,7 +10,7 @@ import * as ts from 'typescript';
import {absoluteFrom, AbsoluteFsPath, getSourceFileOrError} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {MockLogger} from '../../../src/ngtsc/logging/testing';
import {isNamedClassDeclaration, isNamedVariableDeclaration} from '../../../src/ngtsc/reflection';
import {DeclarationNode, isNamedClassDeclaration, isNamedVariableDeclaration} from '../../../src/ngtsc/reflection';
import {getDeclaration} from '../../../src/ngtsc/testing';
import {loadTestFiles} from '../../../test/helpers';
import {ModuleWithProvidersAnalyses, ModuleWithProvidersAnalyzer} from '../../src/analysis/module_with_providers_analyzer';
@ -660,7 +660,7 @@ runInEachFileSystem(() => {
[];
}
function getName(node: ts.Declaration|null): string {
function getName(node: DeclarationNode|null): string {
return node && (isNamedVariableDeclaration(node) || isNamedClassDeclaration(node)) ?
`${node.name.text}.` :
'';

4
packages/compiler-cli/ngcc/test/analysis/references_registry_spec.ts
View File

@ -11,7 +11,7 @@ import {absoluteFrom} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {Reference} from '../../../src/ngtsc/imports';
import {PartialEvaluator} from '../../../src/ngtsc/partial_evaluator';
import {TypeScriptReflectionHost} from '../../../src/ngtsc/reflection';
import {DeclarationNode, TypeScriptReflectionHost} from '../../../src/ngtsc/reflection';
import {getDeclaration} from '../../../src/ngtsc/testing';
import {loadTestFiles} from '../../../test/helpers';
import {NgccReferencesRegistry} from '../../src/analysis/ngcc_references_registry';
@ -61,7 +61,7 @@ runInEachFileSystem(() => {
});
});
function isReference(ref: any): ref is Reference<ts.Declaration> {
function isReference(ref: any): ref is Reference<DeclarationNode> {
return ref instanceof Reference;
}
});

19
packages/compiler-cli/ngcc/test/host/commonjs_host_spec.ts
View File

@ -10,7 +10,7 @@ import * as ts from 'typescript';
import {absoluteFrom, getFileSystem, getSourceFileOrError} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {MockLogger} from '../../../src/ngtsc/logging/testing';
import {ClassMemberKind, ConcreteDeclaration, CtorParameter, DownleveledEnum, InlineDeclaration, isNamedClassDeclaration, isNamedFunctionDeclaration, isNamedVariableDeclaration, KnownDeclaration, TypeScriptReflectionHost, TypeValueReferenceKind} from '../../../src/ngtsc/reflection';
import {ClassMemberKind, ConcreteDeclaration, CtorParameter, DeclarationKind, DownleveledEnum, InlineDeclaration, isNamedClassDeclaration, isNamedFunctionDeclaration, isNamedVariableDeclaration, KnownDeclaration, TypeScriptReflectionHost, TypeValueReferenceKind} from '../../../src/ngtsc/reflection';
import {getDeclaration} from '../../../src/ngtsc/testing';
import {loadFakeCore, loadTestFiles} from '../../../test/helpers';
import {CommonJsReflectionHost} from '../../src/host/commonjs_host';
@ -1840,6 +1840,7 @@ exports.MissingClass2 = MissingClass2;
const helperDeclaration = host.getDeclarationOfIdentifier(helperIdentifier);
expect(helperDeclaration).toEqual({
kind: DeclarationKind.Concrete,
known: knownAs,
node: getHelperDeclaration(helperName),
viaModule,
@ -2163,9 +2164,9 @@ exports.MissingClass2 = MissingClass2;
const helperDeclaration = host.getDeclarationOfIdentifier(helperIdentifier);
expect(helperDeclaration).toEqual({
kind: DeclarationKind.Inline,
known: knownAs,
expression: helperIdentifier,
node: null,
node: helperIdentifier,
viaModule: null,
});
};
@ -2197,9 +2198,9 @@ exports.MissingClass2 = MissingClass2;
const helperDeclaration = host.getDeclarationOfIdentifier(helperIdentifier);
expect(helperDeclaration).toEqual({
kind: DeclarationKind.Inline,
known: knownAs,
expression: helperIdentifier,
node: null,
node: helperIdentifier,
viaModule: null,
});
};
@ -2421,10 +2422,10 @@ exports.MissingClass2 = MissingClass2;
const file = getSourceFileOrError(bundle.program, _('/inline_export.js'));
const exportDeclarations = host.getExportsOfModule(file);
expect(exportDeclarations).not.toBeNull();
const decl = exportDeclarations!.get('directives') as InlineDeclaration;
expect(decl).not.toBeUndefined();
expect(decl.node).toBeNull();
expect(decl.expression).toBeDefined();
const decl = exportDeclarations!.get('directives')!;
expect(decl).toBeDefined();
expect(decl.node).toBeDefined();
expect(decl.kind).toEqual(DeclarationKind.Inline);
});
it('should recognize declarations of known TypeScript helpers', () => {

6
packages/compiler-cli/ngcc/test/host/esm2015_host_spec.ts
View File

@ -2076,7 +2076,8 @@ runInEachFileSystem(() => {
}
expect(classSymbol.name).toEqual('DecoratedWrappedClass');
expect(classSymbol.declaration.valueDeclaration).toBe(outerNode);
expect(classSymbol.implementation.valueDeclaration).toBe(innerNodes[0]);
expect(classSymbol.implementation.valueDeclaration)
.toBe(innerNodes[0] as ts.Declaration);
if (classSymbol.adjacent === undefined ||
!isNamedVariableDeclaration(classSymbol.adjacent.valueDeclaration)) {
@ -2112,7 +2113,8 @@ runInEachFileSystem(() => {
}
expect(classSymbol.name).toEqual('DecoratedWrappedClass');
expect(classSymbol.declaration.valueDeclaration).toBe(outerNode);
expect(classSymbol.implementation.valueDeclaration).toBe(innerNodes[0]);
expect(classSymbol.implementation.valueDeclaration)
.toBe(innerNodes[0] as ts.Declaration);
if (classSymbol.adjacent === undefined ||
!isNamedVariableDeclaration(classSymbol.adjacent.valueDeclaration)) {

11
packages/compiler-cli/ngcc/test/host/esm5_host_spec.ts
View File

@ -11,7 +11,7 @@ import * as ts from 'typescript';
import {absoluteFrom, getFileSystem, getSourceFileOrError} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {MockLogger} from '../../../src/ngtsc/logging/testing';
import {ClassMemberKind, ConcreteDeclaration, CtorParameter, Decorator, DownleveledEnum, isNamedClassDeclaration, isNamedFunctionDeclaration, isNamedVariableDeclaration, KnownDeclaration, TypeScriptReflectionHost, TypeValueReferenceKind} from '../../../src/ngtsc/reflection';
import {ClassMemberKind, ConcreteDeclaration, CtorParameter, DeclarationKind, Decorator, DownleveledEnum, isNamedClassDeclaration, isNamedFunctionDeclaration, isNamedVariableDeclaration, KnownDeclaration, TypeScriptReflectionHost, TypeValueReferenceKind} from '../../../src/ngtsc/reflection';
import {getDeclaration} from '../../../src/ngtsc/testing';
import {loadFakeCore, loadTestFiles} from '../../../test/helpers';
import {DelegatingReflectionHost} from '../../src/host/delegating_host';
@ -1858,6 +1858,7 @@ runInEachFileSystem(() => {
const helperDeclaration = host.getDeclarationOfIdentifier(helperIdentifier);
expect(helperDeclaration).toEqual({
kind: DeclarationKind.Concrete,
known: knownAs,
node: getHelperDeclaration(helperName),
viaModule,
@ -2253,9 +2254,9 @@ runInEachFileSystem(() => {
const helperDeclaration = host.getDeclarationOfIdentifier(helperIdentifier);
expect(helperDeclaration).toEqual({
kind: DeclarationKind.Inline,
known: knownAs,
expression: helperIdentifier,
node: null,
node: helperIdentifier,
viaModule: null,
});
};
@ -2284,9 +2285,9 @@ runInEachFileSystem(() => {
const helperDeclaration = host.getDeclarationOfIdentifier(helperIdentifier);
expect(helperDeclaration).toEqual({
kind: DeclarationKind.Inline,
known: knownAs,
expression: helperIdentifier,
node: null,
node: helperIdentifier,
viaModule: null,
});
};

21
packages/compiler-cli/ngcc/test/host/umd_host_spec.ts
View File

@ -11,7 +11,7 @@ import * as ts from 'typescript';
import {absoluteFrom, getFileSystem, getSourceFileOrError} from '../../../src/ngtsc/file_system';
import {runInEachFileSystem, TestFile} from '../../../src/ngtsc/file_system/testing';
import {MockLogger} from '../../../src/ngtsc/logging/testing';
import {ClassMemberKind, ConcreteDeclaration, CtorParameter, DownleveledEnum, Import, InlineDeclaration, isNamedClassDeclaration, isNamedFunctionDeclaration, isNamedVariableDeclaration, KnownDeclaration, TypeScriptReflectionHost, TypeValueReferenceKind} from '../../../src/ngtsc/reflection';
import {ClassMemberKind, ConcreteDeclaration, CtorParameter, DeclarationKind, DownleveledEnum, Import, InlineDeclaration, isNamedClassDeclaration, isNamedFunctionDeclaration, isNamedVariableDeclaration, KnownDeclaration, TypeScriptReflectionHost, TypeValueReferenceKind} from '../../../src/ngtsc/reflection';
import {getDeclaration} from '../../../src/ngtsc/testing';
import {loadFakeCore, loadTestFiles} from '../../../test/helpers';
import {isExportsStatement} from '../../src/host/commonjs_umd_utils';
@ -2003,6 +2003,7 @@ runInEachFileSystem(() => {
const helperDeclaration = host.getDeclarationOfIdentifier(helperIdentifier);
expect(helperDeclaration).toEqual({
kind: DeclarationKind.Concrete,
known: knownAs,
node: getHelperDeclaration(factoryFn, helperName),
viaModule,
@ -2410,9 +2411,9 @@ runInEachFileSystem(() => {
const helperDeclaration = host.getDeclarationOfIdentifier(helperIdentifier);
expect(helperDeclaration).toEqual({
kind: DeclarationKind.Inline,
known: knownAs,
expression: helperIdentifier,
node: null,
node: helperIdentifier,
viaModule: null,
});
};
@ -2449,9 +2450,9 @@ runInEachFileSystem(() => {
const helperDeclaration = host.getDeclarationOfIdentifier(helperIdentifier);
expect(helperDeclaration).toEqual({
kind: DeclarationKind.Inline,
known: knownAs,
expression: helperIdentifier,
node: null,
node: helperIdentifier,
viaModule: null,
});
};
@ -2697,10 +2698,10 @@ runInEachFileSystem(() => {
const file = getSourceFileOrError(bundle.program, INLINE_EXPORT_FILE.name);
const exportDeclarations = host.getExportsOfModule(file);
expect(exportDeclarations).not.toBe(null);
const decl = exportDeclarations!.get('directives') as InlineDeclaration;
expect(decl).not.toBeUndefined();
expect(decl.node).toBeNull();
expect(decl.expression).toBeDefined();
const decl = exportDeclarations!.get('directives')!;
expect(decl).toBeDefined();
expect(decl.node).toBeDefined();
expect(decl.kind).toEqual(DeclarationKind.Inline);
});
it('should recognize declarations of known TypeScript helpers', () => {
@ -2901,7 +2902,7 @@ runInEachFileSystem(() => {
const classSymbol = host.getClassSymbol(outerNode);
expect(classSymbol).toBeDefined();
expect(classSymbol!.declaration.valueDeclaration).toBe(outerNode);
expect(classSymbol!.declaration.valueDeclaration).toBe(outerNode as any);
expect(classSymbol!.implementation.valueDeclaration).toBe(innerNode);
});

4
packages/compiler-cli/src/ngtsc/annotations/src/component.ts
View File

@ -17,7 +17,7 @@ import {DependencyTracker} from '../../incremental/api';
import {IndexingContext} from '../../indexer';
import {ClassPropertyMapping, DirectiveMeta, DirectiveTypeCheckMeta, extractDirectiveTypeCheckMeta, InjectableClassRegistry, MetadataReader, MetadataRegistry, TemplateMapping} from '../../metadata';
import {EnumValue, PartialEvaluator} from '../../partial_evaluator';
import {ClassDeclaration, Decorator, ReflectionHost, reflectObjectLiteral} from '../../reflection';
import {ClassDeclaration, DeclarationNode, Decorator, ReflectionHost, reflectObjectLiteral} from '../../reflection';
import {ComponentScopeReader, LocalModuleScopeRegistry} from '../../scope';
import {AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerFlags, HandlerPrecedence, ResolveResult} from '../../transform';
import {TemplateSourceMapping, TypeCheckContext} from '../../typecheck/api';
@ -103,7 +103,7 @@ export class ComponentDecoratorHandler implements
* any potential <link> tags which might need to be loaded. This cache ensures that work is not
* thrown away, and the parsed template is reused during the analyze phase.
*/
private preanalyzeTemplateCache = new Map<ts.Declaration, ParsedTemplateWithSource>();
private preanalyzeTemplateCache = new Map<DeclarationNode, ParsedTemplateWithSource>();
readonly precedence = HandlerPrecedence.PRIMARY;
readonly name = ComponentDecoratorHandler.name;

7
packages/compiler-cli/src/ngtsc/annotations/src/metadata.ts
View File

@ -10,7 +10,7 @@ import {Expression, ExternalExpr, FunctionExpr, Identifiers, InvokeFunctionExpr,
import * as ts from 'typescript';
import {DefaultImportRecorder} from '../../imports';
import {CtorParameter, Decorator, ReflectionHost, TypeValueReferenceKind} from '../../reflection';
import {CtorParameter, DeclarationNode, Decorator, ReflectionHost, TypeValueReferenceKind} from '../../reflection';
import {valueReferenceToExpression, wrapFunctionExpressionsInParens} from './util';
@ -23,8 +23,9 @@ import {valueReferenceToExpression, wrapFunctionExpressionsInParens} from './uti
* as a `Statement` for inclusion along with the class.
*/
export function generateSetClassMetadataCall(
clazz: ts.Declaration, reflection: ReflectionHost, defaultImportRecorder: DefaultImportRecorder,
isCore: boolean, annotateForClosureCompiler?: boolean): Statement|null {
clazz: DeclarationNode, reflection: ReflectionHost,
defaultImportRecorder: DefaultImportRecorder, isCore: boolean,
annotateForClosureCompiler?: boolean): Statement|null {
if (!reflection.isClass(clazz)) {
return null;
}

8
packages/compiler-cli/src/ngtsc/annotations/src/ng_module.ts
View File

@ -13,7 +13,7 @@ import {ErrorCode, FatalDiagnosticError, makeDiagnostic, makeRelatedInformation}
import {DefaultImportRecorder, Reference, ReferenceEmitter} from '../../imports';
import {InjectableClassRegistry, MetadataReader, MetadataRegistry} from '../../metadata';
import {PartialEvaluator, ResolvedValue} from '../../partial_evaluator';
import {ClassDeclaration, Decorator, ReflectionHost, reflectObjectLiteral, typeNodeToValueExpr} from '../../reflection';
import {ClassDeclaration, DeclarationNode, Decorator, isNamedClassDeclaration, ReflectionHost, reflectObjectLiteral, typeNodeToValueExpr} from '../../reflection';
import {NgModuleRouteAnalyzer} from '../../routing';
import {LocalModuleScopeRegistry, ScopeData} from '../../scope';
import {FactoryTracker} from '../../shims/api';
@ -434,14 +434,14 @@ export class NgModuleDecoratorHandler implements
}
private _toR3Reference(
valueRef: Reference<ts.Declaration>, valueContext: ts.SourceFile,
valueRef: Reference<ClassDeclaration>, valueContext: ts.SourceFile,
typeContext: ts.SourceFile): R3Reference {
if (valueRef.hasOwningModuleGuess) {
return toR3Reference(valueRef, valueRef, valueContext, valueContext, this.refEmitter);
} else {
let typeRef = valueRef;
let typeNode = this.reflector.getDtsDeclaration(typeRef.node);
if (typeNode !== null && ts.isClassDeclaration(typeNode)) {
if (typeNode !== null && isNamedClassDeclaration(typeNode)) {
typeRef = new Reference(typeNode);
}
return toR3Reference(valueRef, typeRef, valueContext, typeContext, this.refEmitter);
@ -539,7 +539,7 @@ export class NgModuleDecoratorHandler implements
return null;
}
// Verify that a `ts.Declaration` reference is a `ClassDeclaration` reference.
// Verify that a "Declaration" reference is a `ClassDeclaration` reference.
private isClassDeclarationReference(ref: Reference): ref is Reference<ClassDeclaration> {
return this.reflector.isClass(ref.node);
}

6
packages/compiler-cli/src/ngtsc/annotations/src/references_registry.ts
View File

@ -6,8 +6,8 @@
* found in the LICENSE file at https://angular.io/license
*/
import * as ts from 'typescript';
import {Reference} from '../../imports';
import {DeclarationNode} from '../../reflection';
/**
* Implement this interface if you want DecoratorHandlers to register
@ -18,7 +18,7 @@ export interface ReferencesRegistry {
* Register one or more references in the registry.
* @param references A collection of references to register.
*/
add(source: ts.Declaration, ...references: Reference<ts.Declaration>[]): void;
add(source: DeclarationNode, ...references: Reference<DeclarationNode>[]): void;
}
/**
@ -27,5 +27,5 @@ export interface ReferencesRegistry {
* The ngcc tool implements a working version for its purposes.
*/
export class NoopReferencesRegistry implements ReferencesRegistry {
add(source: ts.Declaration, ...references: Reference<ts.Declaration>[]): void {}
add(source: DeclarationNode, ...references: Reference<DeclarationNode>[]): void {}
}

8
packages/compiler-cli/src/ngtsc/core/src/compiler.ts
View File

@ -21,7 +21,7 @@ import {CompoundMetadataReader, CompoundMetadataRegistry, DtsMetadataReader, Inj
import {ModuleWithProvidersScanner} from '../../modulewithproviders';
import {PartialEvaluator} from '../../partial_evaluator';
import {NOOP_PERF_RECORDER, PerfRecorder} from '../../perf';
import {ClassDeclaration, TypeScriptReflectionHost} from '../../reflection';
import {DeclarationNode, TypeScriptReflectionHost} from '../../reflection';
import {AdapterResourceLoader} from '../../resource';
import {entryPointKeyFor, NgModuleRouteAnalyzer} from '../../routing';
import {ComponentScopeReader, LocalModuleScopeRegistry, MetadataDtsModuleScopeResolver} from '../../scope';
@ -238,7 +238,7 @@ export class NgCompiler {
/**
* Retrieves the `ts.Declaration`s for any component(s) which use the given template file.
*/
getComponentsWithTemplateFile(templateFilePath: string): ReadonlySet<ts.Declaration> {
getComponentsWithTemplateFile(templateFilePath: string): ReadonlySet<DeclarationNode> {
const {templateMapping} = this.ensureAnalyzed();
return templateMapping.getComponentsWithTemplate(resolve(templateFilePath));
}
@ -378,7 +378,7 @@ export class NgCompiler {
*
* See the `indexing` package for more details.
*/
getIndexedComponents(): Map<ts.Declaration, IndexedComponent> {
getIndexedComponents(): Map<DeclarationNode, IndexedComponent> {
const compilation = this.ensureAnalyzed();
const context = new IndexingContext();
compilation.traitCompiler.index(context);
@ -880,7 +880,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
class ReferenceGraphAdapter implements ReferencesRegistry {
constructor(private graph: ReferenceGraph) {}
add(source: ts.Declaration, ...references: Reference<ts.Declaration>[]): void {
add(source: DeclarationNode, ...references: Reference<DeclarationNode>[]): void {
for (const {node} of references) {
let sourceFile = node.getSourceFile();
if (sourceFile === undefined) {

1
packages/compiler-cli/src/ngtsc/entry_point/BUILD.bazel
View File

@ -11,6 +11,7 @@ ts_library(
deps = [
"//packages/compiler-cli/src/ngtsc/diagnostics",
"//packages/compiler-cli/src/ngtsc/file_system",
"//packages/compiler-cli/src/ngtsc/reflection",
"//packages/compiler-cli/src/ngtsc/shims:api",
"//packages/compiler-cli/src/ngtsc/util",
"@npm//@types/node",

13
packages/compiler-cli/src/ngtsc/entry_point/src/private_export_checker.ts
View File

@ -9,6 +9,7 @@
import * as ts from 'typescript';
import {ErrorCode, ngErrorCode} from '../../diagnostics';
import {DeclarationNode} from '../../reflection';
import {ReferenceGraph} from './reference_graph';
@ -39,7 +40,7 @@ export function checkForPrivateExports(
const diagnostics: ts.Diagnostic[] = [];
// Firstly, compute the exports of the entry point. These are all the Exported classes.
const topLevelExports = new Set<ts.Declaration>();
const topLevelExports = new Set<DeclarationNode>();
// Do this via `ts.TypeChecker.getExportsOfModule`.
const moduleSymbol = checker.getSymbolAtLocation(entryPoint);
@ -63,7 +64,7 @@ export function checkForPrivateExports(
// Next, go through each exported class and expand it to the set of classes it makes Visible,
// using the `ReferenceGraph`. For each Visible class, verify that it's also Exported, and queue
// an error if it isn't. `checkedSet` ensures only one error is queued per class.
const checkedSet = new Set<ts.Declaration>();
const checkedSet = new Set<DeclarationNode>();
// Loop through each Exported class.
// TODO(alxhub): use proper iteration when the legacy build is removed. (#27762)
@ -110,7 +111,7 @@ export function checkForPrivateExports(
return diagnostics;
}
function getPosOfDeclaration(decl: ts.Declaration): {start: number, length: number} {
function getPosOfDeclaration(decl: DeclarationNode): {start: number, length: number} {
const node: ts.Node = getIdentifierOfDeclaration(decl) || decl;
return {
start: node.getStart(),
@ -118,7 +119,7 @@ function getPosOfDeclaration(decl: ts.Declaration): {start: number, length: numb
};
}
function getIdentifierOfDeclaration(decl: ts.Declaration): ts.Identifier|null {
function getIdentifierOfDeclaration(decl: DeclarationNode): ts.Identifier|null {
if ((ts.isClassDeclaration(decl) || ts.isVariableDeclaration(decl) ||
ts.isFunctionDeclaration(decl)) &&
decl.name !== undefined && ts.isIdentifier(decl.name)) {
@ -128,12 +129,12 @@ function getIdentifierOfDeclaration(decl: ts.Declaration): ts.Identifier|null {
}
}
function getNameOfDeclaration(decl: ts.Declaration): string {
function getNameOfDeclaration(decl: DeclarationNode): string {
const id = getIdentifierOfDeclaration(decl);
return id !== null ? id.text : '(unnamed)';
}
function getDescriptorOfDeclaration(decl: ts.Declaration): string {
function getDescriptorOfDeclaration(decl: DeclarationNode): string {
switch (decl.kind) {
case ts.SyntaxKind.ClassDeclaration:
return 'class';

4
packages/compiler-cli/src/ngtsc/entry_point/src/reference_graph.ts
View File

@ -6,9 +6,9 @@
* found in the LICENSE file at https://angular.io/license
*/
import * as ts from 'typescript';
import {DeclarationNode} from '../../reflection';
export class ReferenceGraph<T = ts.Declaration> {
export class ReferenceGraph<T = DeclarationNode> {
private references = new Map<T, Set<T>>();
add(from: T, to: T): void {

16
packages/compiler-cli/src/ngtsc/imports/src/emitter.ts
View File

@ -11,7 +11,7 @@ import * as ts from 'typescript';
import {UnifiedModulesHost} from '../../core/api';
import {absoluteFromSourceFile, dirname, LogicalFileSystem, LogicalProjectPath, relative, toRelativeImport} from '../../file_system';
import {stripExtension} from '../../file_system/src/util';
import {ReflectionHost} from '../../reflection';
import {DeclarationNode, isConcreteDeclaration, ReflectionHost} from '../../reflection';
import {getSourceFile, isDeclaration, isTypeDeclaration, nodeNameForError} from '../../util/src/typescript';
import {findExportedNameOfNode} from './find_export';
@ -136,7 +136,7 @@ export class AbsoluteModuleStrategy implements ReferenceEmitStrategy {
* A cache of the exports of specific modules, because resolving a module to its exports is a
* costly operation.
*/
private moduleExportsCache = new Map<string, Map<ts.Declaration, string>|null>();
private moduleExportsCache = new Map<string, Map<DeclarationNode, string>|null>();
constructor(
protected program: ts.Program, protected checker: ts.TypeChecker,
@ -170,7 +170,7 @@ export class AbsoluteModuleStrategy implements ReferenceEmitStrategy {
return new ExternalExpr(new ExternalReference(specifier, symbolName));
}
private resolveImportName(moduleName: string, target: ts.Declaration, fromFile: string): string
private resolveImportName(moduleName: string, target: DeclarationNode, fromFile: string): string
|null {
const exports = this.getExportsOfModule(moduleName, fromFile);
if (exports !== null && exports.has(target)) {
@ -181,7 +181,7 @@ export class AbsoluteModuleStrategy implements ReferenceEmitStrategy {
}
private getExportsOfModule(moduleName: string, fromFile: string):
Map<ts.Declaration, string>|null {
Map<DeclarationNode, string>|null {
if (!this.moduleExportsCache.has(moduleName)) {
this.moduleExportsCache.set(moduleName, this.enumerateExportsOfModule(moduleName, fromFile));
}
@ -189,7 +189,7 @@ export class AbsoluteModuleStrategy implements ReferenceEmitStrategy {
}
protected enumerateExportsOfModule(specifier: string, fromFile: string):
Map<ts.Declaration, string>|null {
Map<DeclarationNode, string>|null {
// First, resolve the module specifier to its entry point, and get the ts.Symbol for it.
const entryPointFile = this.moduleResolver.resolveModule(specifier, fromFile);
if (entryPointFile === null) {
@ -200,13 +200,9 @@ export class AbsoluteModuleStrategy implements ReferenceEmitStrategy {
if (exports === null) {
return null;
}
const exportMap = new Map<ts.Declaration, string>();
const exportMap = new Map<DeclarationNode, string>();
exports.forEach((declaration, name) => {
// It's okay to skip inline declarations, since by definition they're not target-able with a
// ts.Declaration anyway.
if (declaration.node !== null) {
exportMap.set(declaration.node, name);
}
});
return exportMap;
}

5
packages/compiler-cli/src/ngtsc/indexer/src/api.ts
View File

@ -7,8 +7,7 @@
*/
import {ParseSourceFile} from '@angular/compiler';
import * as ts from 'typescript';
import {ClassDeclaration} from '../../reflection';
import {ClassDeclaration, DeclarationNode} from '../../reflection';
/**
* Describes the kind of identifier found in a template.
@ -129,7 +128,7 @@ export interface IndexedComponent {
file: ParseSourceFile;
template: {
identifiers: Set<TopLevelIdentifier>,
usedComponents: Set<ts.Declaration>,
usedComponents: Set<DeclarationNode>,
isInline: boolean,
file: ParseSourceFile;
};

8
packages/compiler-cli/src/ngtsc/indexer/src/transform.ts
View File

@ -7,7 +7,7 @@
*/
import {ParseSourceFile} from '@angular/compiler';
import * as ts from 'typescript';
import {DeclarationNode} from '../../reflection';
import {IndexedComponent} from './api';
import {IndexingContext} from './context';
import {getTemplateIdentifiers} from './template';
@ -18,13 +18,13 @@ import {getTemplateIdentifiers} from './template';
*
* The context must be populated before `generateAnalysis` is called.
*/
export function generateAnalysis(context: IndexingContext): Map<ts.Declaration, IndexedComponent> {
const analysis = new Map<ts.Declaration, IndexedComponent>();
export function generateAnalysis(context: IndexingContext): Map<DeclarationNode, IndexedComponent> {
const analysis = new Map<DeclarationNode, IndexedComponent>();
context.components.forEach(({declaration, selector, boundTemplate, templateMeta}) => {
const name = declaration.name.getText();
const usedComponents = new Set<ts.Declaration>();
const usedComponents = new Set<DeclarationNode>();
const usedDirs = boundTemplate.getUsedDirectives();
usedDirs.forEach(dir => {
if (dir.isComponent) {

2
packages/compiler-cli/src/ngtsc/indexer/test/util.ts
View File

@ -29,7 +29,7 @@ export function getComponentDeclaration(componentStr: string, className: string)
return getDeclaration(
program.program, getTestFilePath(), className,
(value: ts.Declaration): value is ClassDeclaration => ts.isClassDeclaration(value));
(value: ts.Node): value is ClassDeclaration => ts.isClassDeclaration(value));
}
/**

26
packages/compiler-cli/src/ngtsc/partial_evaluator/src/interpreter.ts
View File

@ -11,7 +11,7 @@ import * as ts from 'typescript';
import {Reference} from '../../imports';
import {OwningModule} from '../../imports/src/references';
import {DependencyTracker} from '../../incremental/api';
import {ConcreteDeclaration, Declaration, EnumMember, FunctionDefinition, InlineDeclaration, ReflectionHost, SpecialDeclarationKind} from '../../reflection';
import {Declaration, DeclarationNode, EnumMember, FunctionDefinition, isConcreteDeclaration, ReflectionHost, SpecialDeclarationKind} from '../../reflection';
import {isDeclaration} from '../../util/src/typescript';
import {ArrayConcatBuiltinFn, ArraySliceBuiltinFn} from './builtin';
@ -231,12 +231,7 @@ export class StaticInterpreter {
return this.getResolvedEnum(decl.node, decl.identity.enumMembers, context);
}
const declContext = {...context, ...joinModuleContext(context, node, decl)};
// The identifier's declaration is either concrete (a ts.Declaration exists for it) or inline
// (a direct reference to a ts.Expression).
// TODO(alxhub): remove cast once TS is upgraded in g3.
const result = decl.node !== null ?
this.visitDeclaration(decl.node, declContext) :
this.visitExpression((decl as InlineDeclaration).expression, declContext);
const result = this.visitDeclaration(decl.node, declContext);
if (result instanceof Reference) {
// Only record identifiers to non-synthetic references. Synthetic references may not have the
// same value at runtime as they do at compile time, so it's not legal to refer to them by the
@ -250,7 +245,7 @@ export class StaticInterpreter {
return result;
}
private visitDeclaration(node: ts.Declaration, context: Context): ResolvedValue {
private visitDeclaration(node: DeclarationNode, context: Context): ResolvedValue {
if (this.dependencyTracker !== null) {
this.dependencyTracker.addDependency(context.originatingFile, node.getSourceFile());
}
@ -342,10 +337,7 @@ export class StaticInterpreter {
};
// Visit both concrete and inline declarations.
// TODO(alxhub): remove cast once TS is upgraded in g3.
return decl.node !== null ?
this.visitDeclaration(decl.node, declContext) :
this.visitExpression((decl as InlineDeclaration).expression, declContext);
return this.visitDeclaration(decl.node, declContext);
});
}
@ -667,7 +659,7 @@ export class StaticInterpreter {
return map;
}
private getReference<T extends ts.Declaration>(node: T, context: Context): Reference<T> {
private getReference<T extends DeclarationNode>(node: T, context: Context): Reference<T> {
return new Reference(node, owningModule(context));
}
}
@ -733,11 +725,3 @@ function owningModule(context: Context, override: OwningModule|null = null): Own
return null;
}
}
/**
* Helper type guard to workaround a narrowing limitation in g3, where testing for
* `decl.node !== null` would not narrow `decl` to be of type `ConcreteDeclaration`.
*/
function isConcreteDeclaration(decl: Declaration): decl is ConcreteDeclaration {
return decl.node !== null;
}

9
packages/compiler-cli/src/ngtsc/partial_evaluator/test/evaluator_spec.ts
View File

@ -11,7 +11,7 @@ import {absoluteFrom, getSourceFileOrError} from '../../file_system';
import {runInEachFileSystem} from '../../file_system/testing';
import {Reference} from '../../imports';
import {DependencyTracker} from '../../incremental/api';
import {Declaration, KnownDeclaration, SpecialDeclarationKind, TypeScriptReflectionHost} from '../../reflection';
import {Declaration, DeclarationKind, isConcreteDeclaration, KnownDeclaration, SpecialDeclarationKind, TypeScriptReflectionHost} from '../../reflection';
import {getDeclaration, makeProgram} from '../../testing';
import {DynamicValue} from '../src/dynamic';
import {PartialEvaluator} from '../src/interface';
@ -920,7 +920,7 @@ runInEachFileSystem(() => {
class DownleveledEnumReflectionHost extends TypeScriptReflectionHost {
getDeclarationOfIdentifier(id: ts.Identifier): Declaration|null {
const declaration = super.getDeclarationOfIdentifier(id);
if (declaration !== null && declaration.node !== null) {
if (declaration !== null && isConcreteDeclaration(declaration)) {
const enumMembers = [
{name: ts.createStringLiteral('ValueA'), initializer: ts.createStringLiteral('a')},
{name: ts.createStringLiteral('ValueB'), initializer: ts.createStringLiteral('b')},
@ -961,6 +961,7 @@ runInEachFileSystem(() => {
node: id,
viaModule: null,
identity: null,
kind: DeclarationKind.Concrete,
};
}
@ -968,8 +969,8 @@ runInEachFileSystem(() => {
}
}
function getTsHelperFn(node: ts.Declaration): KnownDeclaration|null {
const id = (node as ts.Declaration & {name?: ts.Identifier}).name || null;
function getTsHelperFn(node: ts.Node): KnownDeclaration|null {
const id = (node as ts.Node & {name?: ts.Identifier}).name || null;
const name = id && id.text;
switch (name) {

1
packages/compiler-cli/src/ngtsc/perf/BUILD.bazel
View File

@ -10,6 +10,7 @@ ts_library(
deps = [
"//packages:types",
"//packages/compiler-cli/src/ngtsc/file_system",
"//packages/compiler-cli/src/ngtsc/reflection",
"@npm//@types/node",
"@npm//typescript",
],

7
packages/compiler-cli/src/ngtsc/perf/src/api.ts
View File

@ -6,13 +6,12 @@
* found in the LICENSE file at https://angular.io/license
*/
import * as ts from 'typescript';
import {DeclarationNode} from '../../reflection';
export interface PerfRecorder {
readonly enabled: boolean;
mark(name: string, node?: ts.SourceFile|ts.Declaration, category?: string, detail?: string): void;
start(name: string, node?: ts.SourceFile|ts.Declaration, category?: string, detail?: string):
number;
mark(name: string, node?: DeclarationNode, category?: string, detail?: string): void;
start(name: string, node?: DeclarationNode, category?: string, detail?: string): number;
stop(span: number): void;
}

9
packages/compiler-cli/src/ngtsc/perf/src/noop.ts
View File

@ -5,17 +5,14 @@
* 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 {DeclarationNode} from '../../reflection';
import {PerfRecorder} from './api';
export const NOOP_PERF_RECORDER: PerfRecorder = {
enabled: false,
mark: (name: string, node: ts.SourceFile|ts.Declaration, category?: string, detail?: string):
void => {},
start: (name: string, node: ts.SourceFile|ts.Declaration, category?: string, detail?: string):
number => {
mark: (name: string, node: DeclarationNode, category?: string, detail?: string): void => {},
start: (name: string, node: DeclarationNode, category?: string, detail?: string): number => {
return 0;
},
stop: (span: number|false): void => {},

9
packages/compiler-cli/src/ngtsc/perf/src/tracking.ts
View File

@ -9,6 +9,7 @@
import * as fs from 'fs';
import * as ts from 'typescript';
import {resolve} from '../../file_system';
import {DeclarationNode} from '../../reflection';
import {PerfRecorder} from './api';
import {HrTime, mark, timeSinceInMicros} from './clock';
@ -24,14 +25,12 @@ export class PerfTracker implements PerfRecorder {
return new PerfTracker(mark());
}
mark(name: string, node?: ts.SourceFile|ts.Declaration, category?: string, detail?: string):
void {
mark(name: string, node?: DeclarationNode, category?: string, detail?: string): void {
const msg = this.makeLogMessage(PerfLogEventType.MARK, name, node, category, detail, undefined);
this.log.push(msg);
}
start(name: string, node?: ts.SourceFile|ts.Declaration, category?: string, detail?: string):
number {
start(name: string, node?: DeclarationNode, category?: string, detail?: string): number {
const span = this.nextSpanId++;
const msg = this.makeLogMessage(PerfLogEventType.SPAN_OPEN, name, node, category, detail, span);
this.log.push(msg);
@ -47,7 +46,7 @@ export class PerfTracker implements PerfRecorder {
}
private makeLogMessage(
type: PerfLogEventType, name: string, node: ts.SourceFile|ts.Declaration|undefined,
type: PerfLogEventType, name: string, node: DeclarationNode|undefined,
category: string|undefined, detail: string|undefined, span: number|undefined): PerfLogEvent {
const msg: PerfLogEvent = {
type,

3
packages/compiler-cli/src/ngtsc/program.ts
View File

@ -17,6 +17,7 @@ import {NgCompilerOptions} from './core/api';
import {TrackedIncrementalBuildStrategy} from './incremental';
import {IndexedComponent} from './indexer';
import {NOOP_PERF_RECORDER, PerfRecorder, PerfTracker} from './perf';
import {DeclarationNode} from './reflection';
import {retagAllTsFiles, untagAllTsFiles} from './shims';
import {ReusedProgramStrategy} from './typecheck';
@ -276,7 +277,7 @@ export class NgtscProgram implements api.Program {
return ((opts && opts.mergeEmitResultsCallback) || mergeEmitResults)(emitResults);
}
getIndexedComponents(): Map<ts.Declaration, IndexedComponent> {
getIndexedComponents(): Map<DeclarationNode, IndexedComponent> {
return this.compiler.getIndexedComponents();
}

68
packages/compiler-cli/src/ngtsc/reflection/src/host.ts
View File

@ -113,7 +113,7 @@ export function isDecoratorIdentifier(exp: ts.Expression): exp is DecoratorIdent
* For `ReflectionHost` purposes, a class declaration should always have a `name` identifier,
* because we need to be able to reference it in other parts of the program.
*/
export type ClassDeclaration<T extends ts.Declaration = ts.Declaration> = T&{name: ts.Identifier};
export type ClassDeclaration<T extends DeclarationNode = DeclarationNode> = T&{name: ts.Identifier};
/**
* An enumeration of possible kinds of class members.
@ -275,7 +275,7 @@ export interface ImportedTypeValueReference {
*/
nestedPath: string[]|null;
valueDeclaration: ts.Declaration;
valueDeclaration: DeclarationNode;
}
/**
@ -530,10 +530,38 @@ export interface EnumMember {
initializer: ts.Expression;
}
/**
* A type that is used to identify a declaration.
*
* Declarations are normally `ts.Declaration` types such as variable declarations, class
* declarations, function declarations etc.
* But in some cases there is no `ts.Declaration` that can be used for a declaration, such
* as when they are declared inline as part of an exported expression. Then we must use a
* `ts.Expression` as the declaration.
* An example of this is `exports.someVar = 42` where the declaration expression would be
* `exports.someVar`.
*/
export type DeclarationNode = ts.Declaration|ts.Expression;
/**
* The type of a Declaration - whether its node is concrete (ts.Declaration) or inline
* (ts.Expression). See `ConcreteDeclaration`, `InlineDeclaration` and `DeclarationNode` for more
* information about this.
*/
export const enum DeclarationKind {
Concrete,
Inline,
}
/**
* Base type for all `Declaration`s.
*/
export interface BaseDeclaration<T extends ts.Declaration = ts.Declaration> {
export interface BaseDeclaration<T extends DeclarationNode> {
/**
* The type of the underlying `node`.
*/
kind: DeclarationKind;
/**
* The absolute module path from which the symbol was imported into the application, if the symbol
* was imported via an absolute module (even through a chain of re-exports). If the symbol is part
@ -544,7 +572,7 @@ export interface BaseDeclaration<T extends ts.Declaration = ts.Declaration> {
/**
* TypeScript reference to the declaration itself, if one exists.
*/
node: T|null;
node: T;
/**
* If set, describes the type of the known declaration this declaration resolves to.
@ -553,13 +581,16 @@ export interface BaseDeclaration<T extends ts.Declaration = ts.Declaration> {
}
/**
* A declaration that has an associated TypeScript `ts.Declaration`.
*
* The alternative is an `InlineDeclaration`.
* Returns true if the `decl` is a `ConcreteDeclaration` (ie. that its `node` property is a
* `ts.Declaration`).
*/
export function isConcreteDeclaration(decl: Declaration): decl is ConcreteDeclaration {
return decl.kind === DeclarationKind.Concrete;
}
export interface ConcreteDeclaration<T extends ts.Declaration = ts.Declaration> extends
BaseDeclaration<T> {
node: T;
kind: DeclarationKind.Concrete;
/**
* Optionally represents a special identity of the declaration, or `null` if the declaration
@ -585,29 +616,20 @@ export interface DownleveledEnum {
}
/**
* A declaration that does not have an associated TypeScript `ts.Declaration`, only a
* `ts.Expression`.
* A declaration that does not have an associated TypeScript `ts.Declaration`.
*
* This can occur in some downlevelings when an `export const VAR = ...;` (a `ts.Declaration`) is
* transpiled to an assignment statement (e.g. `exports.VAR = ...;`). There is no `ts.Declaration`
* associated with `VAR` in that case, only an expression.
*/
export interface InlineDeclaration extends BaseDeclaration {
node: null;
/**
* The `ts.Expression` which constitutes the value of the declaration.
*/
expression: ts.Expression;
export interface InlineDeclaration extends
BaseDeclaration<Exclude<DeclarationNode, ts.Declaration>> {
kind: DeclarationKind.Inline;
}
/**
* The declaration of a symbol, along with information about how it was imported into the
* application.
*
* This can either be a `ConcreteDeclaration` if the underlying TypeScript node for the symbol is an
* actual `ts.Declaration`, or an `InlineDeclaration` if the declaration was transpiled in certain
* downlevelings to a `ts.Expression` instead.
*/
export type Declaration<T extends ts.Declaration = ts.Declaration> =
ConcreteDeclaration<T>|InlineDeclaration;
@ -637,7 +659,7 @@ export interface ReflectionHost {
* @returns an array of `Decorator` metadata if decorators are present on the declaration, or
* `null` if either no decorators were present or if the declaration is not of a decoratable type.
*/
getDecoratorsOfDeclaration(declaration: ts.Declaration): Decorator[]|null;
getDecoratorsOfDeclaration(declaration: DeclarationNode): Decorator[]|null;
/**
* Examine a declaration which should be of a class, and return metadata about the members of the
@ -802,7 +824,7 @@ export interface ReflectionHost {
* Note that the `ts.Declaration` returned from this function may not be from the same
* `ts.Program` as the input declaration.
*/
getDtsDeclaration(declaration: ts.Declaration): ts.Declaration|null;
getDtsDeclaration(declaration: DeclarationNode): ts.Declaration|null;
/**
* Get a `ts.Identifier` for a given `ClassDeclaration` which can be used to refer to the class

10
packages/compiler-cli/src/ngtsc/reflection/src/typescript.ts
View File

@ -8,7 +8,7 @@
import * as ts from 'typescript';
import {ClassDeclaration, ClassMember, ClassMemberKind, CtorParameter, Declaration, Decorator, FunctionDefinition, Import, isDecoratorIdentifier, ReflectionHost} from './host';
import {ClassDeclaration, ClassMember, ClassMemberKind, CtorParameter, Declaration, DeclarationKind, DeclarationNode, Decorator, FunctionDefinition, Import, isDecoratorIdentifier, ReflectionHost} from './host';
import {typeToValue} from './type_to_value';
import {isNamedClassDeclaration} from './util';
@ -19,7 +19,7 @@ import {isNamedClassDeclaration} from './util';
export class TypeScriptReflectionHost implements ReflectionHost {
constructor(protected checker: ts.TypeChecker) {}
getDecoratorsOfDeclaration(declaration: ts.Declaration): Decorator[]|null {
getDecoratorsOfDeclaration(declaration: DeclarationNode): Decorator[]|null {
if (declaration.decorators === undefined || declaration.decorators.length === 0) {
return null;
}
@ -187,7 +187,7 @@ export class TypeScriptReflectionHost implements ReflectionHost {
return declaration.initializer || null;
}
getDtsDeclaration(_: ts.Declaration): ts.Declaration|null {
getDtsDeclaration(_: ClassDeclaration): ts.Declaration|null {
return null;
}
@ -207,7 +207,7 @@ export class TypeScriptReflectionHost implements ReflectionHost {
return null;
}
const decl: ts.Declaration = symbol.declarations[0];
const decl = symbol.declarations[0];
const importDecl = getContainingImportDeclaration(decl);
// Ignore declarations that are defined locally (not imported).
@ -318,6 +318,7 @@ export class TypeScriptReflectionHost implements ReflectionHost {
known: null,
viaModule,
identity: null,
kind: DeclarationKind.Concrete,
};
} else if (symbol.declarations !== undefined && symbol.declarations.length > 0) {
return {
@ -325,6 +326,7 @@ export class TypeScriptReflectionHost implements ReflectionHost {
known: null,
viaModule,
identity: null,
kind: DeclarationKind.Concrete,
};
} else {
return null;

4
packages/compiler-cli/src/ngtsc/reflection/test/ts_host_spec.ts
View File

@ -9,7 +9,7 @@ import * as ts from 'typescript';
import {absoluteFrom, getSourceFileOrError} from '../../file_system';
import {runInEachFileSystem} from '../../file_system/testing';
import {getDeclaration, makeProgram} from '../../testing';
import {ClassMember, ClassMemberKind, CtorParameter, TypeValueReferenceKind} from '../src/host';
import {ClassMember, ClassMemberKind, CtorParameter, DeclarationKind, TypeValueReferenceKind} from '../src/host';
import {TypeScriptReflectionHost} from '../src/typescript';
import {isNamedClassDeclaration} from '../src/util';
@ -360,6 +360,7 @@ runInEachFileSystem(() => {
const Target = foo.type.typeName;
const decl = host.getDeclarationOfIdentifier(Target);
expect(decl).toEqual({
kind: DeclarationKind.Concrete,
node: targetDecl,
known: null,
viaModule: 'absolute',
@ -395,6 +396,7 @@ runInEachFileSystem(() => {
known: null,
viaModule: 'absolute',
identity: null,
kind: DeclarationKind.Concrete
});
});
});

22
packages/compiler-cli/src/ngtsc/scope/src/local.ts
View File

@ -12,7 +12,7 @@ import * as ts from 'typescript';
import {ErrorCode, makeDiagnostic, makeRelatedInformation} from '../../diagnostics';
import {AliasingHost, Reexport, Reference, ReferenceEmitter} from '../../imports';
import {DirectiveMeta, MetadataReader, MetadataRegistry, NgModuleMeta, PipeMeta} from '../../metadata';
import {ClassDeclaration} from '../../reflection';
import {ClassDeclaration, DeclarationNode} from '../../reflection';
import {identifierOfNode, nodeNameForError} from '../../util/src/typescript';
import {ExportScope, ScopeData} from './api';
@ -293,14 +293,14 @@ export class LocalModuleScopeRegistry implements MetadataRegistry, ComponentScop
// - the directives and pipes which are exported to any NgModules which import this one.
// Directives and pipes in the compilation scope.
const compilationDirectives = new Map<ts.Declaration, DirectiveMeta>();
const compilationPipes = new Map<ts.Declaration, PipeMeta>();
const compilationDirectives = new Map<DeclarationNode, DirectiveMeta>();
const compilationPipes = new Map<DeclarationNode, PipeMeta>();
const declared = new Set<ts.Declaration>();
const declared = new Set<DeclarationNode>();
// Directives and pipes exported to any importing NgModules.
const exportDirectives = new Map<ts.Declaration, DirectiveMeta>();
const exportPipes = new Map<ts.Declaration, PipeMeta>();
const exportDirectives = new Map<DeclarationNode, DirectiveMeta>();
const exportPipes = new Map<DeclarationNode, PipeMeta>();
// The algorithm is as follows:
// 1) Add all of the directives/pipes from each NgModule imported into the current one to the
@ -477,7 +477,7 @@ export class LocalModuleScopeRegistry implements MetadataRegistry, ComponentScop
*/
private getExportedScope(
ref: Reference<ClassDeclaration>, diagnostics: ts.Diagnostic[],
ownerForErrors: ts.Declaration, type: 'import'|'export'): ExportScope|null|undefined {
ownerForErrors: DeclarationNode, type: 'import'|'export'): ExportScope|null|undefined {
if (ref.node.getSourceFile().isDeclarationFile) {
// The NgModule is declared in a .d.ts file. Resolve it with the `DependencyScopeReader`.
if (!ts.isClassDeclaration(ref.node)) {
@ -499,7 +499,7 @@ export class LocalModuleScopeRegistry implements MetadataRegistry, ComponentScop
}
private getReexports(
ngModule: NgModuleMeta, ref: Reference<ClassDeclaration>, declared: Set<ts.Declaration>,
ngModule: NgModuleMeta, ref: Reference<ClassDeclaration>, declared: Set<DeclarationNode>,
exported: {directives: DirectiveMeta[], pipes: PipeMeta[]},
diagnostics: ts.Diagnostic[]): Reexport[]|null {
let reexports: Reexport[]|null = null;
@ -569,7 +569,7 @@ export class LocalModuleScopeRegistry implements MetadataRegistry, ComponentScop
* Produce a `ts.Diagnostic` for an invalid import or export from an NgModule.
*/
function invalidRef(
clazz: ts.Declaration, decl: Reference<ts.Declaration>,
clazz: DeclarationNode, decl: Reference<DeclarationNode>,
type: 'import'|'export'): ts.Diagnostic {
const code =
type === 'import' ? ErrorCode.NGMODULE_INVALID_IMPORT : ErrorCode.NGMODULE_INVALID_EXPORT;
@ -607,7 +607,7 @@ function invalidRef(
* Produce a `ts.Diagnostic` for an import or export which itself has errors.
*/
function invalidTransitiveNgModuleRef(
clazz: ts.Declaration, decl: Reference<ts.Declaration>,
clazz: DeclarationNode, decl: Reference<DeclarationNode>,
type: 'import'|'export'): ts.Diagnostic {
const code =
type === 'import' ? ErrorCode.NGMODULE_INVALID_IMPORT : ErrorCode.NGMODULE_INVALID_EXPORT;
@ -620,7 +620,7 @@ function invalidTransitiveNgModuleRef(
* Produce a `ts.Diagnostic` for an exported directive or pipe which was not declared or imported
* by the NgModule in question.
*/
function invalidReexport(clazz: ts.Declaration, decl: Reference<ts.Declaration>): ts.Diagnostic {
function invalidReexport(clazz: DeclarationNode, decl: Reference<DeclarationNode>): ts.Diagnostic {
return makeDiagnostic(
ErrorCode.NGMODULE_INVALID_REEXPORT, identifierOfNode(decl.node) || decl.node,
`Present in the NgModule.exports of ${

1
packages/compiler-cli/src/ngtsc/testing/BUILD.bazel
View File

@ -11,6 +11,7 @@ ts_library(
deps = [
"//packages:types",
"//packages/compiler-cli/src/ngtsc/file_system",
"//packages/compiler-cli/src/ngtsc/reflection",
"@npm//typescript",
],
)

7
packages/compiler-cli/src/ngtsc/testing/src/utils.ts
View File

@ -11,6 +11,7 @@
import * as ts from 'typescript';
import {AbsoluteFsPath, dirname, getFileSystem, getSourceFileOrError, NgtscCompilerHost} from '../../file_system';
import {DeclarationNode} from '../../reflection';
export function makeProgram(
files: {name: AbsoluteFsPath, contents: string, isRoot?: boolean}[],
@ -57,7 +58,7 @@ export function makeProgram(
* An error will be thrown if there is not at least one AST node with the given `name` and passes
* the `predicate` test.
*/
export function getDeclaration<T extends ts.Declaration>(
export function getDeclaration<T extends DeclarationNode>(
program: ts.Program, fileName: AbsoluteFsPath, name: string,
assert: (value: any) => value is T): T {
const sf = getSourceFileOrError(program, fileName);
@ -78,8 +79,8 @@ export function getDeclaration<T extends ts.Declaration>(
/**
* Walk the AST tree from the `rootNode` looking for a declaration that has the given `name`.
*/
export function walkForDeclarations(name: string, rootNode: ts.Node): ts.Declaration[] {
const chosenDecls: ts.Declaration[] = [];
export function walkForDeclarations(name: string, rootNode: ts.Node): DeclarationNode[] {
const chosenDecls: DeclarationNode[] = [];
rootNode.forEachChild(node => {
if (ts.isVariableStatement(node)) {
node.declarationList.declarations.forEach(decl => {

4
packages/compiler-cli/src/ngtsc/transform/src/compilation.ts
View File

@ -13,7 +13,7 @@ import {ErrorCode, FatalDiagnosticError} from '../../diagnostics';
import {IncrementalBuild} from '../../incremental/api';
import {IndexingContext} from '../../indexer';
import {PerfRecorder} from '../../perf';
import {ClassDeclaration, Decorator, ReflectionHost} from '../../reflection';
import {ClassDeclaration, DeclarationNode, Decorator, ReflectionHost} from '../../reflection';
import {ProgramTypeCheckAdapter, TypeCheckContext} from '../../typecheck/api';
import {getSourceFile, isExported} from '../../util/src/typescript';
@ -463,7 +463,7 @@ export class TraitCompiler implements ProgramTypeCheckAdapter {
}
}
compile(clazz: ts.Declaration, constantPool: ConstantPool): CompileResult[]|null {
compile(clazz: DeclarationNode, constantPool: ConstantPool): CompileResult[]|null {
const original = ts.getOriginalNode(clazz) as typeof clazz;
if (!this.reflector.isClass(clazz) || !this.reflector.isClass(original) ||
!this.classes.has(original)) {

1
packages/compiler-cli/src/ngtsc/typecheck/diagnostics/BUILD.bazel
View File

@ -9,6 +9,7 @@ ts_library(
deps = [
"//packages:types",
"//packages/compiler",
"//packages/compiler-cli/src/ngtsc/reflection",
"//packages/compiler-cli/src/ngtsc/typecheck/api",
"@npm//typescript",
],

3
packages/compiler-cli/src/ngtsc/typecheck/diagnostics/src/id.ts
View File

@ -7,6 +7,7 @@
*/
import * as ts from 'typescript';
import {DeclarationNode} from '../../../reflection';
import {TemplateId} from '../../api';
@ -22,7 +23,7 @@ interface HasNextTemplateId {
[NEXT_TEMPLATE_ID]: number;
}
export function getTemplateId(clazz: ts.Declaration): TemplateId {
export function getTemplateId(clazz: DeclarationNode): TemplateId {
const node = clazz as ts.Declaration & Partial<HasTemplateId>;
if (node[TEMPLATE_ID] === undefined) {
node[TEMPLATE_ID] = allocateTemplateId(node.getSourceFile());

4
packages/compiler-cli/src/ngtsc/typecheck/src/type_parameter_emitter.ts
View File

@ -8,7 +8,7 @@
import * as ts from 'typescript';
import {OwningModule, Reference} from '../../imports';
import {ReflectionHost} from '../../reflection';
import {DeclarationNode, ReflectionHost} from '../../reflection';
import {canEmitType, ResolvedTypeReference, TypeEmitter} from './type_emitter';
@ -89,7 +89,7 @@ export class TypeParameterEmitter {
return new Reference(declaration.node, owningModule);
}
private isLocalTypeParameter(decl: ts.Declaration): boolean {
private isLocalTypeParameter(decl: DeclarationNode): boolean {
// Checking for local type parameters only occurs during resolution of type parameters, so it is
// guaranteed that type parameters are present.
return this.typeParameters!.some(param => param === decl);

1
packages/compiler-cli/src/ngtsc/util/BUILD.bazel
View File

@ -11,6 +11,7 @@ ts_library(
"//packages:types",
"//packages/compiler-cli/src/ngtsc/file_system",
"//packages/compiler-cli/src/ngtsc/incremental:api",
"//packages/compiler-cli/src/ngtsc/reflection",
"@npm//@types/node",
"@npm//typescript",
],

3
packages/compiler-cli/src/ngtsc/util/src/typescript.ts
View File

@ -11,6 +11,7 @@ const D_TS = /\.d\.ts$/i;
import * as ts from 'typescript';
import {AbsoluteFsPath, absoluteFrom} from '../../file_system';
import {DeclarationNode} from '../../reflection';
export function isDtsPath(filePath: string): boolean {
return D_TS.test(filePath);
@ -82,7 +83,7 @@ export function isTypeDeclaration(node: ts.Node): node is ts.EnumDeclaration|
ts.isInterfaceDeclaration(node);
}
export function isExported(node: ts.Declaration): boolean {
export function isExported(node: DeclarationNode): boolean {
let topLevel: ts.Node = node;
if (ts.isVariableDeclaration(node) && ts.isVariableDeclarationList(node.parent)) {
topLevel = node.parent.parent;

1
packages/compiler-cli/test/ngtsc/BUILD.bazel
View File

@ -11,6 +11,7 @@ ts_library(
"//packages/compiler-cli/src/ngtsc/file_system",
"//packages/compiler-cli/src/ngtsc/file_system/testing",
"//packages/compiler-cli/src/ngtsc/indexer",
"//packages/compiler-cli/src/ngtsc/reflection",
"//packages/compiler-cli/src/ngtsc/routing",
"//packages/compiler-cli/src/ngtsc/testing",
"//packages/compiler-cli/src/ngtsc/util",

3
packages/compiler-cli/test/ngtsc/env.ts
View File

@ -16,6 +16,7 @@ import {absoluteFrom, AbsoluteFsPath, FileSystem, getFileSystem, NgtscCompilerHo
import {Folder, MockFileSystem} from '../../src/ngtsc/file_system/testing';
import {IndexedComponent} from '../../src/ngtsc/indexer';
import {NgtscProgram} from '../../src/ngtsc/program';
import {DeclarationNode} from '../../src/ngtsc/reflection';
import {LazyRoute} from '../../src/ngtsc/routing';
import {setWrapHostForTest} from '../../src/transformers/compiler_host';
import {getCachedSourceFile} from '../helpers';
@ -259,7 +260,7 @@ export class NgtscTestEnvironment {
return program.listLazyRoutes(entryPoint);
}
driveIndexer(): Map<ts.Declaration, IndexedComponent> {
driveIndexer(): Map<DeclarationNode, IndexedComponent> {
const {rootNames, options} = readNgcCommandLineAndConfiguration(['-p', this.basePath]);
const host = createCompilerHost({options});
const program = createProgram({rootNames, host, options});

1
packages/language-service/ivy/BUILD.bazel
View File

@ -12,6 +12,7 @@ ts_library(
"//packages/compiler-cli/src/ngtsc/core:api",
"//packages/compiler-cli/src/ngtsc/file_system",
"//packages/compiler-cli/src/ngtsc/incremental",
"//packages/compiler-cli/src/ngtsc/reflection",
"//packages/compiler-cli/src/ngtsc/shims",
"//packages/compiler-cli/src/ngtsc/typecheck",
"//packages/compiler-cli/src/ngtsc/typecheck/api",

3
packages/language-service/ivy/utils.ts
View File

@ -7,6 +7,7 @@
*/
import {AbsoluteSourceSpan, CssSelector, ParseSourceSpan, SelectorMatcher} from '@angular/compiler';
import {NgCompiler} from '@angular/compiler-cli/src/ngtsc/core';
import {DeclarationNode} from '@angular/compiler-cli/src/ngtsc/reflection';
import {DirectiveSymbol} from '@angular/compiler-cli/src/ngtsc/typecheck/api';
import * as e from '@angular/compiler/src/expression_parser/ast'; // e for expression AST
import * as t from '@angular/compiler/src/render3/r3_ast'; // t for template AST
@ -81,7 +82,7 @@ export function getTemplateInfoAtPosition(
* First, attempt to sort component declarations by file name.
* If the files are the same, sort by start location of the declaration.
*/
function tsDeclarationSortComparator(a: ts.Declaration, b: ts.Declaration): number {
function tsDeclarationSortComparator(a: DeclarationNode, b: DeclarationNode): number {
const aFile = a.getSourceFile().fileName;
const bFile = b.getSourceFile().fileName;
if (aFile < bFile) {