Implement cascaded calls.

lib/compiler/implementation/scanner/scanner.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 interface Scanner {
   Token tokenize();
 }
 
 /**
  * Common base class for a Dart scanner.
  */
 class AbstractScanner<T> implements Scanner {
   abstract int advance();
   abstract int nextByte();
   abstract int peek();
   abstract int select(int choice, PrecedenceInfo yes, PrecedenceInfo no);
-  abstract void appendPrecenceToken(PrecedenceInfo info);
+  abstract void appendPrecedenceToken(PrecedenceInfo info);
   abstract void appendStringToken(PrecedenceInfo info, String value);
   abstract void appendByteStringToken(PrecedenceInfo info, T value);
   abstract void appendKeywordToken(Keyword keyword);
   abstract void appendWhiteSpace(int next);
   abstract void appendEofToken();
   abstract T asciiString(int start, int offset);
   abstract T utf8String(int start, int offset);
   abstract Token firstToken();
   abstract void beginToken();
   abstract void addToCharOffset(int offset);
@@ skipping 78 matching lines @@
 
     if (next === $OPEN_SQUARE_BRACKET) {
       return tokenizeOpenSquareBracket(next);
     }
 
     if (next === $TILDE) {
       return tokenizeTilde(next);
     }
 
     if (next === $BACKSLASH) {
-      appendPrecenceToken(BACKSLASH_INFO);
+      appendPrecedenceToken(BACKSLASH_INFO);
       return advance();
     }
 
     if (next === $HASH) {
       return tokenizeTag(next);
     }
 
     if (next === $OPEN_PAREN) {
       appendBeginGroup(OPEN_PAREN_INFO, "(");
       return advance();
     }
 
     if (next === $CLOSE_PAREN) {
       return appendEndGroup(CLOSE_PAREN_INFO, ")", OPEN_PAREN_TOKEN);
     }
 
     if (next === $COMMA) {
-      appendPrecenceToken(COMMA_INFO);
+      appendPrecedenceToken(COMMA_INFO);
       return advance();
     }
 
     if (next === $COLON) {
-      appendPrecenceToken(COLON_INFO);
+      appendPrecedenceToken(COLON_INFO);
       return advance();
     }
 
     if (next === $SEMICOLON) {
-      appendPrecenceToken(SEMICOLON_INFO);
+      appendPrecedenceToken(SEMICOLON_INFO);
       discardOpenLt();
       return advance();
     }
 
     if (next === $QUESTION) {
-      appendPrecenceToken(QUESTION_INFO);
+      appendPrecedenceToken(QUESTION_INFO);
       return advance();
     }
 
     if (next === $CLOSE_SQUARE_BRACKET) {
       return appendEndGroup(CLOSE_SQUARE_BRACKET_INFO, "]",
                             OPEN_SQUARE_BRACKET_TOKEN);
     }
 
     if (next === $BACKPING) {
-      appendPrecenceToken(BACKPING_INFO);
+      appendPrecedenceToken(BACKPING_INFO);
       return advance();
     }
 
     if (next === $OPEN_CURLY_BRACKET) {
       appendBeginGroup(OPEN_CURLY_BRACKET_INFO, "{");
       return advance();
     }
 
     if (next === $CLOSE_CURLY_BRACKET) {
       return appendEndGroup(CLOSE_CURLY_BRACKET_INFO, "}",
                             OPEN_CURLY_BRACKET_TOKEN);
     }
 
     if (next === $SLASH) {
       return tokenizeSlashOrComment(next);
     }
 
     if (next === $AT) {
       return tokenizeRawString(next);
     }
 
     if (next === $DQ || next === $SQ) {
       return tokenizeString(next, byteOffset, false);
     }
 
     if (next === $PERIOD) {
-      return tokenizeDotOrNumber(next);
+      return tokenizeDotsOrNumber(next);
     }
 
     if (next === $0) {
       return tokenizeHexOrNumber(next);
     }
 
     // TODO(ahe): Would a range check be faster?
     if (next === $1 || next === $2 || next === $3 || next === $4 ||  next === $5
         || next === $6 || next === $7 || next === $8 || next === $9) {
       return tokenizeNumber(next);
@@ skipping 19 matching lines @@
   int tokenizeTag(int next) {
     // # or #!.*[\n\r]
     if (byteOffset === 0) {
       if (peek() === $BANG) {
         do {
           next = advance();
         } while (next !== $LF && next !== $CR && next !== $EOF);
         return next;
       }
     }
-    appendPrecenceToken(HASH_INFO);
+    appendPrecedenceToken(HASH_INFO);
     return advance();
   }
 
   int tokenizeTilde(int next) {
     // ~ ~/ ~/=
     next = advance();
     if (next === $SLASH) {
       return select($EQ, TILDE_SLASH_EQ_INFO, TILDE_SLASH_INFO);
     } else {
-      appendPrecenceToken(TILDE_INFO);
+      appendPrecedenceToken(TILDE_INFO);
       return next;
     }
   }
 
   int tokenizeOpenSquareBracket(int next) {
     // [ [] []=
     next = advance();
     if (next === $CLOSE_SQUARE_BRACKET) {
       return select($EQ, INDEX_EQ_INFO, INDEX_INFO);
     } else {
       appendBeginGroup(OPEN_SQUARE_BRACKET_INFO, "[");
       return next;
     }
   }
 
   int tokenizeCaret(int next) {
     // ^ ^=
     return select($EQ, CARET_EQ_INFO, CARET_INFO);
   }
 
   int tokenizeBar(int next) {
     // | || |=
     next = advance();
     if (next === $BAR) {
-      appendPrecenceToken(BAR_BAR_INFO);
+      appendPrecedenceToken(BAR_BAR_INFO);
       return advance();
     } else if (next === $EQ) {
-      appendPrecenceToken(BAR_EQ_INFO);
+      appendPrecedenceToken(BAR_EQ_INFO);
       return advance();
     } else {
-      appendPrecenceToken(BAR_INFO);
+      appendPrecedenceToken(BAR_INFO);
       return next;
     }
   }
 
   int tokenizeAmpersand(int next) {
     // && &= &
     next = advance();
     if (next === $AMPERSAND) {
-      appendPrecenceToken(AMPERSAND_AMPERSAND_INFO);
+      appendPrecedenceToken(AMPERSAND_AMPERSAND_INFO);
       return advance();
     } else if (next === $EQ) {
-      appendPrecenceToken(AMPERSAND_EQ_INFO);
+      appendPrecedenceToken(AMPERSAND_EQ_INFO);
       return advance();
     } else {
-      appendPrecenceToken(AMPERSAND_INFO);
+      appendPrecedenceToken(AMPERSAND_INFO);
       return next;
     }
   }
 
   int tokenizePercent(int next) {
     // % %=
     return select($EQ, PERCENT_EQ_INFO, PERCENT_INFO);
   }
 
   int tokenizeMultiply(int next) {
     // * *=
     return select($EQ, STAR_EQ_INFO, STAR_INFO);
   }
 
   int tokenizeMinus(int next) {
     // - -- -=
     next = advance();
     if (next === $MINUS) {
-      appendPrecenceToken(MINUS_MINUS_INFO);
+      appendPrecedenceToken(MINUS_MINUS_INFO);
       return advance();
     } else if (next === $EQ) {
-      appendPrecenceToken(MINUS_EQ_INFO);
+      appendPrecedenceToken(MINUS_EQ_INFO);
       return advance();
     } else {
-      appendPrecenceToken(MINUS_INFO);
+      appendPrecedenceToken(MINUS_INFO);
       return next;
     }
   }
 
 
   int tokenizePlus(int next) {
     // + ++ +=
     next = advance();
     if ($PLUS === next) {
-      appendPrecenceToken(PLUS_PLUS_INFO);
+      appendPrecedenceToken(PLUS_PLUS_INFO);
       return advance();
     } else if ($EQ === next) {
-      appendPrecenceToken(PLUS_EQ_INFO);
+      appendPrecedenceToken(PLUS_EQ_INFO);
       return advance();
     } else {
-      appendPrecenceToken(PLUS_INFO);
+      appendPrecedenceToken(PLUS_INFO);
       return next;
     }
   }
 
   int tokenizeExclamation(int next) {
     // ! != !==
     next = advance();
     if (next === $EQ) {
       return select($EQ, BANG_EQ_EQ_INFO, BANG_EQ_INFO);
     }
-    appendPrecenceToken(BANG_INFO);
+    appendPrecedenceToken(BANG_INFO);
     return next;
   }
 
   int tokenizeEquals(int next) {
     // = == ===
     next = advance();
     if (next === $EQ) {
       return select($EQ, EQ_EQ_EQ_INFO, EQ_EQ_INFO);
     } else if (next === $GT) {
-      appendPrecenceToken(FUNCTION_INFO);
+      appendPrecedenceToken(FUNCTION_INFO);
       return advance();
     }
-    appendPrecenceToken(EQ_INFO);
+    appendPrecedenceToken(EQ_INFO);
     return next;
   }
 
   int tokenizeGreaterThan(int next) {
     // > >= >> >>= >>> >>>=
     next = advance();
     if ($EQ === next) {
-      appendPrecenceToken(GT_EQ_INFO);
+      appendPrecedenceToken(GT_EQ_INFO);
       return advance();
     } else if ($GT === next) {
       next = advance();
       if ($EQ === next) {
-        appendPrecenceToken(GT_GT_EQ_INFO);
+        appendPrecedenceToken(GT_GT_EQ_INFO);
         return advance();
       } else if ($GT === next) {
         next = advance();
         if (next === $EQ) {
-          appendPrecenceToken(GT_GT_GT_EQ_INFO);
+          appendPrecedenceToken(GT_GT_GT_EQ_INFO);
           return advance();
         } else {
           appendGtGtGt(GT_GT_GT_INFO, ">>>");
           return next;
         }
       } else {
         appendGtGt(GT_GT_INFO, ">>");
         return next;
       }
     } else {
       appendGt(GT_INFO, ">");
       return next;
     }
   }
 
   int tokenizeLessThan(int next) {
     // < <= << <<=
     next = advance();
     if ($EQ === next) {
-      appendPrecenceToken(LT_EQ_INFO);
+      appendPrecedenceToken(LT_EQ_INFO);
       return advance();
     } else if ($LT === next) {
       return select($EQ, LT_LT_EQ_INFO, LT_LT_INFO);
     } else {
       appendBeginGroup(LT_INFO, "<");
       return next;
     }
   }
 
   int tokenizeNumber(int next) {
@@ skipping 34 matching lines @@
       } else {
         if (!hasDigits) {
           throw new MalformedInputException("hex digit expected", charOffset);
         }
         appendByteStringToken(HEXADECIMAL_INFO, asciiString(start, 0));
         return next;
       }
     }
   }
 
-  int tokenizeDotOrNumber(int next) {
+  int tokenizeDotsOrNumber(int next) {
     int start = byteOffset;
     next = advance();
     if (($0 <= next && next <= $9)) {
       return tokenizeFractionPart(next, start);
     } else if ($PERIOD === next) {
       return select($PERIOD, PERIOD_PERIOD_PERIOD_INFO, PERIOD_PERIOD_INFO);
     } else {
-      appendPrecenceToken(PERIOD_INFO);
+      appendPrecedenceToken(PERIOD_INFO);
       return next;
     }
   }
 
   int tokenizeFractionPart(int next, int start) {
     bool done = false;
     bool hasDigit = false;
     LOOP: while (!done) {
       if ($0 <= next && next <= $9) {
         hasDigit = true;
       } else if ($e === next || $E === next) {
         hasDigit = true;
         next = tokenizeExponent(advance());
         done = true;
         continue LOOP;
       } else {
         done = true;
         continue LOOP;
       }
       next = advance();
     }
     if (!hasDigit) {
       appendByteStringToken(INT_INFO, asciiString(start, -1));
+      if ($PERIOD === next) {
+        return select($PERIOD, PERIOD_PERIOD_PERIOD_INFO, PERIOD_PERIOD_INFO);
+      }
       // TODO(ahe): Wrong offset for the period.
-      appendPrecenceToken(PERIOD_INFO);
+      appendPrecedenceToken(PERIOD_INFO);
       return bigSwitch(next);
     }
     if (next === $d || next === $D) {
       next = advance();
     }
     appendByteStringToken(DOUBLE_INFO, asciiString(start, 0));
     return next;
   }
 
   int tokenizeExponent(int next) {
@@ skipping 14 matching lines @@
     }
   }
 
   int tokenizeSlashOrComment(int next) {
     next = advance();
     if ($STAR === next) {
       return tokenizeMultiLineComment(next);
     } else if ($SLASH === next) {
       return tokenizeSingleLineComment(next);
     } else if ($EQ === next) {
-      appendPrecenceToken(SLASH_EQ_INFO);
+      appendPrecedenceToken(SLASH_EQ_INFO);
       return advance();
     } else {
-      appendPrecenceToken(SLASH_INFO);
+      appendPrecedenceToken(SLASH_INFO);
       return next;
     }
   }
 
   int tokenizeSingleLineComment(int next) {
     while (true) {
       next = advance();
       if ($LF === next || $CR === next || $EOF === next) {
         return next;
       }
@@ skipping 232 matching lines @@
                                       charOffset);
   }
 }
 
 class MalformedInputException {
   final String message;
   final position;
   MalformedInputException(this.message, this.position);
   toString() => message;
 }