feat(compiler): pass compilation unit to the parser

Author: vsavkin

modules/benchmarks/src/change_detection/change_detection_benchmark.js

@@ -108,16 +108,16 @@ function setUpChangeDetection() {
  var parentRange = parentProto.instantiate(dispatcher, MapWrapper.create());
 
  var astWithSource = [
- parser.parseBinding('field0'),
- parser.parseBinding('field1'),
- parser.parseBinding('field2'),
- parser.parseBinding('field3'),
- parser.parseBinding('field4'),
- parser.parseBinding('field5'),
- parser.parseBinding('field6'),
- parser.parseBinding('field7'),
- parser.parseBinding('field8'),
- parser.parseBinding('field9')
+ parser.parseBinding('field0', null),
+ parser.parseBinding('field1', null),
+ parser.parseBinding('field2', null),
+ parser.parseBinding('field3', null),
+ parser.parseBinding('field4', null),
+ parser.parseBinding('field5', null),
+ parser.parseBinding('field6', null),
+ parser.parseBinding('field7', null),
+ parser.parseBinding('field8', null),
+ parser.parseBinding('field9', null)
  ];
 
  function proto(i) {

modules/change_detection/src/parser/ast.js

@@ -385,8 +385,10 @@ export class FunctionCall extends AST {
 export class ASTWithSource extends AST {
  ast:AST;
  source:string;
- constructor(ast:AST, source:string) {
+ location:string;
+ constructor(ast:AST, source:string, location:string) {
  this.source = source;
+ this.location = location;
  this.ast = ast;
  }
 
@@ -407,7 +409,7 @@ export class ASTWithSource extends AST {
  }
 
  toString():string {
- return this.source;
+ return `${this.source} in ${this.location}`;
  }
 }
 

modules/change_detection/src/parser/parser.js

@@ -36,32 +36,34 @@ export class Parser {
  this._reflector = isPresent(providedReflector) ? providedReflector : reflector;
  }
 
- parseAction(input:string):ASTWithSource {
+ parseAction(input:string, location:any):ASTWithSource {
  var tokens = this._lexer.tokenize(input);
- var ast = new _ParseAST(input, tokens, this._reflector, true).parseChain();
- return new ASTWithSource(ast, input);
+ var ast = new _ParseAST(input, location, tokens, this._reflector, true).parseChain();
+ return new ASTWithSource(ast, input, location);
  }
 
- parseBinding(input:string):ASTWithSource {
+ parseBinding(input:string, location:any):ASTWithSource {
  var tokens = this._lexer.tokenize(input);
- var ast = new _ParseAST(input, tokens, this._reflector, false).parseChain();
- return new ASTWithSource(ast, input);
+ var ast = new _ParseAST(input, location, tokens, this._reflector, false).parseChain();
+ return new ASTWithSource(ast, input, location);
  }
 
- parseTemplateBindings(input:string):List<TemplateBinding> {
+ parseTemplateBindings(input:string, location:any):List<TemplateBinding> {
  var tokens = this._lexer.tokenize(input);
- return new _ParseAST(input, tokens, this._reflector, false).parseTemplateBindings();
+ return new _ParseAST(input, location, tokens, this._reflector, false).parseTemplateBindings();
  }
 }
 
 class _ParseAST {
  input:string;
+ location:any;
  tokens:List<Token>;
  reflector:Reflector;
  parseAction:boolean;
  index:int;
- constructor(input:string, tokens:List, reflector:Reflector, parseAction:boolean) {
+ constructor(input:string, location:any, tokens:List, reflector:Reflector, parseAction:boolean) {
  this.input = input;
+ this.location = location;
  this.tokens = tokens;
  this.index = 0;
  this.reflector = reflector;
@@ -451,7 +453,7 @@ class _ParseAST {
  var start = this.inputIndex;
  var ast = this.parseExpression();
  var source = this.input.substring(start, this.inputIndex);
- expression = new ASTWithSource(ast, source);
+ expression = new ASTWithSource(ast, source, this.location);
  }
  }
  ListWrapper.push(bindings, new TemplateBinding(key, name, expression));
@@ -469,6 +471,6 @@ class _ParseAST {
  ? `at column ${this.tokens[index].index + 1} in`
  : `at the end of the expression`;
 
- throw new BaseException(`Parser Error: ${message} ${location} [${this.input}]`);
+ throw new BaseException(`Parser Error: ${message} ${location} [${this.input}] in ${this.location}`);
  }
 }

modules/change_detection/test/change_detector_spec.js

@@ -20,7 +20,7 @@ import {Record} from 'change_detection/record';
 export function main() {
  function ast(exp:string) {
  var parser = new Parser(new Lexer());
- return parser.parseBinding(exp);
+ return parser.parseBinding(exp, 'location');
  }
 
  function createChangeDetector(memo:string, exp:string, context = null, formatters = null,
@@ -451,7 +451,7 @@ export function main() {
  expect(() => {
  var cd = new ChangeDetector(rr, true);
  cd.detectChanges();
- }).toThrowError(new RegExp("Expression 'a' has changed after it was checked"));
+ }).toThrowError(new RegExp("Expression 'a in location' has changed after it was checked"));
  });
  });
  });

modules/change_detection/test/parser/parser_spec.js

@@ -35,16 +35,16 @@ export function main() {
  return new Parser(new Lexer(), reflector);
  }
 
- function parseAction(text) {
- return createParser().parseAction(text).ast;
+ function parseAction(text, location = null) {
+ return createParser().parseAction(text, location);
  }
 
- function parseBinding(text) {
- return createParser().parseBinding(text).ast;
+ function parseBinding(text, location = null) {
+ return createParser().parseBinding(text, location);
  }
 
- function parseTemplateBindings(text) {
- return createParser().parseTemplateBindings(text);
+ function parseTemplateBindings(text, location = null) {
+ return createParser().parseTemplateBindings(text, location);
  }
 
  function expectEval(text, passedInContext = null) {
@@ -340,7 +340,7 @@ export function main() {
 
  it('should pass exceptions', () => {
  expect(() => {
- createParser().parseAction('a()').ast.eval(td(() => {throw new BaseException("boo to you")}));
+ parseAction('a()').eval(td(() => {throw new BaseException("boo to you")}));
  }).toThrowError('boo to you');
  });
 
@@ -352,20 +352,24 @@ export function main() {
  });
 
  it('should store the source in the result', () => {
- expect(createParser().parseAction('someExpr').source).toBe('someExpr');
+ expect(parseAction('someExpr').source).toBe('someExpr');
+ });
+
+ it('should store the passed-in location', () => {
+ expect(parseAction('someExpr', 'location').location).toBe('location');
  });
  });
 
  describe("parseBinding", () => {
  describe("formatters", () => {
  it("should parse formatters", () => {
- var exp = parseBinding("'Foo'|uppercase");
+ var exp = parseBinding("'Foo'|uppercase").ast;
  expect(exp).toBeAnInstanceOf(Formatter);
  expect(exp.name).toEqual("uppercase");
  });
 
  it("should parse formatters with args", () => {
- var exp = parseBinding("1|increment:2");
+ var exp = parseBinding("1|increment:2").ast;
  expect(exp).toBeAnInstanceOf(Formatter);
  expect(exp.name).toEqual("increment");
  expect(exp.args[0]).toBeAnInstanceOf(LiteralPrimitive);
@@ -380,7 +384,11 @@ export function main() {
  });
 
  it('should store the source in the result', () => {
- expect(createParser().parseBinding('someExpr').source).toBe('someExpr');
+ expect(parseBinding('someExpr').source).toBe('someExpr');
+ });
+
+ it('should store the passed-in location', () => {
+ expect(parseBinding('someExpr', 'location').location).toBe('location');
  });
 
  it('should throw on chain expressions', () => {
@@ -409,7 +417,7 @@ export function main() {
 
  function exprAsts(templateBindings) {
  return ListWrapper.map(templateBindings,
- (binding) => isPresent(binding.expression) ? binding.expression.ast : null );
+ (binding) => isPresent(binding.expression) ? binding.expression : null );
  }
 
  it('should parse an empty string', () => {
@@ -482,6 +490,11 @@ export function main() {
  expect(bindings[0].expression.source).toEqual('1');
  expect(bindings[1].expression.source).toEqual('2');
  });
+
+ it('should store the passed-in location', () => {
+ var bindings = parseTemplateBindings("a 1,b 2", 'location');
+ expect(bindings[0].expression.location).toEqual('location');
+ });
  });
  });
 }

modules/core/src/compiler/compiler.js

@@ -62,7 +62,7 @@ export class Compiler {
  for (var i=0; i<directives.length; i++) {
  ListWrapper.push(annotatedDirectives, this._reader.annotatedType(directives[i]));
  }
- return createDefaultSteps(this._parser, annotatedDirectives);
+ return createDefaultSteps(this._parser, component, annotatedDirectives);
  }
 
  compile(component:Type, templateRoot:Element = null):Promise<ProtoView> {

modules/core/src/compiler/pipeline/default_steps.js

@@ -9,17 +9,22 @@ import {ElementBindingMarker} from './element_binding_marker';
 import {ProtoViewBuilder} from './proto_view_builder';
 import {ProtoElementInjectorBuilder} from './proto_element_injector_builder';
 import {ElementBinderBuilder} from './element_binder_builder';
+import {AnnotatedType} from 'core/compiler/annotated_type';
+import {stringify} from 'facade/lang';
 
 /**
  * Default steps used for compiling a template.
  * Takes in an HTMLElement and produces the ProtoViews,
  * ProtoElementInjectors and ElementBinders in the end.
  */
-export function createDefaultSteps(parser:Parser, directives: List<AnnotatedType>) {
+export function createDefaultSteps(parser:Parser, compiledComponent: AnnotatedType,
+ directives: List<AnnotatedType>) {
+ var compilationUnit = stringify(compiledComponent.type);
+
  return [
- new ViewSplitter(parser),
- new TextInterpolationParser(parser),
- new PropertyBindingParser(parser),
+ new ViewSplitter(parser, compilationUnit),
+ new TextInterpolationParser(parser, compilationUnit),
+ new PropertyBindingParser(parser, compilationUnit),
  new DirectiveParser(directives),
  new ElementBindingMarker(),
  new ProtoViewBuilder(),

modules/core/src/compiler/pipeline/property_binding_parser.js

@@ -3,6 +3,7 @@ import {MapWrapper} from 'facade/collection';
 import {TemplateElement} from 'facade/dom';
 
 import {Parser} from 'change_detection/parser/parser';
+import {AST} from 'change_detection/parser/ast';
 import {ExpressionWithSource} from 'change_detection/parser/ast';
 
 import {CompileStep} from './compile_step';
@@ -24,8 +25,10 @@ var BIND_NAME_REGEXP = RegExpWrapper.create('^(?:(?:(bind)|(let)|(on))-(.+))|\\[
  */
 export class PropertyBindingParser extends CompileStep {
  _parser:Parser;
- constructor(parser:Parser) {
+ _compilationUnit:any;
+ constructor(parser:Parser, compilationUnit:any) {
  this._parser = parser;
+ this._compilationUnit = compilationUnit;
  }
 
  process(parent:CompileElement, current:CompileElement, control:CompileControl) {
@@ -35,7 +38,7 @@ export class PropertyBindingParser extends CompileStep {
  if (isPresent(bindParts)) {
  if (isPresent(bindParts[1])) {
  // match: bind-prop
- current.addPropertyBinding(bindParts[4], this._parser.parseBinding(attrValue));
+ current.addPropertyBinding(bindParts[4], this._parseBinding(attrValue));
  } else if (isPresent(bindParts[2])) {
  // match: let-prop
  // Note: We assume that the ViewSplitter already did its work, i.e. template directive should
@@ -46,20 +49,28 @@ export class PropertyBindingParser extends CompileStep {
  current.addVariableBinding(bindParts[4], attrValue);
  } else if (isPresent(bindParts[3])) {
  // match: on-prop
- current.addEventBinding(bindParts[4], this._parser.parseAction(attrValue));
+ current.addEventBinding(bindParts[4], this._parseAction(attrValue));
  } else if (isPresent(bindParts[5])) {
  // match: [prop]
- current.addPropertyBinding(bindParts[5], this._parser.parseBinding(attrValue));
+ current.addPropertyBinding(bindParts[5], this._parseBinding(attrValue));
  } else if (isPresent(bindParts[6])) {
  // match: (prop)
- current.addEventBinding(bindParts[6], this._parser.parseBinding(attrValue));
+ current.addEventBinding(bindParts[6], this._parseBinding(attrValue));
  }
  } else {
  var expression = interpolationToExpression(attrValue);
  if (isPresent(expression)) {
- current.addPropertyBinding(attrName, this._parser.parseBinding(expression));
+ current.addPropertyBinding(attrName, this._parseBinding(expression));
  }
  }
  });
  }
+
+ _parseBinding(input:string):AST {
+ return this._parser.parseBinding(input, this._compilationUnit);
+ }
+
+ _parseAction(input:string):AST {
+ return this._parser.parseAction(input, this._compilationUnit);
+ }
 }

modules/core/src/compiler/pipeline/text_interpolation_parser.js

@@ -47,8 +47,10 @@ export function interpolationToExpression(value:string):string {
  */
 export class TextInterpolationParser extends CompileStep {
  _parser:Parser;
- constructor(parser:Parser) {
+ _compilationUnit:any;
+ constructor(parser:Parser, compilationUnit:any) {
  this._parser = parser;
+ this._compilationUnit = compilationUnit;
  }
 
  process(parent:CompileElement, current:CompileElement, control:CompileControl) {
@@ -66,7 +68,7 @@ export class TextInterpolationParser extends CompileStep {
  var expression = interpolationToExpression(node.nodeValue);
  if (isPresent(expression)) {
  DOM.setText(node, ' ');
- pipelineElement.addTextNodeBinding(nodeIndex, this._parser.parseBinding(expression));
+ pipelineElement.addTextNodeBinding(nodeIndex, this._parser.parseBinding(expression, this._compilationUnit));
  }
  }
 }

modules/core/src/compiler/pipeline/view_splitter.js

@@ -31,8 +31,10 @@ import {CompileControl} from './compile_control';
  */
 export class ViewSplitter extends CompileStep {
  _parser:Parser;
- constructor(parser:Parser) {
+ _compilationUnit:any;
+ constructor(parser:Parser, compilationUnit:any) {
  this._parser = parser;
+ this._compilationUnit = compilationUnit;
  }
 
  process(parent:CompileElement, current:CompileElement, control:CompileControl) {
@@ -74,7 +76,7 @@ export class ViewSplitter extends CompileStep {
  }
 
  _parseTemplateBindings(templateBindings:string, compileElement:CompileElement) {
- var bindings = this._parser.parseTemplateBindings(templateBindings);
+ var bindings = this._parser.parseTemplateBindings(templateBindings, this._compilationUnit);
  for (var i=0; i<bindings.length; i++) {
  var binding = bindings[i];
  if (isPresent(binding.name)) {