Write end-of-block comments.

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

 // Copyright (c) 2014, 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.
 
 // 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';
@@ skipping 413 matching lines @@
   @override
   AstNode visitExportDirective(ExportDirective node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.uri)) {
       return _parser.parseStringLiteral();
     } else if (node.combinators.contains(_oldNode)) {
       throw new IncrementalParseException();
+      //return parser.parseCombinator();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitExpressionFunctionBody(ExpressionFunctionBody node) {
     if (identical(_oldNode, node.expression)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
@@ skipping 40 matching lines @@
     } else if (identical(_oldNode, node.parameters)) {
       return _parser.parseFormalParameterList();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitForEachStatement(ForEachStatement node) {
     if (identical(_oldNode, node.loopVariable)) {
       throw new InsufficientContextException();
+      //return parser.parseDeclaredIdentifier();
     } else if (identical(_oldNode, node.identifier)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.body)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitFormalParameterList(FormalParameterList node) {
@@ skipping 128 matching lines @@
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.uri)) {
       return _parser.parseStringLiteral();
     } else if (identical(_oldNode, node.prefix)) {
       return _parser.parseSimpleIdentifier();
     } else if (node.combinators.contains(_oldNode)) {
       throw new IncrementalParseException();
+      //return parser.parseCombinator();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitIndexExpression(IndexExpression node) {
     if (identical(_oldNode, node.target)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.index)) {
       return _parser.parseExpression2();
@@ skipping 12 matching lines @@
   }
 
   @override
   AstNode visitIntegerLiteral(IntegerLiteral node) => _notAChild(node);
 
   @override
   AstNode visitInterpolationExpression(InterpolationExpression node) {
     if (identical(_oldNode, node.expression)) {
       if (node.leftBracket == null) {
         throw new InsufficientContextException();
+        //return parser.parseThisOrSimpleIdentifier();
       }
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitInterpolationString(InterpolationString node) {
     throw new InsufficientContextException();
   }
@@ skipping 77 matching lines @@
   }
 
   @override
   AstNode visitMethodDeclaration(MethodDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.returnType)) {
       throw new InsufficientContextException();
+      //return parser.parseTypeName();
+      //return parser.parseReturnType();
     } else if (identical(_oldNode, node.name)) {
       if (node.operatorKeyword != null) {
         throw new InsufficientContextException();
       }
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.body)) {
       //return parser.parseFunctionBody();
       throw new InsufficientContextException();
     }
     return _notAChild(node);
@@ skipping 777 matching lines @@
    * @param token the first token of the compilation unit
    * @return the compilation unit that was parsed
    */
   CompilationUnit parseCompilationUnit(Token token) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.Parser.parseCompilationUnit");
     try {
       _currentToken = token;
       return parseCompilationUnit2();
     } finally {
       instrumentation.log2(2);
+      //Record if >= 2ms
     }
   }
 
   /**
    * Parse the script tag and directives in a compilation unit, starting with the given token, until
    * the first non-directive is encountered. The remainder of the compilation unit will not be
    * parsed. Specifically, if there are directives later in the file, they will not be parsed.
    *
    * @param token the first token of the compilation unit
    * @return the compilation unit that was parsed
    */
   CompilationUnit parseDirectives(Token token) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.Parser.parseDirectives");
     try {
       _currentToken = token;
       return _parseDirectives();
     } finally {
       instrumentation.log2(2);
+      //Record if >= 2ms
     }
   }
 
   /**
    * Parse an expression, starting with the given token.
    *
    * @param token the first token of the expression
    * @return the expression that was parsed, or `null` if the tokens do not represent a
    *         recognizable expression
    */
   Expression parseExpression(Token token) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.Parser.parseExpression");
     try {
       _currentToken = token;
       return parseExpression2();
     } finally {
       instrumentation.log2(2);
+      //Record if >= 2ms
     }
   }
 
   /**
    * Parse a statement, starting with the given token.
    *
    * @param token the first token of the statement
    * @return the statement that was parsed, or `null` if the tokens do not represent a
    *         recognizable statement
    */
   Statement parseStatement(Token token) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.Parser.parseStatement");
     try {
       _currentToken = token;
       return parseStatement2();
     } finally {
       instrumentation.log2(2);
+      //Record if >= 2ms
     }
   }
 
   /**
    * Parse a sequence of statements, starting with the given token.
    *
    * @param token the first token of the sequence of statement
    * @return the statements that were parsed, or `null` if the tokens do not represent a
    *         recognizable sequence of statements
    */
   List<Statement> parseStatements(Token token) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.Parser.parseStatements");
     try {
       _currentToken = token;
       return _parseStatementList();
     } finally {
       instrumentation.log2(2);
+      //Record if >= 2ms
     }
   }
 
   /**
    * Set whether the parser is to parse the async support.
    *
    * @param parseAsync `true` if the parser is to parse the async support
    */
   void set parseAsync(bool parseAsync) {
     this._parseAsync = parseAsync;
@@ skipping 2252 matching lines @@
         }
       } else if (_matchesKeyword(Keyword.WITH)) {
         if (withClause == null) {
           withClause = parseWithClause();
           if (implementsClause != null) {
             _reportErrorForToken(ParserErrorCode.IMPLEMENTS_BEFORE_WITH, implementsClause.keyword, []);
           }
         } else {
           _reportErrorForToken(ParserErrorCode.MULTIPLE_WITH_CLAUSES, withClause.withKeyword, []);
           parseWithClause();
+          // TODO(brianwilkerson) Should we merge the list of applied mixins into a single list?
         }
       } else if (_matchesKeyword(Keyword.IMPLEMENTS)) {
         if (implementsClause == null) {
           implementsClause = parseImplementsClause();
         } else {
           _reportErrorForToken(ParserErrorCode.MULTIPLE_IMPLEMENTS_CLAUSES, implementsClause.keyword, []);
           parseImplementsClause();
+          // TODO(brianwilkerson) Should we merge the list of implemented classes into a single list?
         }
       } else {
         foundClause = false;
       }
     }
     if (withClause != null && extendsClause == null) {
       _reportErrorForToken(ParserErrorCode.WITH_WITHOUT_EXTENDS, withClause.withKeyword, []);
     }
     //
     // Look for and skip over the extra-lingual 'native' specification.
@@ skipping 208 matching lines @@
         }
         return new CommentReference(newKeyword, identifier);
       } else if (_tokenMatchesKeyword(firstToken, Keyword.THIS) || _tokenMatchesKeyword(firstToken, Keyword.NULL) || _tokenMatchesKeyword(firstToken, Keyword.TRUE) || _tokenMatchesKeyword(firstToken, Keyword.FALSE)) {
         // TODO(brianwilkerson) If we want to support this we will need to extend the definition
         // of CommentReference to take an expression rather than an identifier. For now we just
         // ignore it to reduce the number of errors produced, but that's probably not a valid
         // long term approach.
         return null;
       }
     } catch (exception) {
+      // Ignored because we assume that it wasn't a real comment reference.
     }
     return null;
   }
 
   /**
    * Parse all of the comment references occurring in the given array of documentation comments.
    *
    * <pre>
    * commentReference ::=
    *     '[' 'new'? qualified ']' libraryReference?
@@ skipping 14 matching lines @@
       int leftIndex = comment.indexOf('[');
       while (leftIndex >= 0 && leftIndex + 1 < length) {
         List<int> range = _findRange(codeBlockRanges, leftIndex);
         if (range == null) {
           int nameOffset = token.offset + leftIndex + 1;
           int rightIndex = JavaString.indexOf(comment, ']', leftIndex);
           if (rightIndex >= 0) {
             int firstChar = comment.codeUnitAt(leftIndex + 1);
             if (firstChar != 0x27 && firstChar != 0x22) {
               if (_isLinkText(comment, rightIndex)) {
+                // TODO(brianwilkerson) Handle the case where there's a library URI in the link text.
               } else {
                 CommentReference reference = _parseCommentReference(comment.substring(leftIndex + 1, rightIndex), nameOffset);
                 if (reference != null) {
                   references.add(reference);
                 }
               }
             }
           } else {
             // terminating ']' is not typed yet
             int charAfterLeft = comment.codeUnitAt(leftIndex + 1);
@@ skipping 686 matching lines @@
             VariableDeclaration variable = variables[0];
             if (variable.initializer != null) {
               _reportErrorForCurrentToken(ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH, []);
             }
             Token keyword = variableList.keyword;
             TypeName type = variableList.type;
             if (keyword != null || type != null) {
               loopVariable = new DeclaredIdentifier(commentAndMetadata.comment, commentAndMetadata.metadata, keyword, type, variable.name);
             } else {
               if (!commentAndMetadata.metadata.isEmpty) {
+                // TODO(jwren) metadata isn't allowed before the identifier in "identifier in expression",
+                // add warning if commentAndMetadata has content
               }
               identifier = variable.name;
             }
           }
           Token inKeyword = _expectKeyword(Keyword.IN);
           Expression iterator = parseExpression2();
           Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
           Statement body = parseStatement2();
           if (loopVariable == null) {
             return new ForEachStatement.con2(awaitKeyword, forKeyword, leftParenthesis, identifier, inKeyword, iterator, rightParenthesis, body);
@@ skipping 1098 matching lines @@
     } else if (_matchesKeyword(Keyword.FALSE)) {
       return new BooleanLiteral(andAdvance, false);
     } else if (_matchesKeyword(Keyword.TRUE)) {
       return new BooleanLiteral(andAdvance, true);
     } else if (_matches(TokenType.DOUBLE)) {
       Token token = andAdvance;
       double value = 0.0;
       try {
         value = double.parse(token.lexeme);
       } on FormatException catch (exception) {
+        // The invalid format should have been reported by the scanner.
       }
       return new DoubleLiteral(token, value);
     } else if (_matches(TokenType.HEXADECIMAL)) {
       Token token = andAdvance;
       int value = null;
       try {
         value = int.parse(token.lexeme.substring(2), radix: 16);
       } on FormatException catch (exception) {
+        // The invalid format should have been reported by the scanner.
       }
       return new IntegerLiteral(token, value);
     } else if (_matches(TokenType.INT)) {
       Token token = andAdvance;
       int value = null;
       try {
         value = int.parse(token.lexeme);
       } on FormatException catch (exception) {
+        // The invalid format should have been reported by the scanner.
       }
       return new IntegerLiteral(token, value);
     } else if (_matches(TokenType.STRING)) {
       return parseStringLiteral();
     } else if (_matches(TokenType.OPEN_CURLY_BRACKET)) {
       return _parseMapLiteral(null, null);
     } else if (_matches(TokenType.OPEN_SQUARE_BRACKET) || _matches(TokenType.INDEX)) {
       return _parseListLiteral(null, null);
     } else if (_matchesIdentifier()) {
       // TODO(brianwilkerson) The code below was an attempt to recover from an error case, but it
@@ skipping 1334 matching lines @@
       // Illegal escape sequence: no char after escape
       // This cannot actually happen because it would require the escape character to be the last
       // character in the string, but if it were it would escape the closing quote, leaving the
       // string unclosed.
       // reportError(ParserErrorCode.MISSING_CHAR_IN_ESCAPE_SEQUENCE);
       return length;
     }
     currentChar = lexeme.codeUnitAt(currentIndex);
     if (currentChar == 0x6E) {
       builder.appendChar(0xA);
+      // newline
     } else if (currentChar == 0x72) {
       builder.appendChar(0xD);
+      // carriage return
     } else if (currentChar == 0x66) {
       builder.appendChar(0xC);
+      // form feed
     } else if (currentChar == 0x62) {
       builder.appendChar(0x8);
+      // backspace
     } else if (currentChar == 0x74) {
       builder.appendChar(0x9);
+      // tab
     } else if (currentChar == 0x76) {
       builder.appendChar(0xB);
+      // vertical tab
     } else if (currentChar == 0x78) {
       if (currentIndex + 2 >= length) {
         // Illegal escape sequence: not enough hex digits
         _reportErrorForCurrentToken(ParserErrorCode.INVALID_HEX_ESCAPE, []);
         return length;
       }
       int firstDigit = lexeme.codeUnitAt(currentIndex + 1);
       int secondDigit = lexeme.codeUnitAt(currentIndex + 2);
       if (!_isHexDigit(firstDigit) || !_isHexDigit(secondDigit)) {
         // Illegal escape sequence: invalid hex digit
@@ skipping 2100 matching lines @@
         return trampoline(target, arguments[0], arguments[1]);
       case 3:
         return trampoline(target, arguments[0], arguments[1], arguments[2]);
       case 4:
         return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
       default:
         throw new IllegalArgumentException("Not implemented for > 4 arguments");
     }
   }
 }