mirror of
https://github.com/angular/angular
synced 2026-05-24 09:28:37 +00:00
393efa54e6
When a partially compiled component or directive is "linked" in JIT mode, the body of its declaration is evaluated by the JavaScript runtime. If a class is referenced in a query (e.g. `ViewQuery` or `ContentQuery`) but its definition is later in the file, then the reference must be wrapped in a `forwardRef()` call. Previously, query predicates were not wrapped correctly in partial declarations causing the code to crash at runtime. In AOT mode, this code is never evaluated but instead transformed as part of the build, so this bug did not become apparent until Angular Material started running JIT mode tests on its distributable output. This change fixes this problem by noting when queries are wrapped in `forwardRef()` calls and ensuring that this gets passed through to partial compilation declarations and then suitably stripped during linking. See https://github.com/angular/components/pull/23882 and https://github.com/angular/components/issues/23907 PR Close #44113
633 lines
27 KiB
TypeScript
633 lines
27 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
|
|
|
|
import {CompilerFacade, CoreEnvironment, ExportedCompilerFacade, OpaqueValue, R3ComponentMetadataFacade, R3DeclareComponentFacade, R3DeclareDependencyMetadataFacade, R3DeclareDirectiveFacade, R3DeclareFactoryFacade, R3DeclareInjectableFacade, R3DeclareInjectorFacade, R3DeclareNgModuleFacade, R3DeclarePipeFacade, R3DeclareQueryMetadataFacade, R3DeclareUsedDirectiveFacade, R3DependencyMetadataFacade, R3DirectiveMetadataFacade, R3FactoryDefMetadataFacade, R3InjectableMetadataFacade, R3InjectorMetadataFacade, R3NgModuleMetadataFacade, R3PipeMetadataFacade, R3QueryMetadataFacade, StringMap, StringMapWithRename} from './compiler_facade_interface';
|
|
import {ConstantPool} from './constant_pool';
|
|
import {ChangeDetectionStrategy, HostBinding, HostListener, Input, Output, ViewEncapsulation} from './core';
|
|
import {compileInjectable} from './injectable_compiler_2';
|
|
import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from './ml_parser/interpolation_config';
|
|
import {DeclareVarStmt, Expression, literal, LiteralExpr, Statement, StmtModifier, WrappedNodeExpr} from './output/output_ast';
|
|
import {JitEvaluator} from './output/output_jit';
|
|
import {ParseError, ParseSourceSpan, r3JitTypeSourceSpan} from './parse_util';
|
|
import {compileFactoryFunction, FactoryTarget, R3DependencyMetadata} from './render3/r3_factory';
|
|
import {compileInjector, R3InjectorMetadata} from './render3/r3_injector_compiler';
|
|
import {R3JitReflector} from './render3/r3_jit';
|
|
import {compileNgModule, compileNgModuleDeclarationExpression, R3NgModuleMetadata} from './render3/r3_module_compiler';
|
|
import {compilePipeFromMetadata, R3PipeMetadata} from './render3/r3_pipe_compiler';
|
|
import {createMayBeForwardRefExpression, ForwardRefHandling, getSafePropertyAccessString, MaybeForwardRefExpression, wrapReference} from './render3/util';
|
|
import {DeclarationListEmitMode, R3ComponentMetadata, R3DirectiveMetadata, R3HostMetadata, R3QueryMetadata, R3UsedDirectiveMetadata} from './render3/view/api';
|
|
import {compileComponentFromMetadata, compileDirectiveFromMetadata, ParsedHostBindings, parseHostBindings, verifyHostBindings} from './render3/view/compiler';
|
|
import {makeBindingParser, parseTemplate} from './render3/view/template';
|
|
import {ResourceLoader} from './resource_loader';
|
|
import {DomElementSchemaRegistry} from './schema/dom_element_schema_registry';
|
|
import {resolveForwardRef} from './util';
|
|
|
|
export class CompilerFacadeImpl implements CompilerFacade {
|
|
FactoryTarget = FactoryTarget as any;
|
|
ResourceLoader = ResourceLoader;
|
|
private elementSchemaRegistry = new DomElementSchemaRegistry();
|
|
|
|
constructor(private jitEvaluator = new JitEvaluator()) {}
|
|
|
|
compilePipe(angularCoreEnv: CoreEnvironment, sourceMapUrl: string, facade: R3PipeMetadataFacade):
|
|
any {
|
|
const metadata: R3PipeMetadata = {
|
|
name: facade.name,
|
|
type: wrapReference(facade.type),
|
|
internalType: new WrappedNodeExpr(facade.type),
|
|
typeArgumentCount: 0,
|
|
deps: null,
|
|
pipeName: facade.pipeName,
|
|
pure: facade.pure,
|
|
};
|
|
const res = compilePipeFromMetadata(metadata);
|
|
return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, []);
|
|
}
|
|
|
|
compilePipeDeclaration(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string,
|
|
declaration: R3DeclarePipeFacade): any {
|
|
const meta = convertDeclarePipeFacadeToMetadata(declaration);
|
|
const res = compilePipeFromMetadata(meta);
|
|
return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, []);
|
|
}
|
|
|
|
compileInjectable(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string,
|
|
facade: R3InjectableMetadataFacade): any {
|
|
const {expression, statements} = compileInjectable(
|
|
{
|
|
name: facade.name,
|
|
type: wrapReference(facade.type),
|
|
internalType: new WrappedNodeExpr(facade.type),
|
|
typeArgumentCount: facade.typeArgumentCount,
|
|
providedIn: computeProvidedIn(facade.providedIn),
|
|
useClass: convertToProviderExpression(facade, USE_CLASS),
|
|
useFactory: wrapExpression(facade, USE_FACTORY),
|
|
useValue: convertToProviderExpression(facade, USE_VALUE),
|
|
useExisting: convertToProviderExpression(facade, USE_EXISTING),
|
|
deps: facade.deps?.map(convertR3DependencyMetadata),
|
|
},
|
|
/* resolveForwardRefs */ true);
|
|
|
|
return this.jitExpression(expression, angularCoreEnv, sourceMapUrl, statements);
|
|
}
|
|
|
|
compileInjectableDeclaration(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string,
|
|
facade: R3DeclareInjectableFacade): any {
|
|
const {expression, statements} = compileInjectable(
|
|
{
|
|
name: facade.type.name,
|
|
type: wrapReference(facade.type),
|
|
internalType: new WrappedNodeExpr(facade.type),
|
|
typeArgumentCount: 0,
|
|
providedIn: computeProvidedIn(facade.providedIn),
|
|
useClass: convertToProviderExpression(facade, USE_CLASS),
|
|
useFactory: wrapExpression(facade, USE_FACTORY),
|
|
useValue: convertToProviderExpression(facade, USE_VALUE),
|
|
useExisting: convertToProviderExpression(facade, USE_EXISTING),
|
|
deps: facade.deps?.map(convertR3DeclareDependencyMetadata),
|
|
},
|
|
/* resolveForwardRefs */ true);
|
|
|
|
return this.jitExpression(expression, angularCoreEnv, sourceMapUrl, statements);
|
|
}
|
|
|
|
compileInjector(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string,
|
|
facade: R3InjectorMetadataFacade): any {
|
|
const meta: R3InjectorMetadata = {
|
|
name: facade.name,
|
|
type: wrapReference(facade.type),
|
|
internalType: new WrappedNodeExpr(facade.type),
|
|
providers: new WrappedNodeExpr(facade.providers),
|
|
imports: facade.imports.map(i => new WrappedNodeExpr(i)),
|
|
};
|
|
const res = compileInjector(meta);
|
|
return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, []);
|
|
}
|
|
|
|
compileInjectorDeclaration(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string,
|
|
declaration: R3DeclareInjectorFacade): any {
|
|
const meta = convertDeclareInjectorFacadeToMetadata(declaration);
|
|
const res = compileInjector(meta);
|
|
return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, []);
|
|
}
|
|
|
|
compileNgModule(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string,
|
|
facade: R3NgModuleMetadataFacade): any {
|
|
const meta: R3NgModuleMetadata = {
|
|
type: wrapReference(facade.type),
|
|
internalType: new WrappedNodeExpr(facade.type),
|
|
adjacentType: new WrappedNodeExpr(facade.type),
|
|
bootstrap: facade.bootstrap.map(wrapReference),
|
|
declarations: facade.declarations.map(wrapReference),
|
|
imports: facade.imports.map(wrapReference),
|
|
exports: facade.exports.map(wrapReference),
|
|
emitInline: true,
|
|
containsForwardDecls: false,
|
|
schemas: facade.schemas ? facade.schemas.map(wrapReference) : null,
|
|
id: facade.id ? new WrappedNodeExpr(facade.id) : null,
|
|
};
|
|
const res = compileNgModule(meta);
|
|
return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, []);
|
|
}
|
|
|
|
compileNgModuleDeclaration(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string,
|
|
declaration: R3DeclareNgModuleFacade): any {
|
|
const expression = compileNgModuleDeclarationExpression(declaration);
|
|
return this.jitExpression(expression, angularCoreEnv, sourceMapUrl, []);
|
|
}
|
|
|
|
compileDirective(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string,
|
|
facade: R3DirectiveMetadataFacade): any {
|
|
const meta: R3DirectiveMetadata = convertDirectiveFacadeToMetadata(facade);
|
|
return this.compileDirectiveFromMeta(angularCoreEnv, sourceMapUrl, meta);
|
|
}
|
|
|
|
compileDirectiveDeclaration(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string,
|
|
declaration: R3DeclareDirectiveFacade): any {
|
|
const typeSourceSpan =
|
|
this.createParseSourceSpan('Directive', declaration.type.name, sourceMapUrl);
|
|
const meta = convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan);
|
|
return this.compileDirectiveFromMeta(angularCoreEnv, sourceMapUrl, meta);
|
|
}
|
|
|
|
private compileDirectiveFromMeta(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string, meta: R3DirectiveMetadata): any {
|
|
const constantPool = new ConstantPool();
|
|
const bindingParser = makeBindingParser();
|
|
const res = compileDirectiveFromMetadata(meta, constantPool, bindingParser);
|
|
return this.jitExpression(
|
|
res.expression, angularCoreEnv, sourceMapUrl, constantPool.statements);
|
|
}
|
|
|
|
compileComponent(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string,
|
|
facade: R3ComponentMetadataFacade): any {
|
|
// Parse the template and check for errors.
|
|
const {template, interpolation} = parseJitTemplate(
|
|
facade.template, facade.name, sourceMapUrl, facade.preserveWhitespaces,
|
|
facade.interpolation);
|
|
|
|
// Compile the component metadata, including template, into an expression.
|
|
const meta: R3ComponentMetadata = {
|
|
...facade as R3ComponentMetadataFacadeNoPropAndWhitespace,
|
|
...convertDirectiveFacadeToMetadata(facade),
|
|
selector: facade.selector || this.elementSchemaRegistry.getDefaultComponentElementName(),
|
|
template,
|
|
declarationListEmitMode: DeclarationListEmitMode.Direct,
|
|
styles: [...facade.styles, ...template.styles],
|
|
encapsulation: facade.encapsulation as any,
|
|
interpolation,
|
|
changeDetection: facade.changeDetection,
|
|
animations: facade.animations != null ? new WrappedNodeExpr(facade.animations) : null,
|
|
viewProviders: facade.viewProviders != null ? new WrappedNodeExpr(facade.viewProviders) :
|
|
null,
|
|
relativeContextFilePath: '',
|
|
i18nUseExternalIds: true,
|
|
};
|
|
const jitExpressionSourceMap = `ng:///${facade.name}.js`;
|
|
return this.compileComponentFromMeta(angularCoreEnv, jitExpressionSourceMap, meta);
|
|
}
|
|
|
|
compileComponentDeclaration(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string,
|
|
declaration: R3DeclareComponentFacade): any {
|
|
const typeSourceSpan =
|
|
this.createParseSourceSpan('Component', declaration.type.name, sourceMapUrl);
|
|
const meta = convertDeclareComponentFacadeToMetadata(declaration, typeSourceSpan, sourceMapUrl);
|
|
return this.compileComponentFromMeta(angularCoreEnv, sourceMapUrl, meta);
|
|
}
|
|
|
|
private compileComponentFromMeta(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string, meta: R3ComponentMetadata): any {
|
|
const constantPool = new ConstantPool();
|
|
const bindingParser = makeBindingParser(meta.interpolation);
|
|
const res = compileComponentFromMetadata(meta, constantPool, bindingParser);
|
|
return this.jitExpression(
|
|
res.expression, angularCoreEnv, sourceMapUrl, constantPool.statements);
|
|
}
|
|
|
|
compileFactory(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string, meta: R3FactoryDefMetadataFacade) {
|
|
const factoryRes = compileFactoryFunction({
|
|
name: meta.name,
|
|
type: wrapReference(meta.type),
|
|
internalType: new WrappedNodeExpr(meta.type),
|
|
typeArgumentCount: meta.typeArgumentCount,
|
|
deps: convertR3DependencyMetadataArray(meta.deps),
|
|
target: meta.target,
|
|
});
|
|
return this.jitExpression(
|
|
factoryRes.expression, angularCoreEnv, sourceMapUrl, factoryRes.statements);
|
|
}
|
|
|
|
compileFactoryDeclaration(
|
|
angularCoreEnv: CoreEnvironment, sourceMapUrl: string, meta: R3DeclareFactoryFacade) {
|
|
const factoryRes = compileFactoryFunction({
|
|
name: meta.type.name,
|
|
type: wrapReference(meta.type),
|
|
internalType: new WrappedNodeExpr(meta.type),
|
|
typeArgumentCount: 0,
|
|
deps: Array.isArray(meta.deps) ? meta.deps.map(convertR3DeclareDependencyMetadata) :
|
|
meta.deps,
|
|
target: meta.target,
|
|
});
|
|
return this.jitExpression(
|
|
factoryRes.expression, angularCoreEnv, sourceMapUrl, factoryRes.statements);
|
|
}
|
|
|
|
|
|
createParseSourceSpan(kind: string, typeName: string, sourceUrl: string): ParseSourceSpan {
|
|
return r3JitTypeSourceSpan(kind, typeName, sourceUrl);
|
|
}
|
|
|
|
/**
|
|
* JIT compiles an expression and returns the result of executing that expression.
|
|
*
|
|
* @param def the definition which will be compiled and executed to get the value to patch
|
|
* @param context an object map of @angular/core symbol names to symbols which will be available
|
|
* in the context of the compiled expression
|
|
* @param sourceUrl a URL to use for the source map of the compiled expression
|
|
* @param preStatements a collection of statements that should be evaluated before the expression.
|
|
*/
|
|
private jitExpression(
|
|
def: Expression, context: {[key: string]: any}, sourceUrl: string,
|
|
preStatements: Statement[]): any {
|
|
// The ConstantPool may contain Statements which declare variables used in the final expression.
|
|
// Therefore, its statements need to precede the actual JIT operation. The final statement is a
|
|
// declaration of $def which is set to the expression being compiled.
|
|
const statements: Statement[] = [
|
|
...preStatements,
|
|
new DeclareVarStmt('$def', def, undefined, [StmtModifier.Exported]),
|
|
];
|
|
|
|
const res = this.jitEvaluator.evaluateStatements(
|
|
sourceUrl, statements, new R3JitReflector(context), /* enableSourceMaps */ true);
|
|
return res['$def'];
|
|
}
|
|
}
|
|
|
|
// This seems to be needed to placate TS v3.0 only
|
|
type R3ComponentMetadataFacadeNoPropAndWhitespace = Pick<
|
|
R3ComponentMetadataFacade,
|
|
Exclude<Exclude<keyof R3ComponentMetadataFacade, 'preserveWhitespaces'>, 'propMetadata'>>;
|
|
|
|
const USE_CLASS = Object.keys({useClass: null})[0];
|
|
const USE_FACTORY = Object.keys({useFactory: null})[0];
|
|
const USE_VALUE = Object.keys({useValue: null})[0];
|
|
const USE_EXISTING = Object.keys({useExisting: null})[0];
|
|
|
|
function convertToR3QueryMetadata(facade: R3QueryMetadataFacade): R3QueryMetadata {
|
|
return {
|
|
...facade,
|
|
predicate: convertQueryPredicate(facade.predicate),
|
|
read: facade.read ? new WrappedNodeExpr(facade.read) : null,
|
|
static: facade.static,
|
|
emitDistinctChangesOnly: facade.emitDistinctChangesOnly,
|
|
};
|
|
}
|
|
|
|
function convertQueryDeclarationToMetadata(declaration: R3DeclareQueryMetadataFacade):
|
|
R3QueryMetadata {
|
|
return {
|
|
propertyName: declaration.propertyName,
|
|
first: declaration.first ?? false,
|
|
predicate: convertQueryPredicate(declaration.predicate),
|
|
descendants: declaration.descendants ?? false,
|
|
read: declaration.read ? new WrappedNodeExpr(declaration.read) : null,
|
|
static: declaration.static ?? false,
|
|
emitDistinctChangesOnly: declaration.emitDistinctChangesOnly ?? true,
|
|
};
|
|
}
|
|
|
|
function convertQueryPredicate(predicate: OpaqueValue|string[]): MaybeForwardRefExpression|
|
|
string[] {
|
|
return Array.isArray(predicate) ?
|
|
// The predicate is an array of strings so pass it through.
|
|
predicate :
|
|
// The predicate is a type - assume that we will need to unwrap any `forwardRef()` calls.
|
|
createMayBeForwardRefExpression(new WrappedNodeExpr(predicate), ForwardRefHandling.Wrapped);
|
|
}
|
|
|
|
function convertDirectiveFacadeToMetadata(facade: R3DirectiveMetadataFacade): R3DirectiveMetadata {
|
|
const inputsFromMetadata = parseInputOutputs(facade.inputs || []);
|
|
const outputsFromMetadata = parseInputOutputs(facade.outputs || []);
|
|
const propMetadata = facade.propMetadata;
|
|
const inputsFromType: StringMapWithRename = {};
|
|
const outputsFromType: StringMap = {};
|
|
for (const field in propMetadata) {
|
|
if (propMetadata.hasOwnProperty(field)) {
|
|
propMetadata[field].forEach(ann => {
|
|
if (isInput(ann)) {
|
|
inputsFromType[field] =
|
|
ann.bindingPropertyName ? [ann.bindingPropertyName, field] : field;
|
|
} else if (isOutput(ann)) {
|
|
outputsFromType[field] = ann.bindingPropertyName || field;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
return {
|
|
...facade as R3DirectiveMetadataFacadeNoPropAndWhitespace,
|
|
typeArgumentCount: 0,
|
|
typeSourceSpan: facade.typeSourceSpan,
|
|
type: wrapReference(facade.type),
|
|
internalType: new WrappedNodeExpr(facade.type),
|
|
deps: null,
|
|
host: extractHostBindings(facade.propMetadata, facade.typeSourceSpan, facade.host),
|
|
inputs: {...inputsFromMetadata, ...inputsFromType},
|
|
outputs: {...outputsFromMetadata, ...outputsFromType},
|
|
queries: facade.queries.map(convertToR3QueryMetadata),
|
|
providers: facade.providers != null ? new WrappedNodeExpr(facade.providers) : null,
|
|
viewQueries: facade.viewQueries.map(convertToR3QueryMetadata),
|
|
fullInheritance: false,
|
|
};
|
|
}
|
|
|
|
function convertDeclareDirectiveFacadeToMetadata(
|
|
declaration: R3DeclareDirectiveFacade, typeSourceSpan: ParseSourceSpan): R3DirectiveMetadata {
|
|
return {
|
|
name: declaration.type.name,
|
|
type: wrapReference(declaration.type),
|
|
typeSourceSpan,
|
|
internalType: new WrappedNodeExpr(declaration.type),
|
|
selector: declaration.selector ?? null,
|
|
inputs: declaration.inputs ?? {},
|
|
outputs: declaration.outputs ?? {},
|
|
host: convertHostDeclarationToMetadata(declaration.host),
|
|
queries: (declaration.queries ?? []).map(convertQueryDeclarationToMetadata),
|
|
viewQueries: (declaration.viewQueries ?? []).map(convertQueryDeclarationToMetadata),
|
|
providers: declaration.providers !== undefined ? new WrappedNodeExpr(declaration.providers) :
|
|
null,
|
|
exportAs: declaration.exportAs ?? null,
|
|
usesInheritance: declaration.usesInheritance ?? false,
|
|
lifecycle: {usesOnChanges: declaration.usesOnChanges ?? false},
|
|
deps: null,
|
|
typeArgumentCount: 0,
|
|
fullInheritance: false,
|
|
};
|
|
}
|
|
|
|
function convertHostDeclarationToMetadata(host: R3DeclareDirectiveFacade['host'] = {}):
|
|
R3HostMetadata {
|
|
return {
|
|
attributes: convertOpaqueValuesToExpressions(host.attributes ?? {}),
|
|
listeners: host.listeners ?? {},
|
|
properties: host.properties ?? {},
|
|
specialAttributes: {
|
|
classAttr: host.classAttribute,
|
|
styleAttr: host.styleAttribute,
|
|
},
|
|
};
|
|
}
|
|
|
|
function convertOpaqueValuesToExpressions(obj: {[key: string]: OpaqueValue}):
|
|
{[key: string]: WrappedNodeExpr<unknown>} {
|
|
const result: {[key: string]: WrappedNodeExpr<unknown>} = {};
|
|
for (const key of Object.keys(obj)) {
|
|
result[key] = new WrappedNodeExpr(obj[key]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function convertDeclareComponentFacadeToMetadata(
|
|
declaration: R3DeclareComponentFacade, typeSourceSpan: ParseSourceSpan,
|
|
sourceMapUrl: string): R3ComponentMetadata {
|
|
const {template, interpolation} = parseJitTemplate(
|
|
declaration.template, declaration.type.name, sourceMapUrl,
|
|
declaration.preserveWhitespaces ?? false, declaration.interpolation);
|
|
|
|
return {
|
|
...convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan),
|
|
template,
|
|
styles: declaration.styles ?? [],
|
|
directives: (declaration.components ?? [])
|
|
.concat(declaration.directives ?? [])
|
|
.map(convertUsedDirectiveDeclarationToMetadata),
|
|
pipes: convertUsedPipesToMetadata(declaration.pipes),
|
|
viewProviders: declaration.viewProviders !== undefined ?
|
|
new WrappedNodeExpr(declaration.viewProviders) :
|
|
null,
|
|
animations: declaration.animations !== undefined ? new WrappedNodeExpr(declaration.animations) :
|
|
null,
|
|
changeDetection: declaration.changeDetection ?? ChangeDetectionStrategy.Default,
|
|
encapsulation: declaration.encapsulation ?? ViewEncapsulation.Emulated,
|
|
interpolation,
|
|
declarationListEmitMode: DeclarationListEmitMode.ClosureResolved,
|
|
relativeContextFilePath: '',
|
|
i18nUseExternalIds: true,
|
|
};
|
|
}
|
|
|
|
function convertUsedDirectiveDeclarationToMetadata(declaration: R3DeclareUsedDirectiveFacade):
|
|
R3UsedDirectiveMetadata {
|
|
return {
|
|
selector: declaration.selector,
|
|
type: new WrappedNodeExpr(declaration.type),
|
|
inputs: declaration.inputs ?? [],
|
|
outputs: declaration.outputs ?? [],
|
|
exportAs: declaration.exportAs ?? null,
|
|
};
|
|
}
|
|
|
|
function convertUsedPipesToMetadata(declaredPipes: R3DeclareComponentFacade['pipes']):
|
|
Map<string, Expression> {
|
|
const pipes = new Map<string, Expression>();
|
|
if (declaredPipes === undefined) {
|
|
return pipes;
|
|
}
|
|
|
|
for (const pipeName of Object.keys(declaredPipes)) {
|
|
const pipeType = declaredPipes[pipeName];
|
|
pipes.set(pipeName, new WrappedNodeExpr(pipeType));
|
|
}
|
|
return pipes;
|
|
}
|
|
|
|
function parseJitTemplate(
|
|
template: string, typeName: string, sourceMapUrl: string, preserveWhitespaces: boolean,
|
|
interpolation: [string, string]|undefined) {
|
|
const interpolationConfig =
|
|
interpolation ? InterpolationConfig.fromArray(interpolation) : DEFAULT_INTERPOLATION_CONFIG;
|
|
// Parse the template and check for errors.
|
|
const parsed = parseTemplate(template, sourceMapUrl, {preserveWhitespaces, interpolationConfig});
|
|
if (parsed.errors !== null) {
|
|
const errors = parsed.errors.map(err => err.toString()).join(', ');
|
|
throw new Error(`Errors during JIT compilation of template for ${typeName}: ${errors}`);
|
|
}
|
|
return {template: parsed, interpolation: interpolationConfig};
|
|
}
|
|
|
|
// This seems to be needed to placate TS v3.0 only
|
|
type R3DirectiveMetadataFacadeNoPropAndWhitespace =
|
|
Pick<R3DirectiveMetadataFacade, Exclude<keyof R3DirectiveMetadataFacade, 'propMetadata'>>;
|
|
|
|
/**
|
|
* Convert the expression, if present to an `R3ProviderExpression`.
|
|
*
|
|
* In JIT mode we do not want the compiler to wrap the expression in a `forwardRef()` call because,
|
|
* if it is referencing a type that has not yet been defined, it will have already been wrapped in
|
|
* a `forwardRef()` - either by the application developer or during partial-compilation. Thus we can
|
|
* use `ForwardRefHandling.None`.
|
|
*/
|
|
function convertToProviderExpression(obj: any, property: string): MaybeForwardRefExpression|
|
|
undefined {
|
|
if (obj.hasOwnProperty(property)) {
|
|
return createMayBeForwardRefExpression(
|
|
new WrappedNodeExpr(obj[property]), ForwardRefHandling.None);
|
|
} else {
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
function wrapExpression(obj: any, property: string): WrappedNodeExpr<any>|undefined {
|
|
if (obj.hasOwnProperty(property)) {
|
|
return new WrappedNodeExpr(obj[property]);
|
|
} else {
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
function computeProvidedIn(providedIn: Function|string|null|undefined): MaybeForwardRefExpression {
|
|
const expression = typeof providedIn === 'function' ? new WrappedNodeExpr(providedIn) :
|
|
new LiteralExpr(providedIn ?? null);
|
|
// See `convertToProviderExpression()` for why this uses `ForwardRefHandling.None`.
|
|
return createMayBeForwardRefExpression(expression, ForwardRefHandling.None);
|
|
}
|
|
|
|
function convertR3DependencyMetadataArray(facades: R3DependencyMetadataFacade[]|null|
|
|
undefined): R3DependencyMetadata[]|null {
|
|
return facades == null ? null : facades.map(convertR3DependencyMetadata);
|
|
}
|
|
|
|
function convertR3DependencyMetadata(facade: R3DependencyMetadataFacade): R3DependencyMetadata {
|
|
const isAttributeDep = facade.attribute != null; // both `null` and `undefined`
|
|
const rawToken = facade.token === null ? null : new WrappedNodeExpr(facade.token);
|
|
// In JIT mode, if the dep is an `@Attribute()` then we use the attribute name given in
|
|
// `attribute` rather than the `token`.
|
|
const token = isAttributeDep ? new WrappedNodeExpr(facade.attribute) : rawToken;
|
|
return createR3DependencyMetadata(
|
|
token, isAttributeDep, facade.host, facade.optional, facade.self, facade.skipSelf);
|
|
}
|
|
|
|
function convertR3DeclareDependencyMetadata(facade: R3DeclareDependencyMetadataFacade):
|
|
R3DependencyMetadata {
|
|
const isAttributeDep = facade.attribute ?? false;
|
|
const token = facade.token === null ? null : new WrappedNodeExpr(facade.token);
|
|
return createR3DependencyMetadata(
|
|
token, isAttributeDep, facade.host ?? false, facade.optional ?? false, facade.self ?? false,
|
|
facade.skipSelf ?? false);
|
|
}
|
|
|
|
function createR3DependencyMetadata(
|
|
token: WrappedNodeExpr<unknown>|null, isAttributeDep: boolean, host: boolean, optional: boolean,
|
|
self: boolean, skipSelf: boolean): R3DependencyMetadata {
|
|
// If the dep is an `@Attribute()` the `attributeNameType` ought to be the `unknown` type.
|
|
// But types are not available at runtime so we just use a literal `"<unknown>"` string as a dummy
|
|
// marker.
|
|
const attributeNameType = isAttributeDep ? literal('unknown') : null;
|
|
return {token, attributeNameType, host, optional, self, skipSelf};
|
|
}
|
|
|
|
function extractHostBindings(
|
|
propMetadata: {[key: string]: any[]}, sourceSpan: ParseSourceSpan,
|
|
host?: {[key: string]: string}): ParsedHostBindings {
|
|
// First parse the declarations from the metadata.
|
|
const bindings = parseHostBindings(host || {});
|
|
|
|
// After that check host bindings for errors
|
|
const errors = verifyHostBindings(bindings, sourceSpan);
|
|
if (errors.length) {
|
|
throw new Error(errors.map((error: ParseError) => error.msg).join('\n'));
|
|
}
|
|
|
|
// Next, loop over the properties of the object, looking for @HostBinding and @HostListener.
|
|
for (const field in propMetadata) {
|
|
if (propMetadata.hasOwnProperty(field)) {
|
|
propMetadata[field].forEach(ann => {
|
|
if (isHostBinding(ann)) {
|
|
// Since this is a decorator, we know that the value is a class member. Always access it
|
|
// through `this` so that further down the line it can't be confused for a literal value
|
|
// (e.g. if there's a property called `true`).
|
|
bindings.properties[ann.hostPropertyName || field] =
|
|
getSafePropertyAccessString('this', field);
|
|
} else if (isHostListener(ann)) {
|
|
bindings.listeners[ann.eventName || field] = `${field}(${(ann.args || []).join(',')})`;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
return bindings;
|
|
}
|
|
|
|
function isHostBinding(value: any): value is HostBinding {
|
|
return value.ngMetadataName === 'HostBinding';
|
|
}
|
|
|
|
function isHostListener(value: any): value is HostListener {
|
|
return value.ngMetadataName === 'HostListener';
|
|
}
|
|
|
|
|
|
function isInput(value: any): value is Input {
|
|
return value.ngMetadataName === 'Input';
|
|
}
|
|
|
|
function isOutput(value: any): value is Output {
|
|
return value.ngMetadataName === 'Output';
|
|
}
|
|
|
|
function parseInputOutputs(values: string[]): StringMap {
|
|
return values.reduce((map, value) => {
|
|
const [field, property] = value.split(',').map(piece => piece.trim());
|
|
map[field] = property || field;
|
|
return map;
|
|
}, {} as StringMap);
|
|
}
|
|
|
|
function convertDeclarePipeFacadeToMetadata(declaration: R3DeclarePipeFacade): R3PipeMetadata {
|
|
return {
|
|
name: declaration.type.name,
|
|
type: wrapReference(declaration.type),
|
|
internalType: new WrappedNodeExpr(declaration.type),
|
|
typeArgumentCount: 0,
|
|
pipeName: declaration.name,
|
|
deps: null,
|
|
pure: declaration.pure ?? true,
|
|
};
|
|
}
|
|
|
|
function convertDeclareInjectorFacadeToMetadata(declaration: R3DeclareInjectorFacade):
|
|
R3InjectorMetadata {
|
|
return {
|
|
name: declaration.type.name,
|
|
type: wrapReference(declaration.type),
|
|
internalType: new WrappedNodeExpr(declaration.type),
|
|
providers: declaration.providers !== undefined ? new WrappedNodeExpr(declaration.providers) :
|
|
null,
|
|
imports: declaration.imports !== undefined ?
|
|
declaration.imports.map(i => new WrappedNodeExpr(i)) :
|
|
[],
|
|
};
|
|
}
|
|
|
|
export function publishFacade(global: any) {
|
|
const ng: ExportedCompilerFacade = global.ng || (global.ng = {});
|
|
ng.ɵcompilerFacade = new CompilerFacadeImpl();
|
|
}
|