@angular/compiler
Version:
Angular - the compiler library
511 lines • 72.9 kB
JavaScript
/**
* @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 { AST, ImplicitReceiver, RecursiveAstVisitor } from '../../expression_parser/ast';
import { Template } from '../r3_ast';
import { createCssSelector } from './template';
import { getAttrsForDirectiveMatching } from './util';
/**
* Processes `Target`s with a given set of directives and performs a binding operation, which
* returns an object similar to TypeScript's `ts.TypeChecker` that contains knowledge about the
* target.
*/
export class R3TargetBinder {
constructor(directiveMatcher) {
this.directiveMatcher = directiveMatcher;
}
/**
* Perform a binding operation on the given `Target` and return a `BoundTarget` which contains
* metadata about the types referenced in the template.
*/
bind(target) {
if (!target.template) {
// TODO(alxhub): handle targets which contain things like HostBindings, etc.
throw new Error('Binding without a template not yet supported');
}
// First, parse the template into a `Scope` structure. This operation captures the syntactic
// scopes in the template and makes them available for later use.
const scope = Scope.apply(target.template);
// Use the `Scope` to extract the entities present at every level of the template.
const templateEntities = extractTemplateEntities(scope);
// Next, perform directive matching on the template using the `DirectiveBinder`. This returns:
// - directives: Map of nodes (elements & ng-templates) to the directives on them.
// - bindings: Map of inputs, outputs, and attributes to the directive/element that claims
// them. TODO(alxhub): handle multiple directives claiming an input/output/etc.
// - references: Map of #references to their targets.
const { directives, bindings, references } = DirectiveBinder.apply(target.template, this.directiveMatcher);
// Finally, run the TemplateBinder to bind references, variables, and other entities within the
// template. This extracts all the metadata that doesn't depend on directive matching.
const { expressions, symbols, nestingLevel, usedPipes } = TemplateBinder.apply(target.template, scope);
return new R3BoundTarget(target, directives, bindings, references, expressions, symbols, nestingLevel, templateEntities, usedPipes);
}
}
/**
* Represents a binding scope within a template.
*
* Any variables, references, or other named entities declared within the template will
* be captured and available by name in `namedEntities`. Additionally, child templates will
* be analyzed and have their child `Scope`s available in `childScopes`.
*/
class Scope {
constructor(parentScope, template) {
this.parentScope = parentScope;
this.template = template;
/**
* Named members of the `Scope`, such as `Reference`s or `Variable`s.
*/
this.namedEntities = new Map();
/**
* Child `Scope`s for immediately nested `Template`s.
*/
this.childScopes = new Map();
}
static newRootScope() {
return new Scope(null, null);
}
/**
* Process a template (either as a `Template` sub-template with variables, or a plain array of
* template `Node`s) and construct its `Scope`.
*/
static apply(template) {
const scope = Scope.newRootScope();
scope.ingest(template);
return scope;
}
/**
* Internal method to process the template and populate the `Scope`.
*/
ingest(template) {
if (template instanceof Template) {
// Variables on an <ng-template> are defined in the inner scope.
template.variables.forEach(node => this.visitVariable(node));
// Process the nodes of the template.
template.children.forEach(node => node.visit(this));
}
else {
// No overarching `Template` instance, so process the nodes directly.
template.forEach(node => node.visit(this));
}
}
visitElement(element) {
// `Element`s in the template may have `Reference`s which are captured in the scope.
element.references.forEach(node => this.visitReference(node));
// Recurse into the `Element`'s children.
element.children.forEach(node => node.visit(this));
}
visitTemplate(template) {
// References on a <ng-template> are defined in the outer scope, so capture them before
// processing the template's child scope.
template.references.forEach(node => this.visitReference(node));
// Next, create an inner scope and process the template within it.
const scope = new Scope(this, template);
scope.ingest(template);
this.childScopes.set(template, scope);
}
visitVariable(variable) {
// Declare the variable if it's not already.
this.maybeDeclare(variable);
}
visitReference(reference) {
// Declare the variable if it's not already.
this.maybeDeclare(reference);
}
// Unused visitors.
visitContent(content) { }
visitBoundAttribute(attr) { }
visitBoundEvent(event) { }
visitBoundText(text) { }
visitText(text) { }
visitTextAttribute(attr) { }
visitIcu(icu) { }
maybeDeclare(thing) {
// Declare something with a name, as long as that name isn't taken.
if (!this.namedEntities.has(thing.name)) {
this.namedEntities.set(thing.name, thing);
}
}
/**
* Look up a variable within this `Scope`.
*
* This can recurse into a parent `Scope` if it's available.
*/
lookup(name) {
if (this.namedEntities.has(name)) {
// Found in the local scope.
return this.namedEntities.get(name);
}
else if (this.parentScope !== null) {
// Not in the local scope, but there's a parent scope so check there.
return this.parentScope.lookup(name);
}
else {
// At the top level and it wasn't found.
return null;
}
}
/**
* Get the child scope for a `Template`.
*
* This should always be defined.
*/
getChildScope(template) {
const res = this.childScopes.get(template);
if (res === undefined) {
throw new Error(`Assertion error: child scope for ${template} not found`);
}
return res;
}
}
/**
* Processes a template and matches directives on nodes (elements and templates).
*
* Usually used via the static `apply()` method.
*/
class DirectiveBinder {
constructor(matcher, directives, bindings, references) {
this.matcher = matcher;
this.directives = directives;
this.bindings = bindings;
this.references = references;
}
/**
* Process a template (list of `Node`s) and perform directive matching against each node.
*
* @param template the list of template `Node`s to match (recursively).
* @param selectorMatcher a `SelectorMatcher` containing the directives that are in scope for
* this template.
* @returns three maps which contain information about directives in the template: the
* `directives` map which lists directives matched on each node, the `bindings` map which
* indicates which directives claimed which bindings (inputs, outputs, etc), and the `references`
* map which resolves #references (`Reference`s) within the template to the named directive or
* template node.
*/
static apply(template, selectorMatcher) {
const directives = new Map();
const bindings = new Map();
const references = new Map();
const matcher = new DirectiveBinder(selectorMatcher, directives, bindings, references);
matcher.ingest(template);
return { directives, bindings, references };
}
ingest(template) {
template.forEach(node => node.visit(this));
}
visitElement(element) {
this.visitElementOrTemplate(element.name, element);
}
visitTemplate(template) {
this.visitElementOrTemplate('ng-template', template);
}
visitElementOrTemplate(elementName, node) {
// First, determine the HTML shape of the node for the purpose of directive matching.
// Do this by building up a `CssSelector` for the node.
const cssSelector = createCssSelector(elementName, getAttrsForDirectiveMatching(node));
// Next, use the `SelectorMatcher` to get the list of directives on the node.
const directives = [];
this.matcher.match(cssSelector, (_, directive) => directives.push(directive));
if (directives.length > 0) {
this.directives.set(node, directives);
}
// Resolve any references that are created on this node.
node.references.forEach(ref => {
let dirTarget = null;
// If the reference expression is empty, then it matches the "primary" directive on the node
// (if there is one). Otherwise it matches the host node itself (either an element or
// <ng-template> node).
if (ref.value.trim() === '') {
// This could be a reference to a component if there is one.
dirTarget = directives.find(dir => dir.isComponent) || null;
}
else {
// This should be a reference to a directive exported via exportAs.
dirTarget =
directives.find(dir => dir.exportAs !== null && dir.exportAs.some(value => value === ref.value)) ||
null;
// Check if a matching directive was found.
if (dirTarget === null) {
// No matching directive was found - this reference points to an unknown target. Leave it
// unmapped.
return;
}
}
if (dirTarget !== null) {
// This reference points to a directive.
this.references.set(ref, { directive: dirTarget, node });
}
else {
// This reference points to the node itself.
this.references.set(ref, node);
}
});
const setAttributeBinding = (attribute, ioType) => {
const dir = directives.find(dir => dir[ioType].hasBindingPropertyName(attribute.name));
const binding = dir !== undefined ? dir : node;
this.bindings.set(attribute, binding);
};
// Node inputs (bound attributes) and text attributes can be bound to an
// input on a directive.
node.inputs.forEach(input => setAttributeBinding(input, 'inputs'));
node.attributes.forEach(attr => setAttributeBinding(attr, 'inputs'));
if (node instanceof Template) {
node.templateAttrs.forEach(attr => setAttributeBinding(attr, 'inputs'));
}
// Node outputs (bound events) can be bound to an output on a directive.
node.outputs.forEach(output => setAttributeBinding(output, 'outputs'));
// Recurse into the node's children.
node.children.forEach(child => child.visit(this));
}
// Unused visitors.
visitContent(content) { }
visitVariable(variable) { }
visitReference(reference) { }
visitTextAttribute(attribute) { }
visitBoundAttribute(attribute) { }
visitBoundEvent(attribute) { }
visitBoundAttributeOrEvent(node) { }
visitText(text) { }
visitBoundText(text) { }
visitIcu(icu) { }
}
/**
* Processes a template and extract metadata about expressions and symbols within.
*
* This is a companion to the `DirectiveBinder` that doesn't require knowledge of directives matched
* within the template in order to operate.
*
* Expressions are visited by the superclass `RecursiveAstVisitor`, with custom logic provided
* by overridden methods from that visitor.
*/
class TemplateBinder extends RecursiveAstVisitor {
constructor(bindings, symbols, usedPipes, nestingLevel, scope, template, level) {
super();
this.bindings = bindings;
this.symbols = symbols;
this.usedPipes = usedPipes;
this.nestingLevel = nestingLevel;
this.scope = scope;
this.template = template;
this.level = level;
this.pipesUsed = [];
// Save a bit of processing time by constructing this closure in advance.
this.visitNode = (node) => node.visit(this);
}
// This method is defined to reconcile the type of TemplateBinder since both
// RecursiveAstVisitor and Visitor define the visit() method in their
// interfaces.
visit(node, context) {
if (node instanceof AST) {
node.visit(this, context);
}
else {
node.visit(this);
}
}
/**
* Process a template and extract metadata about expressions and symbols within.
*
* @param template the nodes of the template to process
* @param scope the `Scope` of the template being processed.
* @returns three maps which contain metadata about the template: `expressions` which interprets
* special `AST` nodes in expressions as pointing to references or variables declared within the
* template, `symbols` which maps those variables and references to the nested `Template` which
* declares them, if any, and `nestingLevel` which associates each `Template` with a integer
* nesting level (how many levels deep within the template structure the `Template` is), starting
* at 1.
*/
static apply(template, scope) {
const expressions = new Map();
const symbols = new Map();
const nestingLevel = new Map();
const usedPipes = new Set();
// The top-level template has nesting level 0.
const binder = new TemplateBinder(expressions, symbols, usedPipes, nestingLevel, scope, template instanceof Template ? template : null, 0);
binder.ingest(template);
return { expressions, symbols, nestingLevel, usedPipes };
}
ingest(template) {
if (template instanceof Template) {
// For <ng-template>s, process only variables and child nodes. Inputs, outputs, templateAttrs,
// and references were all processed in the scope of the containing template.
template.variables.forEach(this.visitNode);
template.children.forEach(this.visitNode);
// Set the nesting level.
this.nestingLevel.set(template, this.level);
}
else {
// Visit each node from the top-level template.
template.forEach(this.visitNode);
}
}
visitElement(element) {
// Visit the inputs, outputs, and children of the element.
element.inputs.forEach(this.visitNode);
element.outputs.forEach(this.visitNode);
element.children.forEach(this.visitNode);
}
visitTemplate(template) {
// First, visit inputs, outputs and template attributes of the template node.
template.inputs.forEach(this.visitNode);
template.outputs.forEach(this.visitNode);
template.templateAttrs.forEach(this.visitNode);
// References are also evaluated in the outer context.
template.references.forEach(this.visitNode);
// Next, recurse into the template using its scope, and bumping the nesting level up by one.
const childScope = this.scope.getChildScope(template);
const binder = new TemplateBinder(this.bindings, this.symbols, this.usedPipes, this.nestingLevel, childScope, template, this.level + 1);
binder.ingest(template);
}
visitVariable(variable) {
// Register the `Variable` as a symbol in the current `Template`.
if (this.template !== null) {
this.symbols.set(variable, this.template);
}
}
visitReference(reference) {
// Register the `Reference` as a symbol in the current `Template`.
if (this.template !== null) {
this.symbols.set(reference, this.template);
}
}
// Unused template visitors
visitText(text) { }
visitContent(content) { }
visitTextAttribute(attribute) { }
visitIcu(icu) {
Object.keys(icu.vars).forEach(key => icu.vars[key].visit(this));
Object.keys(icu.placeholders).forEach(key => icu.placeholders[key].visit(this));
}
// The remaining visitors are concerned with processing AST expressions within template bindings
visitBoundAttribute(attribute) {
attribute.value.visit(this);
}
visitBoundEvent(event) {
event.handler.visit(this);
}
visitBoundText(text) {
text.value.visit(this);
}
visitPipe(ast, context) {
this.usedPipes.add(ast.name);
return super.visitPipe(ast, context);
}
// These five types of AST expressions can refer to expression roots, which could be variables
// or references in the current scope.
visitPropertyRead(ast, context) {
this.maybeMap(context, ast, ast.name);
return super.visitPropertyRead(ast, context);
}
visitSafePropertyRead(ast, context) {
this.maybeMap(context, ast, ast.name);
return super.visitSafePropertyRead(ast, context);
}
visitPropertyWrite(ast, context) {
this.maybeMap(context, ast, ast.name);
return super.visitPropertyWrite(ast, context);
}
visitMethodCall(ast, context) {
this.maybeMap(context, ast, ast.name);
return super.visitMethodCall(ast, context);
}
visitSafeMethodCall(ast, context) {
this.maybeMap(context, ast, ast.name);
return super.visitSafeMethodCall(ast, context);
}
maybeMap(scope, ast, name) {
// If the receiver of the expression isn't the `ImplicitReceiver`, this isn't the root of an
// `AST` expression that maps to a `Variable` or `Reference`.
if (!(ast.receiver instanceof ImplicitReceiver)) {
return;
}
// Check whether the name exists in the current scope. If so, map it. Otherwise, the name is
// probably a property on the top-level component context.
let target = this.scope.lookup(name);
if (target !== null) {
this.bindings.set(ast, target);
}
}
}
/**
* Metadata container for a `Target` that allows queries for specific bits of metadata.
*
* See `BoundTarget` for documentation on the individual methods.
*/
export class R3BoundTarget {
constructor(target, directives, bindings, references, exprTargets, symbols, nestingLevel, templateEntities, usedPipes) {
this.target = target;
this.directives = directives;
this.bindings = bindings;
this.references = references;
this.exprTargets = exprTargets;
this.symbols = symbols;
this.nestingLevel = nestingLevel;
this.templateEntities = templateEntities;
this.usedPipes = usedPipes;
}
getEntitiesInTemplateScope(template) {
var _a;
return (_a = this.templateEntities.get(template)) !== null && _a !== void 0 ? _a : new Set();
}
getDirectivesOfNode(node) {
return this.directives.get(node) || null;
}
getReferenceTarget(ref) {
return this.references.get(ref) || null;
}
getConsumerOfBinding(binding) {
return this.bindings.get(binding) || null;
}
getExpressionTarget(expr) {
return this.exprTargets.get(expr) || null;
}
getTemplateOfSymbol(symbol) {
return this.symbols.get(symbol) || null;
}
getNestingLevel(template) {
return this.nestingLevel.get(template) || 0;
}
getUsedDirectives() {
const set = new Set();
this.directives.forEach(dirs => dirs.forEach(dir => set.add(dir)));
return Array.from(set.values());
}
getUsedPipes() {
return Array.from(this.usedPipes);
}
}
function extractTemplateEntities(rootScope) {
const entityMap = new Map();
function extractScopeEntities(scope) {
if (entityMap.has(scope.template)) {
return entityMap.get(scope.template);
}
const currentEntities = scope.namedEntities;
let templateEntities;
if (scope.parentScope !== null) {
templateEntities = new Map([...extractScopeEntities(scope.parentScope), ...currentEntities]);
}
else {
templateEntities = new Map(currentEntities);
}
entityMap.set(scope.template, templateEntities);
return templateEntities;
}
const scopesToProcess = [rootScope];
while (scopesToProcess.length > 0) {
const scope = scopesToProcess.pop();
for (const childScope of scope.childScopes.values()) {
scopesToProcess.push(childScope);
}
extractScopeEntities(scope);
}
const templateEntities = new Map();
for (const [template, entities] of entityMap) {
templateEntities.set(template, new Set(entities.values()));
}
return templateEntities;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"t2_binder.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler/src/render3/view/t2_binder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {AST, BindingPipe, ImplicitReceiver, MethodCall, PropertyRead, PropertyWrite, RecursiveAstVisitor, SafeMethodCall, SafePropertyRead} from '../../expression_parser/ast';\nimport {SelectorMatcher} from '../../selector';\nimport {BoundAttribute, BoundEvent, BoundText, Content, Element, Icu, Node, Reference, Template, Text, TextAttribute, Variable, Visitor} from '../r3_ast';\n\nimport {BoundTarget, DirectiveMeta, Target, TargetBinder} from './t2_api';\nimport {createCssSelector} from './template';\nimport {getAttrsForDirectiveMatching} from './util';\n\n\n/**\n * Processes `Target`s with a given set of directives and performs a binding operation, which\n * returns an object similar to TypeScript's `ts.TypeChecker` that contains knowledge about the\n * target.\n */\nexport class R3TargetBinder<DirectiveT extends DirectiveMeta> implements TargetBinder<DirectiveT> {\n  constructor(private directiveMatcher: SelectorMatcher<DirectiveT>) {}\n\n  /**\n   * Perform a binding operation on the given `Target` and return a `BoundTarget` which contains\n   * metadata about the types referenced in the template.\n   */\n  bind(target: Target): BoundTarget<DirectiveT> {\n    if (!target.template) {\n      // TODO(alxhub): handle targets which contain things like HostBindings, etc.\n      throw new Error('Binding without a template not yet supported');\n    }\n\n    // First, parse the template into a `Scope` structure. This operation captures the syntactic\n    // scopes in the template and makes them available for later use.\n    const scope = Scope.apply(target.template);\n\n\n    // Use the `Scope` to extract the entities present at every level of the template.\n    const templateEntities = extractTemplateEntities(scope);\n\n    // Next, perform directive matching on the template using the `DirectiveBinder`. This returns:\n    //   - directives: Map of nodes (elements & ng-templates) to the directives on them.\n    //   - bindings: Map of inputs, outputs, and attributes to the directive/element that claims\n    //     them. TODO(alxhub): handle multiple directives claiming an input/output/etc.\n    //   - references: Map of #references to their targets.\n    const {directives, bindings, references} =\n        DirectiveBinder.apply(target.template, this.directiveMatcher);\n    // Finally, run the TemplateBinder to bind references, variables, and other entities within the\n    // template. This extracts all the metadata that doesn't depend on directive matching.\n    const {expressions, symbols, nestingLevel, usedPipes} =\n        TemplateBinder.apply(target.template, scope);\n    return new R3BoundTarget(\n        target, directives, bindings, references, expressions, symbols, nestingLevel,\n        templateEntities, usedPipes);\n  }\n}\n\n/**\n * Represents a binding scope within a template.\n *\n * Any variables, references, or other named entities declared within the template will\n * be captured and available by name in `namedEntities`. Additionally, child templates will\n * be analyzed and have their child `Scope`s available in `childScopes`.\n */\nclass Scope implements Visitor {\n  /**\n   * Named members of the `Scope`, such as `Reference`s or `Variable`s.\n   */\n  readonly namedEntities = new Map<string, Reference|Variable>();\n\n  /**\n   * Child `Scope`s for immediately nested `Template`s.\n   */\n  readonly childScopes = new Map<Template, Scope>();\n\n  private constructor(readonly parentScope: Scope|null, readonly template: Template|null) {}\n\n  static newRootScope(): Scope {\n    return new Scope(null, null);\n  }\n\n  /**\n   * Process a template (either as a `Template` sub-template with variables, or a plain array of\n   * template `Node`s) and construct its `Scope`.\n   */\n  static apply(template: Node[]): Scope {\n    const scope = Scope.newRootScope();\n    scope.ingest(template);\n    return scope;\n  }\n\n  /**\n   * Internal method to process the template and populate the `Scope`.\n   */\n  private ingest(template: Template|Node[]): void {\n    if (template instanceof Template) {\n      // Variables on an <ng-template> are defined in the inner scope.\n      template.variables.forEach(node => this.visitVariable(node));\n\n      // Process the nodes of the template.\n      template.children.forEach(node => node.visit(this));\n    } else {\n      // No overarching `Template` instance, so process the nodes directly.\n      template.forEach(node => node.visit(this));\n    }\n  }\n\n  visitElement(element: Element) {\n    // `Element`s in the template may have `Reference`s which are captured in the scope.\n    element.references.forEach(node => this.visitReference(node));\n\n    // Recurse into the `Element`'s children.\n    element.children.forEach(node => node.visit(this));\n  }\n\n  visitTemplate(template: Template) {\n    // References on a <ng-template> are defined in the outer scope, so capture them before\n    // processing the template's child scope.\n    template.references.forEach(node => this.visitReference(node));\n\n    // Next, create an inner scope and process the template within it.\n    const scope = new Scope(this, template);\n    scope.ingest(template);\n    this.childScopes.set(template, scope);\n  }\n\n  visitVariable(variable: Variable) {\n    // Declare the variable if it's not already.\n    this.maybeDeclare(variable);\n  }\n\n  visitReference(reference: Reference) {\n    // Declare the variable if it's not already.\n    this.maybeDeclare(reference);\n  }\n\n  // Unused visitors.\n  visitContent(content: Content) {}\n  visitBoundAttribute(attr: BoundAttribute) {}\n  visitBoundEvent(event: BoundEvent) {}\n  visitBoundText(text: BoundText) {}\n  visitText(text: Text) {}\n  visitTextAttribute(attr: TextAttribute) {}\n  visitIcu(icu: Icu) {}\n\n  private maybeDeclare(thing: Reference|Variable) {\n    // Declare something with a name, as long as that name isn't taken.\n    if (!this.namedEntities.has(thing.name)) {\n      this.namedEntities.set(thing.name, thing);\n    }\n  }\n\n  /**\n   * Look up a variable within this `Scope`.\n   *\n   * This can recurse into a parent `Scope` if it's available.\n   */\n  lookup(name: string): Reference|Variable|null {\n    if (this.namedEntities.has(name)) {\n      // Found in the local scope.\n      return this.namedEntities.get(name)!;\n    } else if (this.parentScope !== null) {\n      // Not in the local scope, but there's a parent scope so check there.\n      return this.parentScope.lookup(name);\n    } else {\n      // At the top level and it wasn't found.\n      return null;\n    }\n  }\n\n  /**\n   * Get the child scope for a `Template`.\n   *\n  