Version 0.8.10.1

dart/pkg/analyzer/lib/src/generated/scanner.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.scanner;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'error.dart';
 import 'instrumentation.dart';
 import 'utilities_collection.dart' show TokenMap;
@@ skipping 119 matching lines @@
    */
   KeywordState next(int c) => _table[c - 0x61];
 }
 /**
  * The enumeration `ScannerErrorCode` defines the error codes used for errors detected by the
  * scanner.
  *
  * @coverage dart.engine.parser
  */
 class ScannerErrorCode extends Enum<ScannerErrorCode> implements ErrorCode {
-  static final ScannerErrorCode CHARACTER_EXPECTED_AFTER_SLASH = new ScannerErrorCode.con1('CHARACTER_EXPECTED_AFTER_SLASH', 0, "Character expected after slash");
-  static final ScannerErrorCode ILLEGAL_CHARACTER = new ScannerErrorCode.con1('ILLEGAL_CHARACTER', 1, "Illegal character %x");
-  static final ScannerErrorCode MISSING_DIGIT = new ScannerErrorCode.con1('MISSING_DIGIT', 2, "Decimal digit expected");
-  static final ScannerErrorCode MISSING_HEX_DIGIT = new ScannerErrorCode.con1('MISSING_HEX_DIGIT', 3, "Hexidecimal digit expected");
-  static final ScannerErrorCode MISSING_QUOTE = new ScannerErrorCode.con1('MISSING_QUOTE', 4, "Expected quote (' or \")");
-  static final ScannerErrorCode UNTERMINATED_MULTI_LINE_COMMENT = new ScannerErrorCode.con1('UNTERMINATED_MULTI_LINE_COMMENT', 5, "Unterminated multi-line comment");
-  static final ScannerErrorCode UNTERMINATED_STRING_LITERAL = new ScannerErrorCode.con1('UNTERMINATED_STRING_LITERAL', 6, "Unterminated string literal");
+  static final ScannerErrorCode ILLEGAL_CHARACTER = new ScannerErrorCode.con1('ILLEGAL_CHARACTER', 0, "Illegal character %x");
+  static final ScannerErrorCode MISSING_DIGIT = new ScannerErrorCode.con1('MISSING_DIGIT', 1, "Decimal digit expected");
+  static final ScannerErrorCode MISSING_HEX_DIGIT = new ScannerErrorCode.con1('MISSING_HEX_DIGIT', 2, "Hexidecimal digit expected");
+  static final ScannerErrorCode MISSING_QUOTE = new ScannerErrorCode.con1('MISSING_QUOTE', 3, "Expected quote (' or \")");
+  static final ScannerErrorCode UNTERMINATED_MULTI_LINE_COMMENT = new ScannerErrorCode.con1('UNTERMINATED_MULTI_LINE_COMMENT', 4, "Unterminated multi-line comment");
+  static final ScannerErrorCode UNTERMINATED_STRING_LITERAL = new ScannerErrorCode.con1('UNTERMINATED_STRING_LITERAL', 5, "Unterminated string literal");
   static final List<ScannerErrorCode> values = [
-      CHARACTER_EXPECTED_AFTER_SLASH,
       ILLEGAL_CHARACTER,
       MISSING_DIGIT,
       MISSING_HEX_DIGIT,
       MISSING_QUOTE,
       UNTERMINATED_MULTI_LINE_COMMENT,
       UNTERMINATED_STRING_LITERAL];
 
   /**
    * The template used to create the message to be displayed for this error.
    */
@@ skipping 303 matching lines @@
 class IncrementalScanner extends Scanner {
 
   /**
    * The reader used to access the characters in the source.
    */
   CharacterReader _reader;
 
   /**
    * A map from tokens that were copied to the copies of the tokens.
    */
-  TokenMap _tokenMap = new TokenMap();
+  final TokenMap tokenMap = new TokenMap();
+
+  /**
+   * The first token in the range of tokens that are different from the tokens in the original token
+   * stream.
+   */
+  Token _firstToken;
+
+  /**
+   * The last token in the range of tokens that are different from the tokens in the original token
+   * stream.
+   */
+  Token lastToken;
 
   /**
    * Initialize a newly created scanner.
    *
    * @param source the source being scanned
    * @param reader the character reader used to read the characters in the source
    * @param errorListener the error listener that will be informed of any errors that are found
    */
   IncrementalScanner(Source source, CharacterReader reader, AnalysisErrorListener errorListener) : super(source, reader, errorListener) {
     this._reader = reader;
   }
 
   /**
+   * Return the first token in the range of tokens that are different from the tokens in the
+   * original token stream or `null` if the new tokens are the same as the original tokens
+   * except for offset.
+   *
+   * @return the first token in the range of new tokens
+   */
+  Token get firstToken => _firstToken;
+
+  /**
    * Given the stream of tokens scanned from the original source, the modified source (the result of
    * replacing one contiguous range of characters with another string of characters), and a
    * specification of the modification that was made, return a stream of tokens scanned from the
    * modified source. The original stream of tokens will not be modified.
    *
    * @param originalStream the stream of tokens scanned from the original source
    * @param index the index of the first character in both the original and modified source that was
    *          affected by the modification
    * @param removedLength the number of characters removed from the original source
    * @param insertedLength the number of characters added to the modified source
    */
   Token rescan(Token originalStream, int index, int removedLength, int insertedLength) {
-    while (originalStream.end < index) {
+    while (originalStream.type != TokenType.EOF && originalStream.end < index) {
       originalStream = copyAndAdvance(originalStream, 0);
     }
+    Token lastCopied = tail;
     int modifiedEnd = index + insertedLength - 1;
+    if (originalStream.offset < index) {
+      modifiedEnd += originalStream.end - index - removedLength;
+    }
     _reader.offset = Math.min(originalStream.offset, index) - 1;
     int next = _reader.advance();
     while (next != -1 && _reader.offset <= modifiedEnd) {
       next = bigSwitch(next);
     }
-    int removedEnd = index + removedLength - 1;
+    _firstToken = lastCopied.next;
+    lastToken = tail;
+    if (_firstToken == null || identical(_firstToken.type, TokenType.EOF)) {
+      _firstToken = null;
+      lastToken = null;
+    } else if (originalStream.end == index && _firstToken.end == index) {
+      tokenMap.put(originalStream, _firstToken);
+      if (identical(lastToken, _firstToken)) {
+        lastToken = lastToken.next;
+      }
+      _firstToken = _firstToken.next;
+    }
+    int removedEnd = index + removedLength - 1 + Math.max(0, tail.end - index - insertedLength);
     while (originalStream.offset <= removedEnd) {
       originalStream = originalStream.next;
     }
     int delta = insertedLength - removedLength;
     while (originalStream.type != TokenType.EOF) {
       originalStream = copyAndAdvance(originalStream, delta);
     }
-    copyAndAdvance(originalStream, delta);
-    return firstToken();
+    Token eof = copyAndAdvance(originalStream, delta);
+    eof.setNextWithoutSettingPrevious(eof);
+    return super.firstToken;
   }
   Token copyAndAdvance(Token originalToken, int delta) {
     Token copiedToken = originalToken.copy();
-    _tokenMap.put(originalToken, copiedToken);
+    tokenMap.put(originalToken, copiedToken);
     copiedToken.applyDelta(delta);
     appendToken(copiedToken);
     Token originalComment = originalToken.precedingComments;
     Token copiedComment = originalToken.precedingComments;
     while (originalComment != null) {
-      _tokenMap.put(originalComment, copiedComment);
+      tokenMap.put(originalComment, copiedComment);
       originalComment = originalComment.next;
       copiedComment = copiedComment.next;
     }
     return originalToken.next;
   }
 }
 /**
  * The class `Scanner` implements a scanner for Dart code.
  *
  * The lexical structure of Dart is ambiguous without knowledge of the context in which a token is
@@ skipping 22 matching lines @@
   AnalysisErrorListener _errorListener;
 
   /**
    * The token pointing to the head of the linked list of tokens.
    */
   Token _tokens;
 
   /**
    * The last token that was scanned.
    */
-  Token _tail;
+  Token tail;
 
   /**
    * The first token in the list of comment tokens found since the last non-comment token.
    */
   Token _firstComment;
 
   /**
    * The last token in the list of comment tokens found since the last non-comment token.
    */
   Token _lastComment;
@@ skipping 30 matching lines @@
    * @param source the source being scanned
    * @param reader the character reader used to read the characters in the source
    * @param errorListener the error listener that will be informed of any errors that are found
    */
   Scanner(Source source, CharacterReader reader, AnalysisErrorListener errorListener) {
     this.source = source;
     this._reader = reader;
     this._errorListener = errorListener;
     _tokens = new Token(TokenType.EOF, -1);
     _tokens.setNext(_tokens);
-    _tail = _tokens;
+    tail = _tokens;
     _tokenStart = -1;
     _lineStarts.add(0);
   }
 
   /**
    * Return an array containing the offsets of the first character of each line in the source code.
    *
    * @return an array containing the offsets of the first character of each line in the source code
    */
   List<int> get lineStarts => _lineStarts;
@@ skipping 36 matching lines @@
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.AbstractScanner.tokenize");
     int tokenCounter = 0;
     try {
       int next = _reader.advance();
       while (next != -1) {
         tokenCounter++;
         next = bigSwitch(next);
       }
       appendEofToken();
       instrumentation.metric2("tokensCount", tokenCounter);
-      return firstToken();
+      return firstToken;
     } finally {
       instrumentation.log2(2);
     }
   }
 
   /**
    * Append the given token to the end of the token stream being scanned. This method is intended to
    * be used by subclasses that copy existing tokens and should not normally be used because it will
    * fail to correctly associate any comments with the token being passed in.
    *
    * @param token the token to be appended
    */
   void appendToken(Token token) {
-    _tail = _tail.setNext(token);
+    tail = tail.setNext(token);
   }
   int bigSwitch(int next) {
     beginToken();
     if (next == 0xD) {
       next = _reader.advance();
       if (next == 0xA) {
         next = _reader.advance();
       }
       recordStartOfLine();
       return next;
@@ skipping 127 matching lines @@
     }
     reportError(ScannerErrorCode.ILLEGAL_CHARACTER, [next]);
     return _reader.advance();
   }
 
   /**
    * Return the first token in the token stream that was scanned.
    *
    * @return the first token in the token stream that was scanned
    */
-  Token firstToken() => _tokens.next;
+  Token get firstToken => _tokens.next;
 
   /**
    * Record the fact that we are at the beginning of a new line in the source.
    */
   void recordStartOfLine() {
     _lineStarts.add(_reader.offset);
   }
   void appendBeginToken(TokenType type) {
     BeginToken token;
     if (_firstComment == null) {
       token = new BeginToken(type, _tokenStart);
     } else {
       token = new BeginTokenWithComment(type, _tokenStart, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
-    _tail = _tail.setNext(token);
+    tail = tail.setNext(token);
     _groupingStack.add(token);
     _stackEnd++;
   }
   void appendCommentToken(TokenType type, String value) {
     if (_firstComment == null) {
       _firstComment = new StringToken(type, value, _tokenStart);
       _lastComment = _firstComment;
     } else {
       _lastComment = _lastComment.setNext(new StringToken(type, value, _tokenStart));
     }
   }
   void appendEndToken(TokenType type, TokenType beginType) {
     Token token;
     if (_firstComment == null) {
       token = new Token(type, _tokenStart);
     } else {
       token = new TokenWithComment(type, _tokenStart, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
-    _tail = _tail.setNext(token);
+    tail = tail.setNext(token);
     if (_stackEnd >= 0) {
       BeginToken begin = _groupingStack[_stackEnd];
       if (identical(begin.type, beginType)) {
         begin.endToken = token;
         _groupingStack.removeAt(_stackEnd--);
       }
     }
   }
   void appendEofToken() {
     Token eofToken;
     if (_firstComment == null) {
       eofToken = new Token(TokenType.EOF, _reader.offset + 1);
     } else {
       eofToken = new TokenWithComment(TokenType.EOF, _reader.offset + 1, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
     eofToken.setNext(eofToken);
-    _tail = _tail.setNext(eofToken);
+    tail = tail.setNext(eofToken);
     if (_stackEnd >= 0) {
       _hasUnmatchedGroups2 = true;
     }
   }
   void appendKeywordToken(Keyword keyword) {
     if (_firstComment == null) {
-      _tail = _tail.setNext(new KeywordToken(keyword, _tokenStart));
+      tail = tail.setNext(new KeywordToken(keyword, _tokenStart));
     } else {
-      _tail = _tail.setNext(new KeywordTokenWithComment(keyword, _tokenStart, _firstComment));
+      tail = tail.setNext(new KeywordTokenWithComment(keyword, _tokenStart, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
   void appendStringToken(TokenType type, String value) {
     if (_firstComment == null) {
-      _tail = _tail.setNext(new StringToken(type, value, _tokenStart));
+      tail = tail.setNext(new StringToken(type, value, _tokenStart));
     } else {
-      _tail = _tail.setNext(new StringTokenWithComment(type, value, _tokenStart, _firstComment));
+      tail = tail.setNext(new StringTokenWithComment(type, value, _tokenStart, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
   void appendStringToken2(TokenType type, String value, int offset) {
     if (_firstComment == null) {
-      _tail = _tail.setNext(new StringToken(type, value, _tokenStart + offset));
+      tail = tail.setNext(new StringToken(type, value, _tokenStart + offset));
     } else {
-      _tail = _tail.setNext(new StringTokenWithComment(type, value, _tokenStart + offset, _firstComment));
+      tail = tail.setNext(new StringTokenWithComment(type, value, _tokenStart + offset, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
   void appendToken2(TokenType type) {
     if (_firstComment == null) {
-      _tail = _tail.setNext(new Token(type, _tokenStart));
+      tail = tail.setNext(new Token(type, _tokenStart));
     } else {
-      _tail = _tail.setNext(new TokenWithComment(type, _tokenStart, _firstComment));
+      tail = tail.setNext(new TokenWithComment(type, _tokenStart, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
   void appendToken3(TokenType type, int offset) {
     if (_firstComment == null) {
-      _tail = _tail.setNext(new Token(type, offset));
+      tail = tail.setNext(new Token(type, offset));
     } else {
-      _tail = _tail.setNext(new TokenWithComment(type, offset, _firstComment));
+      tail = tail.setNext(new TokenWithComment(type, offset, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
   void beginToken() {
     _tokenStart = _reader.offset;
   }
 
   /**
    * Return the beginning token corresponding to a closing brace that was found while scanning
@@ skipping 378 matching lines @@
             return _reader.advance();
           }
         }
         continue;
       }
       if (next == 0x5C) {
         next = _reader.advance();
         if (next == -1) {
           break;
         }
-        bool missingCharacter = false;
         if (next == 0xD) {
-          missingCharacter = true;
           next = _reader.advance();
           if (next == 0xA) {
             next = _reader.advance();
           }
           recordStartOfLine();
         } else if (next == 0xA) {
-          missingCharacter = true;
           recordStartOfLine();
           next = _reader.advance();
         } else {
           next = _reader.advance();
         }
-        if (missingCharacter) {
-          _errorListener.onError(new AnalysisError.con2(source, _reader.offset - 1, 1, ScannerErrorCode.CHARACTER_EXPECTED_AFTER_SLASH, []));
-        }
       } else if (next == 0xD) {
         next = _reader.advance();
         if (next == 0xA) {
           next = _reader.advance();
         }
         recordStartOfLine();
       } else if (next == 0xA) {
         recordStartOfLine();
         next = _reader.advance();
       } else {
@@ skipping 365 matching lines @@
    */
   Token copyComments(Token token) {
     if (token == null) {
       return null;
     }
     Token head = token.copy();
     Token tail = head;
     token = token.next;
     while (token != null) {
       tail = tail.setNext(token.copy());
+      token = token.next;
     }
     return head;
   }
 }
 /**
  * The interface `CharacterReader`
  */
 abstract class CharacterReader {
 
   /**
@@ skipping 532 matching lines @@
    * Return `true` if this token type represents an operator that can be defined by users.
    *
    * @return `true` if this token type represents an operator that can be defined by users
    */
   bool get isUserDefinableOperator => identical(lexeme, "==") || identical(lexeme, "~") || identical(lexeme, "[]") || identical(lexeme, "[]=") || identical(lexeme, "*") || identical(lexeme, "/") || identical(lexeme, "%") || identical(lexeme, "~/") || identical(lexeme, "+") || identical(lexeme, "-") || identical(lexeme, "<<") || identical(lexeme, ">>") || identical(lexeme, ">=") || identical(lexeme, ">") || identical(lexeme, "<=") || identical(lexeme, "<") || identical(lexeme, "&") || identical(lexeme, "^") || identical(lexeme, "|");
 }
 class TokenType_EOF extends TokenType {
   TokenType_EOF(String name, int ordinal, TokenClass arg0, String arg1) : super.con2(name, ordinal, arg0, arg1);
   String toString() => "-eof-";
 }