fix(ivy): use 'typeof' and 'never' for type metadata (#24862)

Previously ngtsc would use a tuple of class types for listing metadata
in .d.ts files. For example, an @NgModule's declarations might be
represented with the type:

[NgIf, NgForOf, NgClass]

If the module had no declarations, an empty tuple [] would be produced.

This has two problems.

1. If the class type has generic type parameters, TypeScript will
complain that they're not provided.

2. The empty tuple type is not actually legal.

This commit addresses both problems.

1. Class types are now represented using the `typeof` operator, so the
above declarations would be represented as:

[typeof NgIf, typeof NgForOf, typeof NgClass].

Since typeof operates on a value, it doesn't require generic type
arguments.

2. Instead of an empty tuple, `never` is used to indicate no metadata.

PR Close #24862
This commit is contained in:
Alex Rickabaugh 2018-07-17 13:34:20 -07:00 committed by Victor Berchet
parent d3594fc1c5
commit ed1db40322
13 changed files with 85 additions and 14 deletions

View File

@ -353,10 +353,10 @@ export class SelectorScopeRegistry {
return [];
}
return def.elementTypes.map(element => {
if (!ts.isTypeReferenceNode(element)) {
throw new Error(`Expected TypeReferenceNode`);
if (!ts.isTypeQueryNode(element)) {
throw new Error(`Expected TypeQueryNode`);
}
const type = element.typeName;
const type = element.exprName;
const {node, from} = reflectTypeEntityToDeclaration(type, this.checker);
const moduleName = (from !== null && !from.startsWith('.') ? from : ngModuleImportedFrom);
const clazz = node as ts.Declaration;

View File

@ -31,7 +31,7 @@ describe('SelectorScopeRegistry', () => {
import * as i0 from './component';
export declare class SomeModule {
static ngModuleDef: NgModuleDef<SomeModule, [i0.SomeCmp], any, [i0.SomeCmp]>;
static ngModuleDef: NgModuleDef<SomeModule, [typeof i0.SomeCmp], never, [typeof i0.SomeCmp]>;
}
export declare class SomeCmp {

View File

@ -6,7 +6,7 @@
* found in the LICENSE file at https://angular.io/license
*/
import {ArrayType, AssertNotNull, BinaryOperator, BinaryOperatorExpr, BuiltinType, BuiltinTypeName, CastExpr, ClassStmt, CommaExpr, CommentStmt, ConditionalExpr, DeclareFunctionStmt, DeclareVarStmt, Expression, ExpressionStatement, ExpressionType, ExpressionVisitor, ExternalExpr, ExternalReference, FunctionExpr, IfStmt, InstantiateExpr, InvokeFunctionExpr, InvokeMethodExpr, JSDocCommentStmt, LiteralArrayExpr, LiteralExpr, LiteralMapExpr, MapType, NotExpr, ReadKeyExpr, ReadPropExpr, ReadVarExpr, ReturnStatement, Statement, StatementVisitor, StmtModifier, ThrowStmt, TryCatchStmt, Type, TypeVisitor, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr} from '@angular/compiler';
import {ArrayType, AssertNotNull, BinaryOperator, BinaryOperatorExpr, BuiltinType, BuiltinTypeName, CastExpr, ClassStmt, CommaExpr, CommentStmt, ConditionalExpr, DeclareFunctionStmt, DeclareVarStmt, Expression, ExpressionStatement, ExpressionType, ExpressionVisitor, ExternalExpr, ExternalReference, FunctionExpr, IfStmt, InstantiateExpr, InvokeFunctionExpr, InvokeMethodExpr, JSDocCommentStmt, LiteralArrayExpr, LiteralExpr, LiteralMapExpr, MapType, NotExpr, ReadKeyExpr, ReadPropExpr, ReadVarExpr, ReturnStatement, Statement, StatementVisitor, StmtModifier, ThrowStmt, TryCatchStmt, Type, TypeVisitor, TypeofExpr, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr} from '@angular/compiler';
import * as ts from 'typescript';
import {relativePathBetween} from '../../util/src/path';
@ -278,6 +278,10 @@ class ExpressionTranslatorVisitor implements ExpressionVisitor, StatementVisitor
}
visitWrappedNodeExpr(ast: WrappedNodeExpr<any>, context: Context): any { return ast.node; }
visitTypeofExpr(ast: TypeofExpr, context: Context): ts.TypeOfExpression {
return ts.createTypeOf(ast.expr.visitExpression(this, context));
}
}
export class TypeTranslatorVisitor implements ExpressionVisitor, TypeVisitor {
@ -294,6 +298,8 @@ export class TypeTranslatorVisitor implements ExpressionVisitor, TypeVisitor {
return 'number';
case BuiltinTypeName.String:
return 'string';
case BuiltinTypeName.None:
return 'never';
default:
throw new Error(`Unsupported builtin type: ${BuiltinTypeName[type.name]}`);
}
@ -417,4 +423,8 @@ export class TypeTranslatorVisitor implements ExpressionVisitor, TypeVisitor {
`Unsupported WrappedNodeExpr in TypeTranslatorVisitor: ${ts.SyntaxKind[node.kind]}`);
}
}
visitTypeofExpr(ast: TypeofExpr, context: Context): string {
return `typeof ${ast.expr.visitExpression(this, context)}`;
}
}

View File

@ -6,7 +6,7 @@
* found in the LICENSE file at https://angular.io/license
*/
import {AssertNotNull, BinaryOperator, BinaryOperatorExpr, BuiltinMethod, BuiltinVar, CastExpr, ClassStmt, CommaExpr, CommentStmt, ConditionalExpr, DeclareFunctionStmt, DeclareVarStmt, ExpressionStatement, ExpressionVisitor, ExternalExpr, ExternalReference, FunctionExpr, IfStmt, InstantiateExpr, InvokeFunctionExpr, InvokeMethodExpr, JSDocCommentStmt, LiteralArrayExpr, LiteralExpr, LiteralMapExpr, NotExpr, ParseSourceFile, ParseSourceSpan, PartialModule, ReadKeyExpr, ReadPropExpr, ReadVarExpr, ReturnStatement, Statement, StatementVisitor, StmtModifier, ThrowStmt, TryCatchStmt, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr} from '@angular/compiler';
import {AssertNotNull, BinaryOperator, BinaryOperatorExpr, BuiltinMethod, BuiltinVar, CastExpr, ClassStmt, CommaExpr, CommentStmt, ConditionalExpr, DeclareFunctionStmt, DeclareVarStmt, ExpressionStatement, ExpressionVisitor, ExternalExpr, ExternalReference, FunctionExpr, IfStmt, InstantiateExpr, InvokeFunctionExpr, InvokeMethodExpr, JSDocCommentStmt, LiteralArrayExpr, LiteralExpr, LiteralMapExpr, NotExpr, ParseSourceFile, ParseSourceSpan, PartialModule, ReadKeyExpr, ReadPropExpr, ReadVarExpr, ReturnStatement, Statement, StatementVisitor, StmtModifier, ThrowStmt, TryCatchStmt, TypeofExpr, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr} from '@angular/compiler';
import * as ts from 'typescript';
import {error} from './util';
@ -465,6 +465,11 @@ export class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
// ExpressionVisitor
visitWrappedNodeExpr(expr: WrappedNodeExpr<any>) { return this.record(expr, expr.node); }
visitTypeofExpr(expr: TypeofExpr) {
const typeOf = ts.createTypeOf(expr.expr.visitExpression(this, null));
return this.record(expr, typeOf);
}
// ExpressionVisitor
visitReadVarExpr(expr: ReadVarExpr) {
switch (expr.builtin) {

View File

@ -198,7 +198,8 @@ describe('ngtsc behavioral tests', () => {
const dtsContents = getContents('test.d.ts');
expect(dtsContents).toContain('static ngComponentDef: i0.ɵComponentDef<TestCmp, \'test-cmp\'>');
expect(dtsContents)
.toContain('static ngModuleDef: i0.ɵNgModuleDef<TestModule, [TestCmp], [], []>');
.toContain(
'static ngModuleDef: i0.ɵNgModuleDef<TestModule, [typeof TestCmp], never, never>');
expect(dtsContents).not.toContain('__decorate');
});
@ -240,7 +241,8 @@ describe('ngtsc behavioral tests', () => {
const dtsContents = getContents('test.d.ts');
expect(dtsContents)
.toContain('static ngModuleDef: i0.ɵNgModuleDef<TestModule, [TestCmp], [OtherModule], []>');
.toContain(
'static ngModuleDef: i0.ɵNgModuleDef<TestModule, [typeof TestCmp], [typeof OtherModule], never>');
expect(dtsContents).toContain('static ngInjectorDef: i0.ɵInjectorDef');
});
@ -342,7 +344,8 @@ describe('ngtsc behavioral tests', () => {
expect(jsContents).toContain('pipes: [TestPipe]');
const dtsContents = getContents('test.d.ts');
expect(dtsContents).toContain('i0.ɵNgModuleDef<TestModule, [TestPipe,TestCmp], [], []>');
expect(dtsContents)
.toContain('i0.ɵNgModuleDef<TestModule, [typeof TestPipe,typeof TestCmp], never, never>');
});
it('should unwrap a ModuleWithProviders function if a generic type is provided for it', () => {
@ -372,7 +375,8 @@ describe('ngtsc behavioral tests', () => {
const dtsContents = getContents('test.d.ts');
expect(dtsContents).toContain(`import * as i1 from 'router';`);
expect(dtsContents).toContain('i0.ɵNgModuleDef<TestModule, [], [i1.RouterModule], []>');
expect(dtsContents)
.toContain('i0.ɵNgModuleDef<TestModule, never, [typeof i1.RouterModule], never>');
});
it('should inject special types according to the metadata', () => {

View File

@ -68,7 +68,7 @@ export * from './ml_parser/html_tags';
export * from './ml_parser/interpolation_config';
export * from './ml_parser/tags';
export {NgModuleCompiler} from './ng_module_compiler';
export {ArrayType, AssertNotNull, BinaryOperator, BinaryOperatorExpr, BuiltinMethod, BuiltinType, BuiltinTypeName, BuiltinVar, CastExpr, ClassField, ClassMethod, ClassStmt, CommaExpr, CommentStmt, ConditionalExpr, DeclareFunctionStmt, DeclareVarStmt, Expression, ExpressionStatement, ExpressionType, ExpressionVisitor, ExternalExpr, ExternalReference, FunctionExpr, IfStmt, InstantiateExpr, InvokeFunctionExpr, InvokeMethodExpr, JSDocCommentStmt, LiteralArrayExpr, LiteralExpr, LiteralMapExpr, MapType, NotExpr, ReadKeyExpr, ReadPropExpr, ReadVarExpr, ReturnStatement, StatementVisitor, ThrowStmt, TryCatchStmt, Type, TypeVisitor, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, StmtModifier, Statement, collectExternalReferences} from './output/output_ast';
export {ArrayType, AssertNotNull, BinaryOperator, BinaryOperatorExpr, BuiltinMethod, BuiltinType, BuiltinTypeName, BuiltinVar, CastExpr, ClassField, ClassMethod, ClassStmt, CommaExpr, CommentStmt, ConditionalExpr, DeclareFunctionStmt, DeclareVarStmt, Expression, ExpressionStatement, ExpressionType, ExpressionVisitor, ExternalExpr, ExternalReference, FunctionExpr, IfStmt, InstantiateExpr, InvokeFunctionExpr, InvokeMethodExpr, JSDocCommentStmt, LiteralArrayExpr, LiteralExpr, LiteralMapExpr, MapType, NotExpr, ReadKeyExpr, ReadPropExpr, ReadVarExpr, ReturnStatement, StatementVisitor, ThrowStmt, TryCatchStmt, Type, TypeVisitor, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, StmtModifier, Statement, TypeofExpr, collectExternalReferences} from './output/output_ast';
export {EmitterVisitorContext} from './output/abstract_emitter';
export * from './output/ts_emitter';
export * from './parse_util';

View File

@ -298,6 +298,10 @@ class KeyVisitor implements o.ExpressionVisitor {
visitReadVarExpr(node: o.ReadVarExpr) { return `VAR:${node.name}`; }
visitTypeofExpr(node: o.TypeofExpr, context: any): string {
return `TYPEOF:${node.expr.visitExpression(this, context)}`;
}
visitWrappedNodeExpr = invalid;
visitWriteVarExpr = invalid;
visitWriteKeyExpr = invalid;

View File

@ -315,6 +315,10 @@ export abstract class AbstractEmitterVisitor implements o.StatementVisitor, o.Ex
visitWrappedNodeExpr(ast: o.WrappedNodeExpr<any>, ctx: EmitterVisitorContext): any {
throw new Error('Abstract emitter cannot visit WrappedNodeExpr.');
}
visitTypeofExpr(expr: o.TypeofExpr, ctx: EmitterVisitorContext): any {
ctx.print(expr, 'typeof ');
expr.expr.visitExpression(this, ctx);
}
visitReadVarExpr(ast: o.ReadVarExpr, ctx: EmitterVisitorContext): any {
let varName = ast.name !;
if (ast.builtin != null) {

View File

@ -33,7 +33,8 @@ export enum BuiltinTypeName {
Int,
Number,
Function,
Inferred
Inferred,
None,
}
export class BuiltinType extends Type {
@ -77,6 +78,7 @@ export const INT_TYPE = new BuiltinType(BuiltinTypeName.Int);
export const NUMBER_TYPE = new BuiltinType(BuiltinTypeName.Number);
export const STRING_TYPE = new BuiltinType(BuiltinTypeName.String);
export const FUNCTION_TYPE = new BuiltinType(BuiltinTypeName.Function);
export const NONE_TYPE = new BuiltinType(BuiltinTypeName.None);
export interface TypeVisitor {
visitBuiltinType(type: BuiltinType, context: any): any;
@ -279,6 +281,22 @@ export class ReadVarExpr extends Expression {
}
}
export class TypeofExpr extends Expression {
constructor(public expr: Expression, type?: Type|null, sourceSpan?: ParseSourceSpan|null) {
super(type, sourceSpan);
}
visitExpression(visitor: ExpressionVisitor, context: any) {
return visitor.visitTypeofExpr(this, context);
}
isEquivalent(e: Expression): boolean {
return e instanceof TypeofExpr && e.expr.isEquivalent(this.expr);
}
isConstant(): boolean { return this.expr.isConstant(); }
}
export class WrappedNodeExpr<T> extends Expression {
constructor(public node: T, type?: Type|null, sourceSpan?: ParseSourceSpan|null) {
super(type, sourceSpan);
@ -738,6 +756,7 @@ export interface ExpressionVisitor {
visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any;
visitCommaExpr(ast: CommaExpr, context: any): any;
visitWrappedNodeExpr(ast: WrappedNodeExpr<any>, context: any): any;
visitTypeofExpr(ast: TypeofExpr, context: any): any;
}
export const THIS_EXPR = new ReadVarExpr(BuiltinVar.This, null, null);
@ -993,6 +1012,12 @@ export class AstTransformer implements StatementVisitor, ExpressionVisitor {
return this.transformExpr(ast, context);
}
visitTypeofExpr(expr: TypeofExpr, context: any): any {
return this.transformExpr(
new TypeofExpr(expr.expr.visitExpression(this, context), expr.type, expr.sourceSpan),
context);
}
visitWriteVarExpr(expr: WriteVarExpr, context: any): any {
return this.transformExpr(
new WriteVarExpr(
@ -1220,6 +1245,7 @@ export class RecursiveAstVisitor implements StatementVisitor, ExpressionVisitor
visitArrayType(type: ArrayType, context: any): any { return this.visitType(type, context); }
visitMapType(type: MapType, context: any): any { return this.visitType(type, context); }
visitWrappedNodeExpr(ast: WrappedNodeExpr<any>, context: any): any { return ast; }
visitTypeofExpr(ast: TypeofExpr, context: any): any { return this.visitExpression(ast, context); }
visitReadVarExpr(ast: ReadVarExpr, context: any): any {
return this.visitExpression(ast, context);
}
@ -1474,6 +1500,10 @@ export function expressionType(
return new ExpressionType(expr, typeModifiers);
}
export function typeofExpr(expr: Expression) {
return new TypeofExpr(expr);
}
export function literalArr(
values: Expression[], type?: Type | null,
sourceSpan?: ParseSourceSpan | null): LiteralArrayExpr {

View File

@ -117,6 +117,9 @@ class StatementInterpreter implements o.StatementVisitor, o.ExpressionVisitor {
visitWrappedNodeExpr(ast: o.WrappedNodeExpr<any>, ctx: _ExecutionContext): never {
throw new Error('Cannot interpret a WrappedNodeExpr.');
}
visitTypeofExpr(ast: o.TypeofExpr, ctx: _ExecutionContext): never {
throw new Error('Cannot interpret a TypeofExpr');
}
visitReadVarExpr(ast: o.ReadVarExpr, ctx: _ExecutionContext): any {
let varName = ast.name !;
if (ast.builtin != null) {

View File

@ -349,6 +349,9 @@ class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor
case o.BuiltinTypeName.String:
typeStr = 'string';
break;
case o.BuiltinTypeName.None:
typeStr = 'never';
break;
default:
throw new Error(`Unsupported builtin type ${type.name}`);
}

View File

@ -74,8 +74,8 @@ export function compileNgModule(meta: R3NgModuleMetadata): R3NgModuleDef {
})]);
const type = new o.ExpressionType(o.importExpr(R3.NgModuleDef, [
new o.ExpressionType(moduleType), new o.ExpressionType(o.literalArr(declarations)),
new o.ExpressionType(o.literalArr(imports)), new o.ExpressionType(o.literalArr(exports))
new o.ExpressionType(moduleType), tupleTypeOf(declarations), tupleTypeOf(imports),
tupleTypeOf(exports)
]));
const additionalStatements: o.Statement[] = [];
@ -147,3 +147,8 @@ function accessExportScope(module: o.Expression): o.Expression {
const selectorScope = new o.ReadPropExpr(module, 'ngModuleDef');
return new o.ReadPropExpr(selectorScope, 'exported');
}
function tupleTypeOf(exp: o.Expression[]): o.Type {
const types = exp.map(type => o.typeofExpr(type));
return exp.length > 0 ? o.expressionType(o.literalArr(types)) : o.NONE_TYPE;
}

View File

@ -1559,6 +1559,9 @@
{
"name": "TypeModifier"
},
{
"name": "TypeofExpr"
},
{
"name": "UNDEFINED_RENDERER_TYPE_ID"
},