New analyzer_experimental snapshot.

pkg/analyzer_experimental/lib/src/generated/parser.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.parser;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'error.dart';
@@ skipping 413 matching lines @@
    */
   Token createSyntheticToken2(TokenType type) => new StringToken(type, "", _currentToken.offset);
   /**
    * Check that the given expression is assignable and report an error if it isn't.
    * <pre>
    * assignableExpression ::=
    * primary (arguments* assignableSelector)+
    * | 'super' assignableSelector
    * | identifier
    * assignableSelector ::=
-   * '[' expression ']'
+   * '[[' expression ']]'
    * | '.' identifier
    * </pre>
    * @param expression the expression being checked
    */
   void ensureAssignable(Expression expression) {
     if (expression != null && !expression.isAssignable()) {
       reportError4(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, []);
     }
   }
   /**
@@ skipping 20 matching lines @@
       return andAdvance;
     }
     if (identical(type, TokenType.SEMICOLON)) {
       reportError5(ParserErrorCode.EXPECTED_TOKEN, _currentToken.previous, [type.lexeme]);
     } else {
       reportError4(ParserErrorCode.EXPECTED_TOKEN, [type.lexeme]);
     }
     return _currentToken;
   }
   /**
+   * Search the given list of ranges for a range that contains the given index. Return the range
+   * that was found, or {@code null} if none of the ranges contain the index.
+   * @param ranges the ranges to be searched
+   * @param index the index contained in the returned range
+   * @return the range that was found
+   */
+  List<int> findRange(List<List<int>> ranges, int index) {
+    for (List<int> range in ranges) {
+      if (range[0] <= index && index <= range[1]) {
+        return range;
+      } else if (index < range[0]) {
+        return null;
+      }
+    }
+    return null;
+  }
+  /**
    * Advance to the next token in the token stream, making it the new current token.
    * @return the token that was current before this method was invoked
    */
   Token get andAdvance {
     Token token = _currentToken;
     advance();
     return token;
   }
   /**
+   * Return a list of the ranges of characters in the given comment string that should be treated as
+   * code blocks.
+   * @param comment the comment being processed
+   * @return the ranges of characters that should be treated as code blocks
+   */
+  List<List<int>> getCodeBlockRanges(String comment) {
+    List<List<int>> ranges = new List<List<int>>();
+    int length2 = comment.length;
+    int index = 0;
+    if (comment.startsWith("/**") || comment.startsWith("///")) {
+      index = 3;
+    }
+    while (index < length2) {
+      int currentChar = comment.codeUnitAt(index);
+      if (currentChar == 0xD || currentChar == 0xA) {
+        index = index + 1;
+        while (index < length2 && Character.isWhitespace(comment.codeUnitAt(index))) {
+          index = index + 1;
+        }
+        if (JavaString.startsWithBefore(comment, "*     ", index)) {
+          int end = index + 6;
+          while (end < length2 && comment.codeUnitAt(end) != 0xD && comment.codeUnitAt(end) != 0xA) {
+            end = end + 1;
+          }
+          ranges.add(<int> [index, end]);
+          index = end;
+        }
+      } else if (JavaString.startsWithBefore(comment, "[:", index)) {
+        int end = comment.indexOf(":]", index + 2);
+        if (end < 0) {
+          end = length2;
+        }
+        ranges.add(<int> [index, end]);
+        index = end + 1;
+      } else {
+        index = index + 1;
+      }
+    }
+    return ranges;
+  }
+  /**
    * Return {@code true} if the current token is the first token of a return type that is followed
    * by an identifier, possibly followed by a list of type parameters, followed by a
    * left-parenthesis. This is used by parseTypeAlias to determine whether or not to parse a return
    * type.
    * @return {@code true} if we can successfully parse the rest of a type alias if we first parse a
    * return type.
    */
   bool hasReturnTypeInTypeAlias() {
     Token next = skipReturnType(_currentToken);
     if (next == null) {
@@ skipping 71 matching lines @@
       return false;
     }
     token = skipSimpleIdentifier(token);
     if (token == null) {
       return false;
     }
     TokenType type2 = token.type;
     return identical(type2, TokenType.EQ) || identical(type2, TokenType.COMMA) || identical(type2, TokenType.SEMICOLON) || matches3(token, Keyword.IN);
   }
   /**
+   * Given that we have just found bracketed text within a comment, look to see whether that text is
+   * (a) followed by a parenthesized link address, (b) followed by a colon, or (c) followed by
+   * optional whitespace and another square bracket.
+   * <p>
+   * This method uses the syntax described by the <a
+   * href="http://daringfireball.net/projects/markdown/syntax">markdown</a> project.
+   * @param comment the comment text in which the bracketed text was found
+   * @param rightIndex the index of the right bracket
+   * @return {@code true} if the bracketed text is followed by a link address
+   */
+  bool isLinkText(String comment, int rightIndex) {
+    int length2 = comment.length;
+    int index = rightIndex + 1;
+    if (index >= length2) {
+      return false;
+    }
+    int nextChar = comment.codeUnitAt(index);
+    if (nextChar == 0x28 || nextChar == 0x3A) {
+      return true;
+    }
+    while (Character.isWhitespace(nextChar)) {
+      index = index + 1;
+      if (index >= length2) {
+        return false;
+      }
+      nextChar = comment.codeUnitAt(index);
+    }
+    return nextChar == 0x5B;
+  }
+  /**
    * Return {@code true} if the given token appears to be the beginning of an operator declaration.
    * @param startToken the token that might be the start of an operator declaration
    * @return {@code true} if the given token appears to be the beginning of an operator declaration
    */
   bool isOperator(Token startToken) {
     if (startToken.isOperator()) {
       Token token = startToken.next;
       while (token.isOperator()) {
         token = token.next;
       }
@@ skipping 324 matching lines @@
         return expression;
       }
       expression = selectorExpression;
       isOptional = true;
     }
   }
   /**
    * Parse an assignable selector.
    * <pre>
    * assignableSelector ::=
-   * '[' expression ']'
+   * '[[' expression ']]'
    * | '.' identifier
    * </pre>
    * @param prefix the expression preceding the selector
    * @param optional {@code true} if the selector is optional
    * @return the assignable selector that was parsed
    */
   Expression parseAssignableSelector(Expression prefix, bool optional) {
     if (matches5(TokenType.OPEN_SQUARE_BRACKET)) {
       Token leftBracket = andAdvance;
       Expression index = parseExpression2();
@@ skipping 120 matching lines @@
     }
     Token semicolon = expect2(TokenType.SEMICOLON);
     return new BreakStatement.full(breakKeyword, label, semicolon);
   }
   /**
    * Parse a cascade section.
    * <pre>
    * cascadeSection ::=
    * '..' (cascadeSelector arguments*) (assignableSelector arguments*)* cascadeAssignment?
    * cascadeSelector ::=
-   * '[' expression ']'
+   * '[[' expression ']]'
    * | identifier
    * cascadeAssignment ::=
    * assignmentOperator expressionWithoutCascade
    * </pre>
    * @return the expression representing the cascaded method invocation
    */
   Expression parseCascadeSection() {
     Token period = expect2(TokenType.PERIOD_PERIOD);
     Expression expression = null;
     SimpleIdentifier functionName = null;
@@ skipping 97 matching lines @@
           reportError5(ParserErrorCode.MULTIPLE_IMPLEMENTS_CLAUSES, implementsClause.keyword, []);
           parseImplementsClause();
         }
       } else {
         foundClause = false;
       }
     }
     if (withClause != null && extendsClause == null) {
       reportError5(ParserErrorCode.WITH_WITHOUT_EXTENDS, withClause.withKeyword, []);
     }
+    if (matches2(_NATIVE) && matches4(peek(), TokenType.STRING)) {
+      advance();
+      advance();
+    }
     Token leftBracket = null;
     List<ClassMember> members = null;
     Token rightBracket = null;
     if (matches5(TokenType.OPEN_CURLY_BRACKET)) {
       leftBracket = expect2(TokenType.OPEN_CURLY_BRACKET);
       members = parseClassMembers(className, ((leftBracket as BeginToken)).endToken != null);
       rightBracket = expect2(TokenType.CLOSE_CURLY_BRACKET);
     } else {
       leftBracket = createSyntheticToken2(TokenType.OPEN_CURLY_BRACKET);
       rightBracket = createSyntheticToken2(TokenType.CLOSE_CURLY_BRACKET);
@@ skipping 224 matching lines @@
   CommentReference parseCommentReference(String referenceSource, int sourceOffset) {
     if (referenceSource.length == 0) {
       return null;
     }
     try {
       List<bool> errorFound = [false];
       AnalysisErrorListener listener = new AnalysisErrorListener_12(errorFound);
       StringScanner scanner = new StringScanner(null, referenceSource, listener);
       scanner.setSourceStart(1, 1, sourceOffset);
       Token firstToken = scanner.tokenize();
-      if (!errorFound[0]) {
-        Token newKeyword = null;
-        if (matches3(firstToken, Keyword.NEW)) {
-          newKeyword = firstToken;
-          firstToken = firstToken.next;
+      if (errorFound[0]) {
+        return null;
+      }
+      Token newKeyword = null;
+      if (matches3(firstToken, Keyword.NEW)) {
+        newKeyword = firstToken;
+        firstToken = firstToken.next;
+      }
+      if (matchesIdentifier2(firstToken)) {
+        Token secondToken = firstToken.next;
+        Token thirdToken = secondToken.next;
+        Token nextToken;
+        Identifier identifier;
+        if (matches4(secondToken, TokenType.PERIOD) && matchesIdentifier2(thirdToken)) {
+          identifier = new PrefixedIdentifier.full(new SimpleIdentifier.full(firstToken), secondToken, new SimpleIdentifier.full(thirdToken));
+          nextToken = thirdToken.next;
+        } else {
+          identifier = new SimpleIdentifier.full(firstToken);
+          nextToken = firstToken.next;
         }
-        if (matchesIdentifier2(firstToken)) {
-          Token secondToken = firstToken.next;
-          Token thirdToken = secondToken.next;
-          Token nextToken;
-          Identifier identifier;
-          if (matches4(secondToken, TokenType.PERIOD) && matchesIdentifier2(thirdToken)) {
-            identifier = new PrefixedIdentifier.full(new SimpleIdentifier.full(firstToken), secondToken, new SimpleIdentifier.full(thirdToken));
-            nextToken = thirdToken.next;
-          } else {
-            identifier = new SimpleIdentifier.full(firstToken);
-            nextToken = firstToken.next;
-          }
-          if (nextToken.type != TokenType.EOF) {
-          }
-          return new CommentReference.full(newKeyword, identifier);
-        } else if (matches3(firstToken, Keyword.THIS) || matches3(firstToken, Keyword.NULL) || matches3(firstToken, Keyword.TRUE) || matches3(firstToken, Keyword.FALSE)) {
+        if (nextToken.type != TokenType.EOF) {
           return null;
-        } else if (matches4(firstToken, TokenType.STRING)) {
-        } else {
         }
+        return new CommentReference.full(newKeyword, identifier);
+      } else if (matches3(firstToken, Keyword.THIS) || matches3(firstToken, Keyword.NULL) || matches3(firstToken, Keyword.TRUE) || matches3(firstToken, Keyword.FALSE)) {
+        return null;
       }
     } catch (exception) {
     }
     return null;
   }
   /**
    * Parse all of the comment references occurring in the given array of documentation comments.
    * <pre>
    * commentReference ::=
-   * '[' 'new'? qualified ']' libraryReference?
+   * '[[' 'new'? qualified ']]' libraryReference?
    * libraryReference ::=
    * '(' stringLiteral ')'
    * </pre>
    * @param tokens the comment tokens representing the documentation comments to be parsed
    * @return the comment references that were parsed
    */
   List<CommentReference> parseCommentReferences(List<Token> tokens) {
     List<CommentReference> references = new List<CommentReference>();
     for (Token token in tokens) {
       String comment = token.lexeme;
+      int length2 = comment.length;
+      List<List<int>> codeBlockRanges = getCodeBlockRanges(comment);
       int leftIndex = comment.indexOf('[');
-      while (leftIndex >= 0) {
-        int rightIndex = comment.indexOf(']', leftIndex);
-        if (rightIndex >= 0) {
-          int firstChar = comment.codeUnitAt(leftIndex + 1);
-          if (firstChar != 0x27 && firstChar != 0x22 && firstChar != 0x3A) {
-            CommentReference reference = parseCommentReference(comment.substring(leftIndex + 1, rightIndex), token.offset + leftIndex + 1);
-            if (reference != null) {
-              references.add(reference);
+      while (leftIndex >= 0 && leftIndex + 1 < length2) {
+        List<int> range = findRange(codeBlockRanges, leftIndex);
+        if (range == null) {
+          int rightIndex = comment.indexOf(']', leftIndex);
+          if (rightIndex >= 0) {
+            int firstChar = comment.codeUnitAt(leftIndex + 1);
+            if (firstChar != 0x27 && firstChar != 0x22) {
+              if (isLinkText(comment, rightIndex)) {
+              } else {
+                CommentReference reference = parseCommentReference(comment.substring(leftIndex + 1, rightIndex), token.offset + leftIndex + 1);
+                if (reference != null) {
+                  references.add(reference);
+                }
+              }
             }
+          } else {
+            rightIndex = leftIndex + 1;
           }
+          leftIndex = comment.indexOf('[', rightIndex);
         } else {
-          rightIndex = leftIndex + 1;
+          leftIndex = comment.indexOf('[', range[1] + 1);
         }
-        leftIndex = comment.indexOf('[', rightIndex);
       }
     }
     return references;
   }
   /**
    * Parse a compilation unit.
    * <p>
    * Specified:
    * <pre>
    * compilationUnit ::=
@@ skipping 603 matching lines @@
    * formalParameterList ::=
    * '(' ')'
    * | '(' normalFormalParameters (',' optionalFormalParameters)? ')'
    * | '(' optionalFormalParameters ')'
    * normalFormalParameters ::=
    * normalFormalParameter (',' normalFormalParameter)
    * optionalFormalParameters ::=
    * optionalPositionalFormalParameters
    * | namedFormalParameters
    * optionalPositionalFormalParameters ::=
-   * '[' defaultFormalParameter (',' defaultFormalParameter)* ']'
+   * '[[' defaultFormalParameter (',' defaultFormalParameter)* ']]'
    * namedFormalParameters ::=
    * '{' defaultNamedParameter (',' defaultNamedParameter)* '}'
    * </pre>
    * @return the formal parameters that were parsed
    */
   FormalParameterList parseFormalParameterList() {
     Token leftParenthesis = expect2(TokenType.OPEN_PAREN);
     if (matches5(TokenType.CLOSE_PAREN)) {
       return new FormalParameterList.full(leftParenthesis, null, null, null, andAdvance);
     }
@@ skipping 200 matching lines @@
         Expression expression = parseExpression2();
         Token semicolon = null;
         if (!inExpression) {
           semicolon = expect2(TokenType.SEMICOLON);
         }
         return new ExpressionFunctionBody.full(functionDefinition, expression, semicolon);
       } else if (matches5(TokenType.OPEN_CURLY_BRACKET)) {
         return new BlockFunctionBody.full(parseBlock());
       } else if (matches2(_NATIVE)) {
         Token nativeToken = andAdvance;
-        StringLiteral stringLiteral = parseStringLiteral();
+        StringLiteral stringLiteral = null;
+        if (matches5(TokenType.STRING)) {
+          stringLiteral = parseStringLiteral();
+        }
         return new NativeFunctionBody.full(nativeToken, stringLiteral, expect2(TokenType.SEMICOLON));
       } else {
         reportError4(ParserErrorCode.MISSING_FUNCTION_BODY, []);
         return new EmptyFunctionBody.full(createSyntheticToken2(TokenType.SEMICOLON));
       }
     } finally {
       _inLoop = wasInLoop;
       _inSwitch = wasInSwitch;
     }
   }
@@ skipping 310 matching lines @@
       reportError5(missingNameError, missingNameToken, []);
     }
     List<SimpleIdentifier> components = new List<SimpleIdentifier>();
     components.add(createSyntheticIdentifier());
     return new LibraryIdentifier.full(components);
   }
   /**
    * Parse a list literal.
    * <pre>
    * listLiteral ::=
-   * 'const'? typeArguments? '[' (expressionList ','?)? ']'
+   * 'const'? typeArguments? '[[' (expressionList ','?)? ']]'
    * </pre>
    * @param modifier the 'const' modifier appearing before the literal, or {@code null} if there is
    * no modifier
    * @param typeArguments the type arguments appearing before the literal, or {@code null} if there
    * are no type arguments
    * @return the list literal that was parsed
    */
   ListLiteral parseListLiteral(Token modifier, TypeArgumentList typeArguments) {
     if (matches5(TokenType.INDEX)) {
       BeginToken leftBracket = new BeginToken(TokenType.OPEN_SQUARE_BRACKET, _currentToken.offset);
@@ skipping 1368 matching lines @@
     }
     return token;
   }
   /**
    * Report an error with the given error code and arguments.
    * @param errorCode the error code of the error to be reported
    * @param node the node specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportError(ParserErrorCode errorCode, ASTNode node, List<Object> arguments) {
-    _errorListener.onError(new AnalysisError.con2(_source, node.offset, node.length, errorCode, [arguments]));
+    _errorListener.onError(new AnalysisError.con2(_source, node.offset, node.length, errorCode, arguments));
   }
   /**
    * Report an error with the given error code and arguments.
    * @param errorCode the error code of the error to be reported
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportError4(ParserErrorCode errorCode, List<Object> arguments) {
     reportError5(errorCode, _currentToken, arguments);
   }
   /**
    * Report an error with the given error code and arguments.
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportError5(ParserErrorCode errorCode, Token token, List<Object> arguments) {
-    _errorListener.onError(new AnalysisError.con2(_source, token.offset, token.length, errorCode, [arguments]));
+    _errorListener.onError(new AnalysisError.con2(_source, token.offset, token.length, errorCode, arguments));
   }
   /**
    * Parse the 'final', 'const', 'var' or type preceding a variable declaration, starting at the
    * given token, without actually creating a type or changing the current token. Return the token
    * following the type that was parsed, or {@code null} if the given token is not the first token
    * in a valid type.
    * <pre>
    * finalConstVarOrType ::=
    * | 'final' type?
    * | 'const' type?
@@ skipping 36 matching lines @@
    * formalParameterList ::=
    * '(' ')'
    * | '(' normalFormalParameters (',' optionalFormalParameters)? ')'
    * | '(' optionalFormalParameters ')'
    * normalFormalParameters ::=
    * normalFormalParameter (',' normalFormalParameter)
    * optionalFormalParameters ::=
    * optionalPositionalFormalParameters
    * | namedFormalParameters
    * optionalPositionalFormalParameters ::=
-   * '[' defaultFormalParameter (',' defaultFormalParameter)* ']'
+   * '[[' defaultFormalParameter (',' defaultFormalParameter)* ']]'
    * namedFormalParameters ::=
    * '{' defaultNamedParameter (',' defaultNamedParameter)* '}'
    * </pre>
    * @param startToken the token at which parsing is to begin
    * @return the token following the formal parameter list that was parsed
    */
   Token skipFormalParameterList(Token startToken) {
     if (!matches4(startToken, TokenType.OPEN_PAREN)) {
       return null;
     }
@@ skipping 775 matching lines @@
   /**
    * The message template used to create the message to be displayed for this error.
    */
   String _message;
   /**
    * Initialize a newly created error code to have the given severity and message.
    * @param severity the severity of the error
    * @param message the message template used to create the message to be displayed for the error
    */
   ParserErrorCode.con1(String ___name, int ___ordinal, ErrorSeverity severity2, String message2) {
-    _jtd_constructor_301_impl(___name, ___ordinal, severity2, message2);
+    _jtd_constructor_302_impl(___name, ___ordinal, severity2, message2);
   }
-  _jtd_constructor_301_impl(String ___name, int ___ordinal, ErrorSeverity severity2, String message2) {
+  _jtd_constructor_302_impl(String ___name, int ___ordinal, ErrorSeverity severity2, String message2) {
     __name = ___name;
     __ordinal = ___ordinal;
     this._severity = severity2;
     this._message = message2;
   }
   /**
    * Initialize a newly created error code to have the given message and a severity of ERROR.
    * @param message the message template used to create the message to be displayed for the error
    */
   ParserErrorCode.con2(String ___name, int ___ordinal, String message) {
-    _jtd_constructor_302_impl(___name, ___ordinal, message);
+    _jtd_constructor_303_impl(___name, ___ordinal, message);
   }
-  _jtd_constructor_302_impl(String ___name, int ___ordinal, String message) {
-    _jtd_constructor_301_impl(___name, ___ordinal, ErrorSeverity.ERROR, message);
+  _jtd_constructor_303_impl(String ___name, int ___ordinal, String message) {
+    _jtd_constructor_302_impl(___name, ___ordinal, ErrorSeverity.ERROR, message);
   }
   ErrorSeverity get errorSeverity => _severity;
   String get message => _message;
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
   bool needsRecompilation() => true;
   int compareTo(ParserErrorCode other) => __ordinal - other.__ordinal;
   String toString() => __name;
 }
 /**
  * Instances of the class {link ToFormattedSourceVisitor} write a source representation of a visited
@@ skipping 871 matching lines @@
         for (int i = 0; i < size2; i++) {
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
       }
     }
   }
 }