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

feat(ivy): use fileNameToModuleName to emit imports when it's available (#28523)

Browse Source 
The ultimate goal of this commit is to make use of fileNameToModuleName to
get the module specifier to use when generating an import, when that API is
available in the CompilerHost that ngtsc is created with.

As part of getting there, the way in which ngtsc tracks references and
generates import module specifiers is refactored considerably. References
are tracked with the Reference class, and previously ngtsc had several
different kinds of Reference. An AbsoluteReference represented a declaration
which needed to be imported via an absolute module specifier tracked in the
AbsoluteReference, and a RelativeReference represented a declaration from
the local program, imported via relative path or referred to directly by
identifier if possible. Thus, how to refer to a particular declaration was
encoded into the Reference type _at the time of creation of the Reference_.

This commit refactors that logic and reduces Reference to a single class
with no subclasses. A Reference represents a node being referenced, plus
context about how the node was located. This context includes a
"bestGuessOwningModule", the compiler's best guess at which absolute
module specifier has defined this reference. For example, if the compiler
arrives at the declaration of CommonModule via an import to @angular/common,
then any references obtained from CommonModule (e.g. NgIf) will also be
considered to be owned by @angular/common.

A ReferenceEmitter class and accompanying ReferenceEmitStrategy interface
are introduced. To produce an Expression referring to a given Reference'd
node, the ReferenceEmitter consults a sequence of ReferenceEmitStrategy
implementations.

Several different strategies are defined:

- LocalIdentifierStrategy: use local ts.Identifiers if available.
- AbsoluteModuleStrategy: if the Reference has a bestGuessOwningModule,
  import the node via an absolute import from that module specifier.
- LogicalProjectStrategy: if the Reference is in the logical project
  (is under the project rootDirs), import the node via a relative import.
- FileToModuleStrategy: use a FileToModuleHost to generate the module
  specifier by which to import the node.

Depending on the availability of fileNameToModuleName in the CompilerHost,
then, a different collection of these strategies is used for compilation.

PR Close #28523
This commit is contained in:
Alex Rickabaugh
2019-02-01 17:24:21 -08:00
committed by Misko Hevery
parent a529f53031
commit 423b39e216
40 changed files with 709 additions and 417 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -8,7 +8,7 @@
import * as ts from 'typescript';
import {Reference, ReferenceResolver} from '../../imports';
import {Reference} from '../../imports';
import {ReflectionHost} from '../../reflection';
import {StaticInterpreter} from './interpreter';
@ -19,12 +19,10 @@ export type ForeignFunctionResolver =
args: ReadonlyArray<ts.Expression>) => ts.Expression | null;
export class PartialEvaluator {
constructor(
private host: ReflectionHost, private checker: ts.TypeChecker,
private refResolver: ReferenceResolver) {}
constructor(private host: ReflectionHost, private checker: ts.TypeChecker) {}
evaluate(expr: ts.Expression, foreignFunctionResolver?: ForeignFunctionResolver): ResolvedValue {
const interpreter = new StaticInterpreter(this.host, this.checker, this.refResolver);
const interpreter = new StaticInterpreter(this.host, this.checker);
return interpreter.visit(expr, {
absoluteModuleName: null,
resolutionContext: expr.getSourceFile().fileName,

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

@ -8,7 +8,8 @@
import * as ts from 'typescript';
import {AbsoluteReference, NodeReference, Reference, ReferenceResolver, ResolvedReference} from '../../imports';
import {Reference} from '../../imports';
import {OwningModule} from '../../imports/src/references';
import {Declaration, ReflectionHost} from '../../reflection';
import {ArraySliceBuiltinFn} from './builtin';
@ -78,9 +79,7 @@ interface Context {
}
export class StaticInterpreter {
constructor(
private host: ReflectionHost, private checker: ts.TypeChecker,
private refResolver: ReferenceResolver) {}
constructor(private host: ReflectionHost, private checker: ts.TypeChecker) {}
visit(node: ts.Expression, context: Context): ResolvedValue {
return this.visitExpression(node, context);
@ -332,10 +331,7 @@ export class StaticInterpreter {
} else if (lhs instanceof Reference) {
const ref = lhs.node;
if (this.host.isClass(ref)) {
let absoluteModuleName = context.absoluteModuleName;
if (lhs instanceof NodeReference || lhs instanceof AbsoluteReference) {
absoluteModuleName = lhs.moduleName || absoluteModuleName;
}
const module = owningModule(context, lhs.bestGuessOwningModule);
let value: ResolvedValue = undefined;
const member = this.host.getMembersOfClass(ref).find(
member => member.isStatic && member.name === strIndex);
@ -343,9 +339,9 @@ export class StaticInterpreter {
if (member.value !== null) {
value = this.visitExpression(member.value, context);
} else if (member.implementation !== null) {
value = new NodeReference(member.implementation, absoluteModuleName);
value = new Reference(member.implementation, module);
} else if (member.node) {
value = new NodeReference(member.node, absoluteModuleName);
value = new Reference(member.node, module);
}
}
return value;
@ -391,11 +387,10 @@ export class StaticInterpreter {
// If the function is declared in a different file, resolve the foreign function expression
// using the absolute module name of that file (if any).
if ((lhs instanceof NodeReference || lhs instanceof AbsoluteReference) &&
lhs.moduleName !== null) {
if (lhs.bestGuessOwningModule !== null) {
context = {
...context,
absoluteModuleName: lhs.moduleName,
absoluteModuleName: lhs.bestGuessOwningModule.specifier,
resolutionContext: node.getSourceFile().fileName,
};
}
@ -496,7 +491,7 @@ export class StaticInterpreter {
}
private getReference(node: ts.Declaration, context: Context): Reference {
return this.refResolver.resolve(node, context.absoluteModuleName, context.resolutionContext);
return new Reference(node, owningModule(context));
}
}
@ -542,3 +537,18 @@ function joinModuleContext(existing: Context, node: ts.Node, decl: Declaration):
return EMPTY;
}
}
function owningModule(context: Context, override: OwningModule | null = null): OwningModule|null {
let specifier = context.absoluteModuleName;
if (override !== null) {
specifier = override.specifier;
}
if (specifier !== null) {
return {
specifier,
resolutionContext: context.resolutionContext,
};
} else {
return null;
}
}

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

@ -6,10 +6,9 @@
* found in the LICENSE file at https://angular.io/license
*/
import {WrappedNodeExpr} from '@angular/compiler';
import * as ts from 'typescript';
import {AbsoluteReference, Reference, TsReferenceResolver} from '../../imports';
import {Reference} from '../../imports';
import {TypeScriptReflectionHost} from '../../reflection';
import {getDeclaration, makeProgram} from '../../testing/in_memory_typescript';
import {PartialEvaluator} from '../src/interface';
@ -44,8 +43,7 @@ function evaluate<T extends ResolvedValue>(
code: string, expr: string, supportingFiles: {name: string, contents: string}[] = []): T {
const {expression, checker, program, options, host} = makeExpression(code, expr, supportingFiles);
const reflectionHost = new TypeScriptReflectionHost(checker);
const resolver = new TsReferenceResolver(program, checker, options, host);
const evaluator = new PartialEvaluator(reflectionHost, checker, resolver);
const evaluator = new PartialEvaluator(reflectionHost, checker);
return evaluator.evaluate(expression) as T;
}
@ -150,22 +148,17 @@ describe('ngtsc metadata', () => {
const reflectionHost = new TypeScriptReflectionHost(checker);
const result = getDeclaration(program, 'entry.ts', 'target$', ts.isVariableDeclaration);
const expr = result.initializer !;
const resolver = new TsReferenceResolver(program, checker, options, host);
const evaluator = new PartialEvaluator(reflectionHost, checker, resolver);
const evaluator = new PartialEvaluator(reflectionHost, checker);
const resolved = evaluator.evaluate(expr);
if (!(resolved instanceof Reference)) {
return fail('Expected expression to resolve to a reference');
}
expect(ts.isFunctionDeclaration(resolved.node)).toBe(true);
expect(resolved.expressable).toBe(true);
const reference = resolved.toExpression(program.getSourceFile('entry.ts') !);
if (!(reference instanceof WrappedNodeExpr)) {
return fail('Expected expression reference to be a wrapped node');
const reference = resolved.getIdentityIn(program.getSourceFile('entry.ts') !);
if (reference === null) {
return fail('Expected to get an identifier');
}
if (!ts.isIdentifier(reference.node)) {
return fail('Expected expression to be an Identifier');
}
expect(reference.node.getSourceFile()).toEqual(program.getSourceFile('entry.ts') !);
expect(reference.getSourceFile()).toEqual(program.getSourceFile('entry.ts') !);
});
it('absolute imports work', () => {
@ -183,23 +176,16 @@ describe('ngtsc metadata', () => {
const reflectionHost = new TypeScriptReflectionHost(checker);
const result = getDeclaration(program, 'entry.ts', 'target$', ts.isVariableDeclaration);
const expr = result.initializer !;
const resolver = new TsReferenceResolver(program, checker, options, host);
const evaluator = new PartialEvaluator(reflectionHost, checker, resolver);
const evaluator = new PartialEvaluator(reflectionHost, checker);
const resolved = evaluator.evaluate(expr);
if (!(resolved instanceof AbsoluteReference)) {
if (!(resolved instanceof Reference)) {
return fail('Expected expression to resolve to an absolute reference');
}
expect(resolved.moduleName).toBe('some_library');
expect(owningModuleOf(resolved)).toBe('some_library');
expect(ts.isFunctionDeclaration(resolved.node)).toBe(true);
expect(resolved.expressable).toBe(true);
const reference = resolved.toExpression(program.getSourceFile('entry.ts') !);
if (!(reference instanceof WrappedNodeExpr)) {
return fail('Expected expression reference to be a wrapped node');
}
if (!ts.isIdentifier(reference.node)) {
return fail('Expected expression to be an Identifier');
}
expect(reference.node.getSourceFile()).toEqual(program.getSourceFile('entry.ts') !);
const reference = resolved.getIdentityIn(program.getSourceFile('entry.ts') !);
expect(reference).not.toBeNull();
expect(reference !.getSourceFile()).toEqual(program.getSourceFile('entry.ts') !);
});
it('reads values from default exports', () => {
@ -282,3 +268,7 @@ describe('ngtsc metadata', () => {
expect(value instanceof Reference).toBe(true);
});
});
function owningModuleOf(ref: Reference): string|null {
return ref.bestGuessOwningModule !== null ? ref.bestGuessOwningModule.specifier : null;
}