feat(compiler): integrate compiler with view engine - di, query, cont…

modules/@angular/compiler/src/compile_metadata.ts

@@ -304,6 +304,7 @@ export interface CompileDirectiveSummary extends CompileTypeSummary {
   providers: CompileProviderMetadata[];
   viewProviders: CompileProviderMetadata[];
   queries: CompileQueryMetadata[];
+  viewQueries: CompileQueryMetadata[];
   entryComponents: CompileEntryComponentMetadata[];
   changeDetection: ChangeDetectionStrategy;
   template: CompileTemplateSummary;
@@ -480,6 +481,7 @@ export class CompileDirectiveMetadata {
       providers: this.providers,
       viewProviders: this.viewProviders,
       queries: this.queries,
+      viewQueries: this.viewQueries,
       entryComponents: this.entryComponents,
       changeDetection: this.changeDetection,
       template: this.template && this.template.toSummary(),

modules/@angular/compiler/src/identifiers.ts

@@ -368,6 +368,12 @@ export class Identifiers {
       {name: 'ɵviewEngine', moduleUrl: CORE, member: 'pipeDef', runtime: ɵviewEngine.pipeDef};
   static nodeValue: IdentifierSpec =
       {name: 'ɵviewEngine', moduleUrl: CORE, member: 'nodeValue', runtime: ɵviewEngine.nodeValue};
+  static ngContentDef: IdentifierSpec = {
+    name: 'ɵviewEngine',
+    moduleUrl: CORE,
+    member: 'ngContentDef',
+    runtime: ɵviewEngine.ngContentDef
+  };
   static unwrapValue: IdentifierSpec = {
     name: 'ɵviewEngine',
     moduleUrl: CORE,

modules/@angular/compiler/src/provider_analyzer.ts

@@ -11,15 +11,15 @@ import {CompileDiDependencyMetadata, CompileDirectiveMetadata, CompileDirectiveS
 import {isBlank, isPresent} from './facade/lang';
 import {Identifiers, createIdentifierToken, resolveIdentifier} from './identifiers';
 import {ParseError, ParseSourceSpan} from './parse_util';
-import {AttrAst, DirectiveAst, ProviderAst, ProviderAstType, QueryId, QueryMatch, ReferenceAst} from './template_parser/template_ast';
+import {AttrAst, DirectiveAst, ProviderAst, ProviderAstType, QueryMatch, ReferenceAst} from './template_parser/template_ast';
 
 export class ProviderError extends ParseError {
   constructor(message: string, span: ParseSourceSpan) { super(span, message); }
 }
 
 export interface QueryWithId {
   meta: CompileQueryMetadata;
-  id: QueryId;
+  queryId: number;
 }
 
 export class ProviderViewContext {
@@ -57,16 +57,21 @@ export class ProviderElementContext {
   constructor(
       public viewContext: ProviderViewContext, private _parent: ProviderElementContext,
       private _isViewRoot: boolean, private _directiveAsts: DirectiveAst[], attrs: AttrAst[],
-      refs: ReferenceAst[], private _sourceSpan: ParseSourceSpan) {
+      refs: ReferenceAst[], isTemplate: boolean, contentQueryStartId: number,
+      private _sourceSpan: ParseSourceSpan) {
     this._attrs = {};
     attrs.forEach((attrAst) => this._attrs[attrAst.name] = attrAst.value);
     const directivesMeta = _directiveAsts.map(directiveAst => directiveAst.directive);
     this._allProviders =
         _resolveProvidersFromDirectives(directivesMeta, _sourceSpan, viewContext.errors);
-    this._contentQueries = _getContentQueries(this.depth, directivesMeta);
+    this._contentQueries = _getContentQueries(contentQueryStartId, directivesMeta);
     Array.from(this._allProviders.values()).forEach((provider) => {
       this._addQueryReadsTo(provider.token, provider.token, this._queriedTokens);
     });
+    if (isTemplate) {
+      const templateRefId = createIdentifierToken(Identifiers.TemplateRef);
+      this._addQueryReadsTo(templateRefId, templateRefId, this._queriedTokens);
+    }
     refs.forEach((refAst) => {
       let defaultQueryValue = refAst.value || createIdentifierToken(Identifiers.ElementRef);
       this._addQueryReadsTo({value: refAst.name}, defaultQueryValue, this._queriedTokens);
@@ -91,16 +96,6 @@ export class ProviderElementContext {
     });
   }
 
-  get depth(): number {
-    let d = 0;
-    let current: ProviderElementContext = this;
-    while (current._parent) {
-      d++;
-      current = current._parent;
-    }
-    return d;
-  }
-
   get transformProviders(): ProviderAst[] {
     return Array.from(this._transformedProviders.values());
   }
@@ -133,7 +128,7 @@ export class ProviderElementContext {
         queryMatches = [];
         queryReadTokens.set(tokenRef, queryMatches);
       }
-      queryMatches.push({query: query.id, value: queryValue});
+      queryMatches.push({queryId: query.queryId, value: queryValue});
     });
   }
 
@@ -483,24 +478,24 @@ function _resolveProviders(
 
 
 function _getViewQueries(component: CompileDirectiveMetadata): Map<any, QueryWithId[]> {
+  // Note: queries start with id 1 so we can use the number in a Bloom filter!
+  let viewQueryId = 1;
   const viewQueries = new Map<any, QueryWithId[]>();
   if (component.viewQueries) {
     component.viewQueries.forEach(
-        (query, queryIndex) => _addQueryToTokenMap(
-            viewQueries,
-            {meta: query, id: {elementDepth: null, directiveIndex: null, queryIndex: queryIndex}}));
+        (query) => _addQueryToTokenMap(viewQueries, {meta: query, queryId: viewQueryId++}));
   }
   return viewQueries;
 }
 
 function _getContentQueries(
-    elementDepth: number, directives: CompileDirectiveSummary[]): Map<any, QueryWithId[]> {
+    contentQueryStartId: number, directives: CompileDirectiveSummary[]): Map<any, QueryWithId[]> {
+  let contentQueryId = contentQueryStartId;
   const contentQueries = new Map<any, QueryWithId[]>();
   directives.forEach((directive, directiveIndex) => {
     if (directive.queries) {
       directive.queries.forEach(
-          (query, queryIndex) => _addQueryToTokenMap(
-              contentQueries, {meta: query, id: {elementDepth, directiveIndex, queryIndex}}));
+          (query) => _addQueryToTokenMap(contentQueries, {meta: query, queryId: contentQueryId++}));
     }
   });
   return contentQueries;

modules/@angular/compiler/src/template_parser/template_ast.ts

@@ -170,7 +170,7 @@ export class DirectiveAst implements TemplateAst {
   constructor(
       public directive: CompileDirectiveSummary, public inputs: BoundDirectivePropertyAst[],
       public hostProperties: BoundElementPropertyAst[], public hostEvents: BoundEventAst[],
-      public sourceSpan: ParseSourceSpan) {}
+      public contentQueryStartId: number, public sourceSpan: ParseSourceSpan) {}
   visit(visitor: TemplateAstVisitor, context: any): any {
     return visitor.visitDirective(this, context);
   }
@@ -241,17 +241,8 @@ export enum PropertyBindingType {
   Animation
 }
 
-/**
- * This id differentiates a query on an element from any query on any child.
- */
-export interface QueryId {
-  elementDepth: number;
-  directiveIndex: number;
-  queryIndex: number;
-}
-
 export interface QueryMatch {
-  query: QueryId;
+  queryId: number;
   value: CompileTokenMetadata;
 }
 

modules/@angular/compiler/src/template_parser/template_parser.ts

@@ -207,12 +207,15 @@ export class TemplateParser {
 class TemplateParseVisitor implements html.Visitor {
   selectorMatcher = new SelectorMatcher();
   directivesIndex = new Map<CompileDirectiveSummary, number>();
-  ngContentCount: number = 0;
+  ngContentCount = 0;
+  contentQueryStartId: number;
 
   constructor(
       public providerViewContext: ProviderViewContext, directives: CompileDirectiveSummary[],
       private _bindingParser: BindingParser, private _schemaRegistry: ElementSchemaRegistry,
       private _schemas: SchemaMetadata[], private _targetErrors: TemplateParseError[]) {
+    // Note: queries start with id 1 so we can use the number in a Bloom filter!
+    this.contentQueryStartId = providerViewContext.component.viewQueries.length + 1;
     directives.forEach((directive, index) => {
       const selector = CssSelector.parse(directive.selector);
       this.selectorMatcher.addSelectables(selector, directive);
@@ -241,6 +244,7 @@ class TemplateParseVisitor implements html.Visitor {
   visitComment(comment: html.Comment, context: any): any { return null; }
 
   visitElement(element: html.Element, parent: ElementContext): any {
+    const queryStartIndex = this.contentQueryStartId;
     const nodeName = element.name;
     const preparsedElement = preparseElement(element);
     if (preparsedElement.type === PreparsedElementType.SCRIPT ||
@@ -322,9 +326,9 @@ class TemplateParseVisitor implements html.Visitor {
 
     const providerContext = new ProviderElementContext(
         this.providerViewContext, parent.providerContext, isViewRoot, directiveAsts, attrs,
-        references, element.sourceSpan);
+        references, isTemplateElement, queryStartIndex, element.sourceSpan);
 
-    const children = html.visitAll(
+    const children: TemplateAst[] = html.visitAll(
         preparsedElement.nonBindable ? NON_BINDABLE_VISITOR : this, element.children,
         ElementContext.create(
             isTemplateElement, directiveAsts,
@@ -378,6 +382,7 @@ class TemplateParseVisitor implements html.Visitor {
     }
 
     if (hasInlineTemplates) {
+      const templateQueryStartIndex = this.contentQueryStartId;
       const templateCssSelector =
           createElementCssSelector(TEMPLATE_ELEMENT, templateMatchableAttrs);
       const {directives: templateDirectiveMetas} =
@@ -392,7 +397,7 @@ class TemplateParseVisitor implements html.Visitor {
           templateDirectiveAsts, templateElementProps, element.sourceSpan);
       const templateProviderContext = new ProviderElementContext(
           this.providerViewContext, parent.providerContext, parent.isTemplateElement,
-          templateDirectiveAsts, [], [], element.sourceSpan);
+          templateDirectiveAsts, [], [], true, templateQueryStartIndex, element.sourceSpan);
       templateProviderContext.afterElement();
 
       parsedElement = new EmbeddedTemplateAst(
@@ -585,8 +590,11 @@ class TemplateParseVisitor implements html.Visitor {
           matchedReferences.add(elOrDirRef.name);
         }
       });
+      const contentQueryStartId = this.contentQueryStartId;
+      this.contentQueryStartId += directive.queries.length;
       return new DirectiveAst(
-          directive, directiveProperties, hostProperties, hostEvents, sourceSpan);
+          directive, directiveProperties, hostProperties, hostEvents, contentQueryStartId,
+          sourceSpan);
     });
 
     elementOrDirectiveRefs.forEach((elOrDirRef) => {
@@ -779,7 +787,7 @@ class NonBindableVisitor implements html.Visitor {
     const attrNameAndValues = ast.attrs.map((attr): [string, string] => [attr.name, attr.value]);
     const selector = createElementCssSelector(ast.name, attrNameAndValues);
     const ngContentIndex = parent.findNgContentIndex(selector);
-    const children = html.visitAll(this, ast.children, EMPTY_ELEMENT_CONTEXT);
+    const children: TemplateAst[] = html.visitAll(this, ast.children, EMPTY_ELEMENT_CONTEXT);
     return new ElementAst(
         ast.name, html.visitAll(this, ast.attrs), [], [], [], [], [], false, [], children,
         ngContentIndex, ast.sourceSpan, ast.endSourceSpan);