chore(packaging): move files to match target file structure

2015-02-04 23:05:13 -08:00
parent 7ce4f66cdc
commit 3820609f24
149 changed files with 0 additions and 77 deletions
--- a/modules/angular2/src/change_detection/parser/ast.js
+++ b/modules/angular2/src/change_detection/parser/ast.js
@ -0,0 +1,467 @@
+import {FIELD, autoConvertAdd, isBlank, isPresent, FunctionWrapper, BaseException} from "facade/src/lang";
+import {List, Map, ListWrapper, StringMapWrapper} from "facade/src/collection";
+import {ContextWithVariableBindings} from "./context_with_variable_bindings";
+
+export class AST {
+  eval(context) {
+    throw new BaseException("Not supported");
+  }
+
+  get isAssignable() {
+    return false;
+  }
+
+  assign(context, value) {
+    throw new BaseException("Not supported");
+  }
+
+  visit(visitor) {
+  }
+
+  toString():string {
+    return "AST";
+  }
+}
+
+export class EmptyExpr extends AST {
+  eval(context) {
+    return null;
+  }
+
+  visit(visitor) {
+    //do nothing
+  }
+}
+
+export class Structural extends AST {
+  value:AST;
+  constructor(value:AST) {
+    this.value = value;
+  }
+
+  eval(context) {
+    return value.eval(context);
+  }
+
+  visit(visitor) {
+    return visitor.visitStructural(this);
+  }
+}
+
+export class ImplicitReceiver extends AST {
+  eval(context) {
+    return context;
+  }
+
+  visit(visitor) {
+    return visitor.visitImplicitReceiver(this);
+  }
+}
+
+/**
+ * Multiple expressions separated by a semicolon.
+ */
+export class Chain extends AST {
+  expressions:List;
+  constructor(expressions:List) {
+    this.expressions = expressions;
+  }
+
+  eval(context) {
+    var result;
+    for (var i = 0; i < this.expressions.length; i++) {
+      var last = this.expressions[i].eval(context);
+      if (isPresent(last)) result = last;
+    }
+    return result;
+  }
+
+  visit(visitor) {
+    return visitor.visitChain(this);
+  }
+}
+
+export class Conditional extends AST {
+  condition:AST;
+  trueExp:AST;
+  falseExp:AST;
+  constructor(condition:AST, trueExp:AST, falseExp:AST){
+    this.condition = condition;
+    this.trueExp = trueExp;
+    this.falseExp = falseExp;
+  }
+
+  eval(context) {
+    if(this.condition.eval(context)) {
+      return this.trueExp.eval(context);
+    } else {
+      return this.falseExp.eval(context);
+    }
+  }
+
+  visit(visitor) {
+    return visitor.visitConditional(this);
+  }
+}
+
+export class AccessMember extends AST {
+  receiver:AST;
+  name:string;
+  getter:Function;
+  setter:Function;
+  constructor(receiver:AST, name:string, getter:Function, setter:Function) {
+    this.receiver = receiver;
+    this.name = name;
+    this.getter = getter;
+    this.setter = setter;
+  }
+
+  eval(context) {
+    var evaluatedContext = this.receiver.eval(context);
+
+    while (evaluatedContext instanceof ContextWithVariableBindings) {
+      if (evaluatedContext.hasBinding(this.name)) {
+        return evaluatedContext.get(this.name);
+      }
+      evaluatedContext = evaluatedContext.parent;
+    }
+
+    return this.getter(evaluatedContext);
+  }
+
+  get isAssignable() {
+    return true;
+  }
+
+  assign(context, value) {
+    var evaluatedContext = this.receiver.eval(context);
+
+    while (evaluatedContext instanceof ContextWithVariableBindings) {
+      if (evaluatedContext.hasBinding(this.name)) {
+        throw new BaseException(`Cannot reassign a variable binding ${this.name}`)
+      }
+      evaluatedContext = evaluatedContext.parent;
+    }
+
+    return this.setter(evaluatedContext, value);
+  }
+
+  visit(visitor) {
+    return visitor.visitAccessMember(this);
+  }
+}
+
+export class KeyedAccess extends AST {
+  obj:AST;
+  key:AST;
+  constructor(obj:AST, key:AST) {
+    this.obj = obj;
+    this.key = key;
+  }
+
+  eval(context) {
+    var obj = this.obj.eval(context);
+    var key = this.key.eval(context);
+    return obj[key];
+  }
+
+  get isAssignable() {
+    return true;
+  }
+
+  assign(context, value) {
+    var obj = this.obj.eval(context);
+    var key = this.key.eval(context);
+    obj[key] = value;
+    return value;
+  }
+
+  visit(visitor) {
+    return visitor.visitKeyedAccess(this);
+  }
+}
+
+export class Formatter extends AST {
+  exp:AST;
+  name:string;
+  args:List<AST>;
+  allArgs:List<AST>;
+  constructor(exp:AST, name:string, args:List) {
+    this.exp = exp;
+    this.name = name;
+    this.args = args;
+    this.allArgs = ListWrapper.concat([exp], args);
+  }
+
+  visit(visitor) {
+    return visitor.visitFormatter(this);
+  }
+}
+
+export class LiteralPrimitive extends AST {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+
+  eval(context) {
+    return this.value;
+  }
+
+  visit(visitor) {
+    return visitor.visitLiteralPrimitive(this);
+  }
+}
+
+export class LiteralArray extends AST {
+  expressions:List;
+  constructor(expressions:List) {
+    this.expressions = expressions;
+  }
+
+  eval(context) {
+    return ListWrapper.map(this.expressions, (e) => e.eval(context));
+  }
+
+  visit(visitor) {
+    return visitor.visitLiteralArray(this);
+  }
+}
+
+export class LiteralMap extends AST {
+  keys:List;
+  values:List;
+  constructor(keys:List, values:List) {
+    this.keys = keys;
+    this.values = values;
+  }
+
+  eval(context) {
+    var res = StringMapWrapper.create();
+    for(var i = 0; i < this.keys.length; ++i) {
+      StringMapWrapper.set(res, this.keys[i], this.values[i].eval(context));
+    }
+    return res;
+  }
+
+  visit(visitor) {
+    return visitor.visitLiteralMap(this);
+  }
+}
+
+export class Interpolation extends AST {
+  strings:List;
+  expressions:List;
+  constructor(strings:List, expressions:List) {
+    this.strings = strings;
+    this.expressions = expressions;
+  }
+
+  eval(context) {
+    throw new BaseException("evaluating an Interpolation is not supported");
+  }
+
+  visit(visitor) {
+    visitor.visitInterpolation(this);
+  }
+}
+
+export class Binary extends AST {
+  operation:string;
+  left:AST;
+  right:AST;
+  constructor(operation:string, left:AST, right:AST) {
+    this.operation = operation;
+    this.left = left;
+    this.right = right;
+  }
+
+  eval(context) {
+    var left = this.left.eval(context);
+    switch (this.operation) {
+      case '&&': return left && this.right.eval(context);
+      case '||': return left || this.right.eval(context);
+    }
+    var right = this.right.eval(context);
+
+    switch (this.operation) {
+      case '+'  : return left + right;
+      case '-'  : return left - right;
+      case '*'  : return left * right;
+      case '/'  : return left / right;
+      case '%'  : return left % right;
+      case '==' : return left == right;
+      case '!=' : return left != right;
+      case '<'  : return left < right;
+      case '>'  : return left > right;
+      case '<=' : return left <= right;
+      case '>=' : return left >= right;
+      case '^'  : return left ^ right;
+      case '&'  : return left & right;
+    }
+    throw 'Internal error [$operation] not handled';
+  }
+
+  visit(visitor) {
+    return visitor.visitBinary(this);
+  }
+}
+
+export class PrefixNot extends AST {
+  expression:AST;
+  constructor(expression:AST) {
+    this.expression = expression;
+  }
+
+  eval(context) {
+    return !this.expression.eval(context);
+  }
+
+  visit(visitor) {
+    return visitor.visitPrefixNot(this);
+  }
+}
+
+export class Assignment extends AST {
+  target:AST;
+  value:AST;
+  constructor(target:AST, value:AST) {
+    this.target = target;
+    this.value = value;
+  }
+
+  eval(context) {
+    return this.target.assign(context, this.value.eval(context));
+  }
+
+  visit(visitor) {
+    return visitor.visitAssignment(this);
+  }
+}
+
+export class MethodCall extends AST {
+  receiver:AST;
+  fn:Function;
+  args:List;
+  name:string;
+  constructor(receiver:AST, name:string, fn:Function, args:List) {
+    this.receiver = receiver;
+    this.fn = fn;
+    this.args = args;
+    this.name = name;
+  }
+
+  eval(context) {
+    var evaluatedContext = this.receiver.eval(context);
+    var evaluatedArgs = evalList(context, this.args);
+
+    while (evaluatedContext instanceof ContextWithVariableBindings) {
+      if (evaluatedContext.hasBinding(this.name)) {
+        var fn = evaluatedContext.get(this.name);
+        return FunctionWrapper.apply(fn, evaluatedArgs);
+      }
+      evaluatedContext = evaluatedContext.parent;
+    }
+
+    return this.fn(evaluatedContext, evaluatedArgs);
+  }
+
+  visit(visitor) {
+    return visitor.visitMethodCall(this);
+  }
+}
+
+export class FunctionCall extends AST {
+  target:AST;
+  args:List;
+  constructor(target:AST, args:List) {
+    this.target = target;
+    this.args = args;
+  }
+
+  eval(context) {
+    var obj = this.target.eval(context);
+    if (! (obj instanceof Function)) {
+      throw new BaseException(`${obj} is not a function`);
+    }
+    return FunctionWrapper.apply(obj, evalList(context, this.args));
+  }
+
+  visit(visitor) {
+    return visitor.visitFunctionCall(this);
+  }
+}
+
+export class ASTWithSource extends AST {
+  ast:AST;
+  source:string;
+  location:string;
+  constructor(ast:AST, source:string, location:string) {
+    this.source = source;
+    this.location = location;
+    this.ast = ast;
+  }
+
+  eval(context) {
+    return this.ast.eval(context);
+  }
+
+  get isAssignable() {
+    return this.ast.isAssignable;
+  }
+
+  assign(context, value) {
+    return this.ast.assign(context, value);
+  }
+
+  visit(visitor) {
+    return this.ast.visit(visitor);
+  }
+
+  toString():string {
+    return `${this.source} in ${this.location}`;
+  }
+}
+
+export class TemplateBinding {
+  key:string;
+  keyIsVar:boolean;
+  name:string;
+  expression:ASTWithSource;
+  constructor(key:string, keyIsVar:boolean, name:string, expression:ASTWithSource) {
+    this.key = key;
+    this.keyIsVar = keyIsVar;
+    // only either name or expression will be filled.
+    this.name = name;
+    this.expression = expression;
+  }
+}
+
+//INTERFACE
+export class AstVisitor {
+  visitAccessMember(ast:AccessMember) {}
+  visitAssignment(ast:Assignment) {}
+  visitBinary(ast:Binary) {}
+  visitChain(ast:Chain){}
+  visitStructural(ast:Structural) {}
+  visitConditional(ast:Conditional) {}
+  visitFormatter(ast:Formatter) {}
+  visitFunctionCall(ast:FunctionCall) {}
+  visitImplicitReceiver(ast:ImplicitReceiver) {}
+  visitKeyedAccess(ast:KeyedAccess) {}
+  visitLiteralArray(ast:LiteralArray) {}
+  visitLiteralMap(ast:LiteralMap) {}
+  visitLiteralPrimitive(ast:LiteralPrimitive) {}
+  visitMethodCall(ast:MethodCall) {}
+  visitPrefixNot(ast:PrefixNot) {}
+}
+
+var _evalListCache = [[],[0],[0,0],[0,0,0],[0,0,0,0],[0,0,0,0,0]];
+function evalList(context, exps:List){
+  var length = exps.length;
+  var result = _evalListCache[length];
+  for (var i = 0; i < length; i++) {
+    result[i] = exps[i].eval(context);
+  }
+  return result;
+}
--- a/modules/angular2/src/change_detection/parser/context_with_variable_bindings.js
+++ b/modules/angular2/src/change_detection/parser/context_with_variable_bindings.js
@ -0,0 +1,38 @@
+import {MapWrapper} from 'facade/src/collection';
+import {BaseException} from 'facade/src/lang';
+
+export class ContextWithVariableBindings {
+  parent:any;
+  /// varBindings' keys are read-only. adding/removing keys is not supported.
+  varBindings:Map;
+
+  constructor(parent:any, varBindings:Map) {
+    this.parent = parent;
+    this.varBindings = varBindings;
+  }
+
+  hasBinding(name:string):boolean {
+    return MapWrapper.contains(this.varBindings, name);
+  }
+
+  get(name:string) {
+    return MapWrapper.get(this.varBindings, name);
+  }
+
+  set(name:string, value) {
+    // TODO(rado): consider removing this check if we can guarantee this is not
+    // exposed to the public API.
+    if (this.hasBinding(name)) {
+      MapWrapper.set(this.varBindings, name, value);
+    } else {
+      throw new BaseException(
+        'VariableBindings do not support setting of new keys post-construction.');
+    }
+  }
+
+  clearValues() {
+    for (var k of MapWrapper.keys(this.varBindings)) {
+      MapWrapper.set(this.varBindings, k, null);
+    }
+  }
+}
--- a/modules/angular2/src/change_detection/parser/lexer.js
+++ b/modules/angular2/src/change_detection/parser/lexer.js
@ -0,0 +1,481 @@
+import {List, ListWrapper, SetWrapper} from "facade/src/collection";
+import {int, FIELD, NumberWrapper, StringJoiner, StringWrapper} from "facade/src/lang";
+
+export const TOKEN_TYPE_CHARACTER  = 1;
+export const TOKEN_TYPE_IDENTIFIER = 2;
+export const TOKEN_TYPE_KEYWORD    = 3;
+export const TOKEN_TYPE_STRING     = 4;
+export const TOKEN_TYPE_OPERATOR   = 5;
+export const TOKEN_TYPE_NUMBER     = 6;
+
+export class Lexer {
+  text:string;
+  tokenize(text:string):List {
+    var scanner = new _Scanner(text);
+    var tokens = [];
+    var token = scanner.scanToken();
+    while (token != null) {
+      ListWrapper.push(tokens, token);
+      token = scanner.scanToken();
+    }
+    return tokens;
+  }
+}
+
+export class Token {
+  index:int;
+  type:int;
+  _numValue:number;
+  _strValue:string;
+  constructor(index:int, type:int, numValue:number, strValue:string) {
+    /**
+     * NOTE: To ensure that this constructor creates the same hidden class each time, ensure that
+     * all the fields are assigned to in the exact same order in each run of this constructor.
+     */
+    this.index = index;
+    this.type = type;
+    this._numValue = numValue;
+    this._strValue = strValue;
+  }
+
+  isCharacter(code:int):boolean {
+    return (this.type == TOKEN_TYPE_CHARACTER && this._numValue == code);
+  }
+
+  isNumber():boolean {
+    return (this.type == TOKEN_TYPE_NUMBER);
+  }
+
+  isString():boolean {
+    return (this.type == TOKEN_TYPE_STRING);
+  }
+
+  isOperator(operater:string):boolean {
+    return (this.type == TOKEN_TYPE_OPERATOR && this._strValue == operater);
+  }
+
+  isIdentifier():boolean {
+    return (this.type == TOKEN_TYPE_IDENTIFIER);
+  }
+
+  isKeyword():boolean {
+    return (this.type == TOKEN_TYPE_KEYWORD);
+  }
+
+  isKeywordVar():boolean {
+    return (this.type == TOKEN_TYPE_KEYWORD && this._strValue == "var");
+  }
+
+  isKeywordNull():boolean {
+    return (this.type == TOKEN_TYPE_KEYWORD && this._strValue == "null");
+  }
+
+  isKeywordUndefined():boolean {
+    return (this.type == TOKEN_TYPE_KEYWORD && this._strValue == "undefined");
+  }
+
+  isKeywordTrue():boolean {
+    return (this.type == TOKEN_TYPE_KEYWORD && this._strValue == "true");
+  }
+
+  isKeywordFalse():boolean {
+    return (this.type == TOKEN_TYPE_KEYWORD && this._strValue == "false");
+  }
+
+  toNumber():number {
+    // -1 instead of NULL ok?
+    return (this.type == TOKEN_TYPE_NUMBER) ? this._numValue : -1;
+  }
+
+  toString():string {
+    var type:int = this.type;
+    if (type >= TOKEN_TYPE_CHARACTER && type <= TOKEN_TYPE_STRING) {
+      return this._strValue;
+    } else if (type == TOKEN_TYPE_NUMBER) {
+      return this._numValue.toString();
+    } else {
+      return null;
+    }
+  }
+}
+
+function newCharacterToken(index:int, code:int):Token {
+  return new Token(index, TOKEN_TYPE_CHARACTER, code, StringWrapper.fromCharCode(code));
+}
+
+function newIdentifierToken(index:int, text:string):Token {
+  return new Token(index, TOKEN_TYPE_IDENTIFIER, 0, text);
+}
+
+function newKeywordToken(index:int, text:string):Token {
+  return new Token(index, TOKEN_TYPE_KEYWORD, 0, text);
+}
+
+function newOperatorToken(index:int, text:string):Token {
+  return new Token(index, TOKEN_TYPE_OPERATOR, 0, text);
+}
+
+function newStringToken(index:int, text:string):Token {
+  return new Token(index, TOKEN_TYPE_STRING, 0, text);
+}
+
+function newNumberToken(index:int, n:number):Token {
+  return new Token(index, TOKEN_TYPE_NUMBER, n, "");
+}
+
+
+export var EOF:Token = new Token(-1, 0, 0, "");
+
+export const $EOF       = 0;
+export const $TAB       = 9;
+export const $LF        = 10;
+export const $VTAB      = 11;
+export const $FF        = 12;
+export const $CR        = 13;
+export const $SPACE     = 32;
+export const $BANG      = 33;
+export const $DQ        = 34;
+export const $HASH      = 35;
+export const $$         = 36;
+export const $PERCENT   = 37;
+export const $AMPERSAND = 38;
+export const $SQ        = 39;
+export const $LPAREN    = 40;
+export const $RPAREN    = 41;
+export const $STAR      = 42;
+export const $PLUS      = 43;
+export const $COMMA     = 44;
+export const $MINUS     = 45;
+export const $PERIOD    = 46;
+export const $SLASH     = 47;
+export const $COLON     = 58;
+export const $SEMICOLON = 59;
+export const $LT        = 60;
+export const $EQ        = 61;
+export const $GT        = 62;
+export const $QUESTION  = 63;
+
+const $0 = 48;
+const $9 = 57;
+
+const $A = 65, $B = 66, $C = 67, $D = 68, $E = 69, $F = 70, $G = 71, $H = 72,
+      $I = 73, $J = 74, $K = 75, $L = 76, $M = 77, $N = 78, $O = 79, $P = 80,
+      $Q = 81, $R = 82, $S = 83, $T = 84, $U = 85, $V = 86, $W = 87, $X = 88,
+      $Y = 89, $Z = 90;
+
+export const $LBRACKET  = 91;
+export const $BACKSLASH = 92;
+export const $RBRACKET  = 93;
+const $CARET     = 94;
+const $_         = 95;
+
+const $a =  97, $b =  98, $c =  99, $d = 100, $e = 101, $f = 102, $g = 103,
+      $h = 104, $i = 105, $j = 106, $k = 107, $l = 108, $m = 109, $n = 110,
+      $o = 111, $p = 112, $q = 113, $r = 114, $s = 115, $t = 116, $u = 117,
+      $v = 118, $w = 119, $x = 120, $y = 121, $z = 122;
+
+export const $LBRACE = 123;
+export const $BAR    = 124;
+export const $RBRACE = 125;
+const $TILDE  = 126;
+const $NBSP   = 160;
+
+
+export class ScannerError extends Error {
+  message:string;
+  constructor(message) {
+    this.message = message;
+  }
+
+  toString() {
+    return this.message;
+  }
+}
+
+class _Scanner {
+  input:string;
+  length:int;
+  peek:int;
+  index:int;
+
+  constructor(input:string) {
+    this.input = input;
+    this.length = input.length;
+    this.peek = 0;
+    this.index = -1;
+    this.advance();
+  }
+
+  advance() {
+    this.peek = ++this.index >= this.length ? $EOF : StringWrapper.charCodeAt(this.input, this.index);
+  }
+
+  scanToken():Token {
+    var input = this.input,
+        length = this.length,
+        peek = this.peek,
+        index = this.index;
+
+    // Skip whitespace.
+    while (peek <= $SPACE) {
+      if (++index >= length) {
+        peek = $EOF;
+        break;
+      } else {
+        peek = StringWrapper.charCodeAt(input, index);
+      }
+    }
+
+    this.peek = peek;
+    this.index = index;
+
+    if (index >= length) {
+      return null;
+    }
+
+    // Handle identifiers and numbers.
+    if (isIdentifierStart(peek)) return this.scanIdentifier();
+    if (isDigit(peek)) return this.scanNumber(index);
+
+    var start:int = index;
+    switch (peek) {
+      case $PERIOD:
+        this.advance();
+        return isDigit(this.peek) ? this.scanNumber(start) :
+                                    newCharacterToken(start, $PERIOD);
+      case $LPAREN:   case $RPAREN:
+      case $LBRACE:   case $RBRACE:
+      case $LBRACKET: case $RBRACKET:
+      case $COMMA:
+      case $COLON:
+      case $SEMICOLON:
+        return this.scanCharacter(start, peek);
+      case $SQ:
+      case $DQ:
+        return this.scanString();
+      case $HASH:
+        return this.scanOperator(start, StringWrapper.fromCharCode(peek));
+      case $PLUS:
+      case $MINUS:
+      case $STAR:
+      case $SLASH:
+      case $PERCENT:
+      case $CARET:
+      case $QUESTION:
+        return this.scanOperator(start, StringWrapper.fromCharCode(peek));
+      case $LT:
+      case $GT:
+      case $BANG:
+      case $EQ:
+        return this.scanComplexOperator(start, $EQ, StringWrapper.fromCharCode(peek), '=');
+      case $AMPERSAND:
+        return this.scanComplexOperator(start, $AMPERSAND, '&', '&');
+      case $BAR:
+        return this.scanComplexOperator(start, $BAR, '|', '|');
+      case $TILDE:
+        return this.scanComplexOperator(start, $SLASH, '~', '/');
+      case $NBSP:
+        while (isWhitespace(this.peek)) this.advance();
+        return this.scanToken();
+    }
+
+    this.error(`Unexpected character [${StringWrapper.fromCharCode(peek)}]`, 0);
+    return null;
+  }
+
+  scanCharacter(start:int, code:int):Token {
+    assert(this.peek == code);
+    this.advance();
+    return newCharacterToken(start, code);
+  }
+
+
+  scanOperator(start:int, str:string):Token {
+    assert(this.peek == StringWrapper.charCodeAt(str, 0));
+    assert(SetWrapper.has(OPERATORS, str));
+    this.advance();
+    return newOperatorToken(start, str);
+  }
+
+  scanComplexOperator(start:int, code:int, one:string, two:string):Token {
+    assert(this.peek == StringWrapper.charCodeAt(one, 0));
+    this.advance();
+    var str:string = one;
+    if (this.peek == code) {
+      this.advance();
+      str += two;
+    }
+    assert(SetWrapper.has(OPERATORS, str));
+    return newOperatorToken(start, str);
+  }
+
+  scanIdentifier():Token {
+    assert(isIdentifierStart(this.peek));
+    var start:int = this.index;
+    this.advance();
+    while (isIdentifierPart(this.peek)) this.advance();
+    var str:string = this.input.substring(start, this.index);
+    if (SetWrapper.has(KEYWORDS, str)) {
+      return newKeywordToken(start, str);
+    } else {
+      return newIdentifierToken(start, str);
+    }
+  }
+
+  scanNumber(start:int):Token {
+    assert(isDigit(this.peek));
+    var simple:boolean = (this.index === start);
+    this.advance();  // Skip initial digit.
+    while (true) {
+      if (isDigit(this.peek)) {
+        // Do nothing.
+      } else if (this.peek == $PERIOD) {
+        simple = false;
+      } else if (isExponentStart(this.peek)) {
+        this.advance();
+        if (isExponentSign(this.peek)) this.advance();
+        if (!isDigit(this.peek)) this.error('Invalid exponent', -1);
+        simple = false;
+      } else {
+        break;
+      }
+      this.advance();
+    }
+    var str:string = this.input.substring(start, this.index);
+    // TODO
+    var value:number = simple ? NumberWrapper.parseIntAutoRadix(str) : NumberWrapper.parseFloat(str);
+    return newNumberToken(start, value);
+  }
+
+  scanString():Token {
+    assert(this.peek == $SQ || this.peek == $DQ);
+    var start:int = this.index;
+    var quote:int = this.peek;
+    this.advance();  // Skip initial quote.
+
+    var buffer:StringJoiner;
+    var marker:int = this.index;
+    var input:string = this.input;
+
+    while (this.peek != quote) {
+      if (this.peek == $BACKSLASH) {
+        if (buffer == null) buffer = new StringJoiner();
+        buffer.add(input.substring(marker, this.index));
+        this.advance();
+        var unescapedCode:int;
+        if (this.peek == $u) {
+          // 4 character hex code for unicode character.
+          var hex:string = input.substring(this.index + 1, this.index + 5);
+          try {
+            unescapedCode = NumberWrapper.parseInt(hex, 16);
+          } catch (e) {
+            this.error(`Invalid unicode escape [\\u${hex}]`, 0);
+          }
+          for (var i:int = 0; i < 5; i++) {
+            this.advance();
+          }
+        } else {
+          unescapedCode = unescape(this.peek);
+          this.advance();
+        }
+        buffer.add(StringWrapper.fromCharCode(unescapedCode));
+        marker = this.index;
+      } else if (this.peek == $EOF) {
+        this.error('Unterminated quote', 0);
+      } else {
+        this.advance();
+      }
+    }
+
+    var last:string = input.substring(marker, this.index);
+    this.advance();  // Skip terminating quote.
+
+    // Compute the unescaped string value.
+    var unescaped:string = last;
+    if (buffer != null) {
+      buffer.add(last);
+      unescaped = buffer.toString();
+    }
+    return newStringToken(start, unescaped);
+  }
+
+  error(message:string, offset:int) {
+    var position:int = this.index + offset;
+    throw new ScannerError(`Lexer Error: ${message} at column ${position} in expression [${this.input}]`);
+  }
+}
+
+function isWhitespace(code:int):boolean {
+  return (code >= $TAB && code <= $SPACE) || (code == $NBSP);
+}
+
+function isIdentifierStart(code:int):boolean {
+  return ($a <= code && code <= $z) ||
+         ($A <= code && code <= $Z) ||
+         (code == $_) ||
+         (code == $$);
+}
+
+function isIdentifierPart(code:int):boolean {
+  return ($a <= code && code <= $z) ||
+         ($A <= code && code <= $Z) ||
+         ($0 <= code && code <= $9) ||
+         (code == $_) ||
+         (code == $$);
+}
+
+function isDigit(code:int):boolean {
+  return $0 <= code && code <= $9;
+}
+
+function isExponentStart(code:int):boolean {
+  return code == $e || code == $E;
+}
+
+function isExponentSign(code:int):boolean {
+  return code == $MINUS || code == $PLUS;
+}
+
+function unescape(code:int):int {
+  switch(code) {
+    case $n: return $LF;
+    case $f: return $FF;
+    case $r: return $CR;
+    case $t: return $TAB;
+    case $v: return $VTAB;
+    default: return code;
+  }
+}
+
+var OPERATORS = SetWrapper.createFromList([
+  '+',
+  '-',
+  '*',
+  '/',
+  '~/',
+  '%',
+  '^',
+  '=',
+  '==',
+  '!=',
+  '<',
+  '>',
+  '<=',
+  '>=',
+  '&&',
+  '||',
+  '&',
+  '|',
+  '!',
+  '?',
+  '#'
+]);
+
+
+var KEYWORDS = SetWrapper.createFromList([
+    'var',
+    'null',
+    'undefined',
+    'true',
+    'false',
+]);
--- a/modules/angular2/src/change_detection/parser/parser.js
+++ b/modules/angular2/src/change_detection/parser/parser.js
@ -0,0 +1,521 @@
+import {FIELD, int, isBlank, isPresent,  BaseException, StringWrapper, RegExpWrapper} from 'facade/src/lang';
+import {ListWrapper, List} from 'facade/src/collection';
+import {Lexer, EOF, Token, $PERIOD, $COLON, $SEMICOLON, $LBRACKET, $RBRACKET,
+  $COMMA, $LBRACE, $RBRACE, $LPAREN, $RPAREN} from './lexer';
+import {reflector, Reflector} from 'reflection/src/reflection';
+import {
+  AST,
+  EmptyExpr,
+  ImplicitReceiver,
+  AccessMember,
+  LiteralPrimitive,
+  Expression,
+  Binary,
+  PrefixNot,
+  Conditional,
+  Formatter,
+  Assignment,
+  Chain,
+  KeyedAccess,
+  LiteralArray,
+  LiteralMap,
+  Interpolation,
+  MethodCall,
+  FunctionCall,
+  TemplateBindings,
+  TemplateBinding,
+  ASTWithSource
+  } from './ast';
+
+var _implicitReceiver = new ImplicitReceiver();
+// TODO(tbosch): Cannot make this const/final right now because of the transpiler...
+var INTERPOLATION_REGEXP = RegExpWrapper.create('\\{\\{(.*?)\\}\\}');
+var QUOTE_REGEXP = RegExpWrapper.create("'");
+
+export class Parser {
+  _lexer:Lexer;
+  _reflector:Reflector;
+  constructor(lexer:Lexer, providedReflector:Reflector = null){
+    this._lexer = lexer;
+    this._reflector = isPresent(providedReflector) ? providedReflector : reflector;
+  }
+
+  parseAction(input:string, location:any):ASTWithSource {
+    var tokens = this._lexer.tokenize(input);
+    var ast = new _ParseAST(input, location, tokens, this._reflector, true).parseChain();
+    return new ASTWithSource(ast, input, location);
+  }
+
+  parseBinding(input:string, location:any):ASTWithSource {
+    var tokens = this._lexer.tokenize(input);
+    var ast = new _ParseAST(input, location, tokens, this._reflector, false).parseChain();
+    return new ASTWithSource(ast, input, location);
+  }
+
+  parseTemplateBindings(input:string, location:any):List<TemplateBinding> {
+    var tokens = this._lexer.tokenize(input);
+    return new _ParseAST(input, location, tokens, this._reflector, false).parseTemplateBindings();
+  }
+
+  parseInterpolation(input:string, location:any):ASTWithSource {
+    var parts = StringWrapper.split(input, INTERPOLATION_REGEXP);
+    if (parts.length <= 1) {
+      return null;
+    }
+    var strings = [];
+    var expressions = [];
+
+    for (var i=0; i<parts.length; i++) {
+      var part = parts[i];
+      if (i%2 === 0) {
+        // fixed string
+        ListWrapper.push(strings, part);
+      } else {
+        var tokens = this._lexer.tokenize(part);
+        var ast = new _ParseAST(input, location, tokens, this._reflector, false).parseChain();
+        ListWrapper.push(expressions, ast);
+      }
+    }
+    return new ASTWithSource(new Interpolation(strings, expressions), input, location);
+  }
+
+}
+
+class _ParseAST {
+  input:string;
+  location:any;
+  tokens:List<Token>;
+  reflector:Reflector;
+  parseAction:boolean;
+  index:int;
+  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;
+    this.parseAction = parseAction;
+  }
+
+  peek(offset:int):Token {
+    var i = this.index + offset;
+    return i < this.tokens.length ? this.tokens[i] : EOF;
+  }
+
+  get next():Token {
+    return this.peek(0);
+  }
+
+  get inputIndex():int {
+    return (this.index < this.tokens.length) ? this.next.index : this.input.length;
+  }
+
+  advance() {
+    this.index ++;
+  }
+
+  optionalCharacter(code:int):boolean {
+    if (this.next.isCharacter(code)) {
+      this.advance();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  optionalKeywordVar():boolean {
+    if (this.peekKeywordVar()) {
+      this.advance();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  peekKeywordVar():boolean {
+    return this.next.isKeywordVar() || this.next.isOperator('#');
+  }
+
+  expectCharacter(code:int) {
+    if (this.optionalCharacter(code)) return;
+    this.error(`Missing expected ${StringWrapper.fromCharCode(code)}`);
+  }
+
+
+  optionalOperator(op:string):boolean {
+    if (this.next.isOperator(op)) {
+      this.advance();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  expectOperator(operator:string) {
+    if (this.optionalOperator(operator)) return;
+    this.error(`Missing expected operator ${operator}`);
+  }
+
+  expectIdentifierOrKeyword():string {
+    var n = this.next;
+    if (!n.isIdentifier() && !n.isKeyword()) {
+      this.error(`Unexpected token ${n}, expected identifier or keyword`)
+    }
+    this.advance();
+    return n.toString();
+  }
+
+  expectIdentifierOrKeywordOrString():string {
+    var n = this.next;
+    if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) {
+      this.error(`Unexpected token ${n}, expected identifier, keyword, or string`)
+    }
+    this.advance();
+    return n.toString();
+  }
+
+  parseChain():AST {
+    var exprs = [];
+    while (this.index < this.tokens.length) {
+      var expr = this.parseFormatter();
+      ListWrapper.push(exprs, expr);
+
+      if (this.optionalCharacter($SEMICOLON)) {
+        if (! this.parseAction) {
+          this.error("Binding expression cannot contain chained expression");
+        }
+        while (this.optionalCharacter($SEMICOLON)){} //read all semicolons
+      } else if (this.index < this.tokens.length) {
+        this.error(`Unexpected token '${this.next}'`);
+      }
+    }
+    if (exprs.length == 0) return new EmptyExpr();
+    if (exprs.length == 1) return exprs[0];
+    return new Chain(exprs);
+  }
+
+  parseFormatter() {
+    var result = this.parseExpression();
+    while (this.optionalOperator("|")) {
+      if (this.parseAction) {
+        this.error("Cannot have a formatter in an action expression");
+      }
+      var name = this.expectIdentifierOrKeyword();
+      var args = ListWrapper.create();
+      while (this.optionalCharacter($COLON)) {
+        ListWrapper.push(args, this.parseExpression());
+      }
+      result = new Formatter(result, name, args);
+    }
+    return result;
+  }
+
+  parseExpression() {
+    var start = this.inputIndex;
+    var result = this.parseConditional();
+
+    while (this.next.isOperator('=')) {
+      if (!result.isAssignable) {
+        var end = this.inputIndex;
+        var expression = this.input.substring(start, end);
+        this.error(`Expression ${expression} is not assignable`);
+      }
+
+      if (!this.parseAction) {
+        this.error("Binding expression cannot contain assignments");
+      }
+
+      this.expectOperator('=');
+      result = new Assignment(result, this.parseConditional());
+    }
+
+    return result;
+  }
+
+  parseConditional() {
+    var start = this.inputIndex;
+    var result = this.parseLogicalOr();
+
+    if (this.optionalOperator('?')) {
+      var yes = this.parseExpression();
+      if (!this.optionalCharacter($COLON)) {
+        var end = this.inputIndex;
+        var expression = this.input.substring(start, end);
+        this.error(`Conditional expression ${expression} requires all 3 expressions`);
+      }
+      var no = this.parseExpression();
+      return new Conditional(result, yes, no);
+    } else {
+      return result;
+    }
+  }
+
+  parseLogicalOr() {
+    // '||'
+    var result = this.parseLogicalAnd();
+    while (this.optionalOperator('||')) {
+      result = new Binary('||', result, this.parseLogicalAnd());
+    }
+    return result;
+  }
+
+  parseLogicalAnd() {
+    // '&&'
+    var result = this.parseEquality();
+    while (this.optionalOperator('&&')) {
+      result = new Binary('&&', result, this.parseEquality());
+    }
+    return result;
+  }
+
+  parseEquality() {
+    // '==','!='
+    var result = this.parseRelational();
+    while (true) {
+      if (this.optionalOperator('==')) {
+        result = new Binary('==', result, this.parseRelational());
+      } else if (this.optionalOperator('!=')) {
+        result = new Binary('!=', result, this.parseRelational());
+      } else {
+        return result;
+      }
+    }
+  }
+
+  parseRelational() {
+    // '<', '>', '<=', '>='
+    var result = this.parseAdditive();
+    while (true) {
+      if (this.optionalOperator('<')) {
+        result = new Binary('<', result, this.parseAdditive());
+      } else if (this.optionalOperator('>')) {
+        result = new Binary('>', result, this.parseAdditive());
+      } else if (this.optionalOperator('<=')) {
+        result = new Binary('<=', result, this.parseAdditive());
+      } else if (this.optionalOperator('>=')) {
+        result = new Binary('>=', result, this.parseAdditive());
+      } else {
+        return result;
+      }
+    }
+  }
+
+  parseAdditive() {
+    // '+', '-'
+    var result = this.parseMultiplicative();
+    while (true) {
+      if (this.optionalOperator('+')) {
+        result = new Binary('+', result, this.parseMultiplicative());
+      } else if (this.optionalOperator('-')) {
+        result = new Binary('-', result, this.parseMultiplicative());
+      } else {
+        return result;
+      }
+    }
+  }
+
+  parseMultiplicative() {
+    // '*', '%', '/'
+    var result = this.parsePrefix();
+    while (true) {
+      if (this.optionalOperator('*')) {
+        result = new Binary('*', result, this.parsePrefix());
+      } else if (this.optionalOperator('%')) {
+        result = new Binary('%', result, this.parsePrefix());
+      } else if (this.optionalOperator('/')) {
+        result = new Binary('/', result, this.parsePrefix());
+      } else {
+        return result;
+      }
+    }
+  }
+
+  parsePrefix() {
+    if (this.optionalOperator('+')) {
+      return this.parsePrefix();
+    } else if (this.optionalOperator('-')) {
+      return new Binary('-', new LiteralPrimitive(0), this.parsePrefix());
+    } else if (this.optionalOperator('!')) {
+      return new PrefixNot(this.parsePrefix());
+    } else {
+      return this.parseCallChain();
+    }
+  }
+
+  parseCallChain():AST {
+    var result = this.parsePrimary();
+    while (true) {
+      if (this.optionalCharacter($PERIOD)) {
+        result = this.parseAccessMemberOrMethodCall(result);
+
+      } else if (this.optionalCharacter($LBRACKET)) {
+        var key = this.parseExpression();
+        this.expectCharacter($RBRACKET);
+        result = new KeyedAccess(result, key);
+
+      } else if (this.optionalCharacter($LPAREN)) {
+        var args = this.parseCallArguments();
+        this.expectCharacter($RPAREN);
+        result = new FunctionCall(result, args);
+
+      } else {
+        return result;
+      }
+    }
+  }
+
+  parsePrimary() {
+    if (this.optionalCharacter($LPAREN)) {
+      var result = this.parseFormatter();
+      this.expectCharacter($RPAREN);
+      return result;
+
+    } else if (this.next.isKeywordNull() || this.next.isKeywordUndefined()) {
+      this.advance();
+      return new LiteralPrimitive(null);
+
+    } else if (this.next.isKeywordTrue()) {
+      this.advance();
+      return new LiteralPrimitive(true);
+
+    } else if (this.next.isKeywordFalse()) {
+      this.advance();
+      return new LiteralPrimitive(false);
+
+    } else if (this.optionalCharacter($LBRACKET)) {
+      var elements = this.parseExpressionList($RBRACKET);
+      this.expectCharacter($RBRACKET);
+      return new LiteralArray(elements);
+
+    } else if (this.next.isCharacter($LBRACE)) {
+      return this.parseLiteralMap();
+
+    } else if (this.next.isIdentifier()) {
+      return this.parseAccessMemberOrMethodCall(_implicitReceiver);
+
+    } else if (this.next.isNumber()) {
+      var value = this.next.toNumber();
+      this.advance();
+      return new LiteralPrimitive(value);
+
+    } else if (this.next.isString()) {
+      var value = this.next.toString();
+      this.advance();
+      return new LiteralPrimitive(value);
+
+    } else if (this.index >= this.tokens.length) {
+      this.error(`Unexpected end of expression: ${this.input}`);
+
+    } else {
+      this.error(`Unexpected token ${this.next}`);
+    }
+  }
+
+  parseExpressionList(terminator:int):List {
+    var result = [];
+    if (!this.next.isCharacter(terminator)) {
+      do {
+        ListWrapper.push(result, this.parseExpression());
+      } while (this.optionalCharacter($COMMA));
+    }
+    return result;
+  }
+
+  parseLiteralMap() {
+    var keys = [];
+    var values = [];
+    this.expectCharacter($LBRACE);
+    if (!this.optionalCharacter($RBRACE)) {
+      do {
+        var key = this.expectIdentifierOrKeywordOrString();
+        ListWrapper.push(keys, key);
+        this.expectCharacter($COLON);
+        ListWrapper.push(values, this.parseExpression());
+      } while (this.optionalCharacter($COMMA));
+      this.expectCharacter($RBRACE);
+    }
+    return new LiteralMap(keys, values);
+  }
+
+  parseAccessMemberOrMethodCall(receiver):AST {
+    var id = this.expectIdentifierOrKeyword();
+
+    if (this.optionalCharacter($LPAREN)) {
+      var args = this.parseCallArguments();
+      this.expectCharacter($RPAREN);
+      var fn = this.reflector.method(id);
+      return new MethodCall(receiver, id, fn, args);
+
+    } else {
+      var getter = this.reflector.getter(id);
+      var setter = this.reflector.setter(id);
+      return new AccessMember(receiver, id, getter, setter);
+    }
+  }
+
+  parseCallArguments() {
+    if (this.next.isCharacter($RPAREN)) return [];
+    var positionals = [];
+    do {
+      ListWrapper.push(positionals, this.parseExpression());
+    } while (this.optionalCharacter($COMMA))
+    return positionals;
+  }
+
+  /**
+   * An identifier, a keyword, a string with an optional `-` inbetween.
+   */
+  expectTemplateBindingKey() {
+    var result = '';
+    var operatorFound = false;
+    do {
+      result += this.expectIdentifierOrKeywordOrString();
+      operatorFound = this.optionalOperator('-');
+      if (operatorFound) {
+        result += '-';
+      }
+    } while (operatorFound);
+
+    return result.toString();
+  }
+
+  parseTemplateBindings() {
+    var bindings = [];
+    while (this.index < this.tokens.length) {
+      var keyIsVar:boolean = this.optionalKeywordVar();
+      var key = this.expectTemplateBindingKey();
+      this.optionalCharacter($COLON);
+      var name = null;
+      var expression = null;
+      if (this.next !== EOF) {
+        if (keyIsVar) {
+          if (this.optionalOperator("=")) {
+            name = this.expectTemplateBindingKey();
+          } else {
+            name = '\$implicit';
+          }
+        } else if (!this.peekKeywordVar()) {
+          var start = this.inputIndex;
+          var ast = this.parseExpression();
+          var source = this.input.substring(start, this.inputIndex);
+          expression = new ASTWithSource(ast, source, this.location);
+        }
+      }
+      ListWrapper.push(bindings, new TemplateBinding(key, keyIsVar, name, expression));
+      if (!this.optionalCharacter($SEMICOLON)) {
+        this.optionalCharacter($COMMA);
+      };
+    }
+    return bindings;
+  }
+
+  error(message:string, index:int = null) {
+    if (isBlank(index)) index = this.index;
+
+    var location = (index < this.tokens.length)
+      ? `at column ${this.tokens[index].index + 1} in`
+      : `at the end of the expression`;
+
+    throw new BaseException(`Parser Error: ${message} ${location} [${this.input}] in ${this.location}`);
+  }
+}