Updating Angular version

third_party/pkg/angular/lib/core/parser/lexer.dart

-part of angular.core.parser;
+library angular.core.parser.lexer;
 
+import 'package:angular/core/module.dart' show NgInjectableService;
+import 'package:angular/core/parser/characters.dart';
+
+class Token {
+  final int index;
+  final String text;
+
+  var value;
+  // Tokens should have one of these set.
+  String opKey;
+  String key;
+
+  Token(this.index, this.text);
+
+  withOp(op) {
+    this.opKey = op;
+  }
+
+  withGetterSetter(key) {
+    this.key = key;
+  }
+
+  withValue(value) { this.value = value; }
+
+  toString() => "Token($text)";
+}
+
+
 @NgInjectableService()
 class Lexer {
   List<Token> call(String text) {
     Scanner scanner = new Scanner(text);
     List<Token> tokens = [];
     Token token = scanner.scanToken();
     while (token != null) {
       tokens.add(token);
       token = scanner.scanToken();
     }
     return tokens;
   }
 }
 
 class Scanner {
   final String input;
   final int length;
 
-  // TODO(kasperl): Get rid of this buffer. It is currently used for
-  // pushing back tokens for method calls found while scanning
-  // identifiers. We should be able to do this in the parser instead.
-  final List<Token> buffer = [];
-
   int peek = 0;
   int index = -1;
 
   Scanner(String input) : this.input = input, this.length = input.length {
     advance();
   }
 
   Token scanToken() {
-    // TODO(kasperl): The current handling of method calls is somewhat
-    // complicated. We should simplify it by dealing with it in the parser.
-    if (!buffer.isEmpty) return buffer.removeLast();
-
     // Skip whitespace.
-    while (isWhitespace(peek)) advance();
+    while (peek <= $SPACE) {
+    if (++index >= length) {
+      peek = $EOF;
+      return null;
+    } else {
+      peek = input.codeUnitAt(index);
+    }
+  }
 
     // Handle identifiers and numbers.
     if (isIdentifierStart(peek)) return scanIdentifier();
     if (isDigit(peek)) return scanNumber(index);
 
     int start = index;
     switch (peek) {
-      case $EOF:
-        return null;
       case $PERIOD:
         advance();
         return isDigit(peek) ? scanNumber(start) : new Token(start, '.');
       case $LPAREN:
-        return scanCharacter(start, '(');
       case $RPAREN:
-        return scanCharacter(start, ')');
       case $LBRACE:
-        return scanCharacter(start, '{');
       case $RBRACE:
-        return scanCharacter(start, '}');
       case $LBRACKET:
-        return scanCharacter(start, '[');
       case $RBRACKET:
-        return scanCharacter(start, ']');
       case $COMMA:
-        return scanCharacter(start, ',');
       case $COLON:
-        return scanCharacter(start, ':');
       case $SEMICOLON:
-        return scanCharacter(start, ';');
+        return scanCharacter(start, new String.fromCharCode(peek));
       case $SQ:
       case $DQ:
         return scanString();
       case $PLUS:
-        return scanOperator(start, '+');
       case $MINUS:
-        return scanOperator(start, '-');
       case $STAR:
-        return scanOperator(start, '*');
       case $SLASH:
-        return scanOperator(start, '/');
       case $PERCENT:
-        return scanOperator(start, '%');
       case $CARET:
-        return scanOperator(start, '^');
       case $QUESTION:
-        return scanOperator(start, '?');
+        return scanOperator(start, new String.fromCharCode(peek));
       case $LT:
-        return scanComplexOperator(start, $EQ, '<', '<=');
       case $GT:
-        return scanComplexOperator(start, $EQ, '>', '>=');
       case $BANG:
-        return scanComplexOperator(start, $EQ, '!', '!=');
       case $EQ:
-        return scanComplexOperator(start, $EQ, '=', '==');
+        return scanComplexOperator(start, $EQ, new String.fromCharCode(peek), '=');
       case $AMPERSAND:
-        return scanComplexOperator(start, $AMPERSAND, '&', '&&');
+        return scanComplexOperator(start, $AMPERSAND, '&', '&');
       case $BAR:
-        return scanComplexOperator(start, $BAR, '|', '||');
+        return scanComplexOperator(start, $BAR, '|', '|');
       case $TILDE:
-        return scanComplexOperator(start, $SLASH, '~', '~/');
+        return scanComplexOperator(start, $SLASH, '~', '/');
+      case $NBSP:
+        while (isWhitespace(peek)) advance();
+        return scanToken();
     }
 
     String character = new String.fromCharCode(peek);
     error('Unexpected character [$character]');
   }
 
   Token scanCharacter(int start, String string) {
     assert(peek == string.codeUnitAt(0));
     advance();
     return new Token(start, string);
   }
 
   Token scanOperator(int start, String string) {
     assert(peek == string.codeUnitAt(0));
-    assert(OPERATORS.containsKey(string));
+    assert(OPERATORS.contains(string));
     advance();
     return new Token(start, string)..withOp(string);
   }
 
   Token scanComplexOperator(int start, int code, String one, String two) {
     assert(peek == one.codeUnitAt(0));
     advance();
     String string = one;
     if (peek == code) {
       advance();
-      string = two;
+      string += two;
     }
-    assert(OPERATORS.containsKey(string));
+    assert(OPERATORS.contains(string));
     return new Token(start, string)..withOp(string);
   }
 
   Token scanIdentifier() {
     assert(isIdentifierStart(peek));
     int start = index;
-    int dot = -1;
     advance();
-    while (true) {
-      if (peek == $PERIOD) {
-        dot = index;
-      } else if (!isIdentifierPart(peek)) {
-        break;
-      }
-      advance();
+    while (isIdentifierPart(peek)) advance();
+    String string = input.substring(start, index);
+    Token result = new Token(start, string);
+    // TODO(kasperl): Deal with null, undefined, true, and false in
+    // a cleaner and faster way.
+    if (OPERATORS.contains(string)) {
+      result.withOp(string);
+    } else {
+      result.withGetterSetter(string);
     }
-    if (dot == -1) {
-      String string = input.substring(start, index);
-      Token result = new Token(start, string);
-      // TODO(kasperl): Deal with null, undefined, true, and false in
-      // a cleaner and faster way.
-      if (OPERATORS.containsKey(string)) {
-        result.withOp(string);
-      } else {
-        result.withGetterSetter(string);
-      }
-      return result;
-    }
-
-    int end = index;
-    while (isWhitespace(peek)) advance();
-    if (peek == $LPAREN) {
-      buffer.add(new Token(dot + 1, input.substring(dot + 1, end)));
-      buffer.add(new Token(dot, '.'));
-      end = dot;
-    }
-    String string = input.substring(start, end);
-    return new Token(start, string)..withGetterSetter(string);
+    return result;
   }
 
   Token scanNumber(int start) {
     assert(isDigit(peek));
     bool simple = (index == start);
+    advance();  // Skip initial digit.
     while (true) {
       if (isDigit(peek)) {
         // Do nothing.
       } else if (peek == $PERIOD) {
         simple = false;
       } else if (isExponentStart(peek)) {
         advance();
         if (isExponentSign(peek)) advance();
         if (!isDigit(peek)) error('Invalid exponent', -1);
         simple = false;
@@ skipping 60 matching lines @@
     else peek = input.codeUnitAt(index);
   }
 
   void error(String message, [int offset = 0]) {
     // TODO(kasperl): Try to get rid of the offset. It is only used to match
     // the error expectations in the lexer tests for numbers with exponents.
     int position = index + offset;
     throw "Lexer Error: $message at column $position in expression [$input]";
   }
 }
+
+Set<String> OPERATORS = new Set<String>.from([
+    'undefined',
+    'null',
+    'true',
+    'false',
+    '+',
+    '-',
+    '*',
+    '/',
+    '~/',
+    '%',
+    '^',
+    '=',
+    '==',
+    '!=',
+    '<',
+    '>',
+    '<=',
+    '>=',
+    '&&',
+    '||',
+    '&',
+    '|',
+    '!',
+    '?',
+]);
+