Remove old instrumentation

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:math" as math;
 import 'dart:collection';
 
 import 'ast.dart';
 import 'engine.dart' show AnalysisEngine, AnalysisOptionsImpl;
 import 'error.dart';
-import 'instrumentation.dart';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'scanner.dart';
 import 'source.dart';
 import 'utilities_collection.dart' show TokenMap;
 import 'utilities_dart.dart';
 
 Map<String, MethodTrampoline> methodTable_Parser = <String, MethodTrampoline>{
   'parseCompilationUnit_1': new MethodTrampoline(
       1,
@@ skipping 2648 matching lines @@
     } else if (!_matchesIdentifier()) {
       //
       // Recover from an error.
       //
       if (_matchesKeyword(Keyword.CLASS)) {
         _reportErrorForCurrentToken(ParserErrorCode.CLASS_IN_CLASS);
         // TODO(brianwilkerson) We don't currently have any way to capture the
         // class that was parsed.
         _parseClassDeclaration(commentAndMetadata, null);
         return null;
-      } else if (_matchesKeyword(Keyword.ABSTRACT) && _tokenMatchesKeyword(_peek(), Keyword.CLASS)) {
+      } else if (_matchesKeyword(Keyword.ABSTRACT) &&
+          _tokenMatchesKeyword(_peek(), Keyword.CLASS)) {
         _reportErrorForToken(ParserErrorCode.CLASS_IN_CLASS, _peek());
         // TODO(brianwilkerson) We don't currently have any way to capture the
         // class that was parsed.
         _parseClassDeclaration(commentAndMetadata, getAndAdvance());
         return null;
       } else if (_isOperator(_currentToken)) {
         //
         // We appear to have found an operator declaration without the
         // 'operator' keyword.
         //
@@ skipping 237 matching lines @@
     return null;
   }
 
   /**
    * Parse a compilation unit, starting with the given token.
    *
    * @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
-    }
+    _currentToken = token;
+    return parseCompilationUnit2();
   }
 
   /**
    * Parse a compilation unit.
    *
    * Specified:
    *
    * <pre>
    * compilationUnit ::=
    *     scriptTag? directive* topLevelDeclaration*
@@ skipping 175 matching lines @@
 
   /**
    * 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
-    }
+    _currentToken = token;
+    return _parseDirectives();
   }
 
   /**
    * 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
-    }
+    _currentToken = token;
+    return parseExpression2();
   }
 
   /**
    * Parse an expression that might contain a cascade.
    *
    * <pre>
    * expression ::=
    *     assignableExpression assignmentOperator expression
    *   | conditionalExpression cascadeSection*
    *   | throwExpression
@@ skipping 533 matching lines @@
   }
 
   /**
    * 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
-    }
+    _currentToken = token;
+    return parseStatement2();
   }
 
   /**
    * Parse a statement.
    *
    * <pre>
    * statement ::=
    *     label* nonLabeledStatement
    * </pre>
    *
@@ skipping 12 matching lines @@
   }
 
   /**
    * 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
-    }
+    _currentToken = token;
+    return _parseStatementList();
   }
 
   /**
    * Parse a string literal.
    *
    * <pre>
    * stringLiteral ::=
    *     MULTI_LINE_STRING+
    *   | SINGLE_LINE_STRING+
    * </pre>
@@ skipping 1004 matching lines @@
    *   | 'super' assignableSelector
    *   | identifier
    * </pre>
    *
    * @param primaryAllowed `true` if the expression is allowed to be a primary without any
    *          assignable selector
    * @return the assignable expression that was parsed
    */
   Expression _parseAssignableExpression(bool primaryAllowed) {
     if (_matchesKeyword(Keyword.SUPER)) {
-      return _parseAssignableSelector(new SuperExpression(getAndAdvance()), false);
+      return _parseAssignableSelector(
+          new SuperExpression(getAndAdvance()),
+          false);
     }
     //
     // A primary expression can start with an identifier. We resolve the
     // ambiguity by determining whether the primary consists of anything other
     // than an identifier and/or is followed by an assignableSelector.
     //
     Expression expression = _parsePrimaryExpression();
     bool isOptional = primaryAllowed || expression is SimpleIdentifier;
     while (true) {
       while (_matches(TokenType.OPEN_PAREN)) {
@@ skipping 1572 matching lines @@
       Token awaitKeyword = null;
       if (_matchesString(_AWAIT)) {
         awaitKeyword = getAndAdvance();
       }
       Token forKeyword = _expectKeyword(Keyword.FOR);
       Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
       VariableDeclarationList variableList = null;
       Expression initialization = null;
       if (!_matches(TokenType.SEMICOLON)) {
         CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
-        if (_matchesIdentifier() && (_tokenMatchesKeyword(_peek(), Keyword.IN) || _tokenMatches(_peek(), TokenType.COLON))) {
+        if (_matchesIdentifier() &&
+            (_tokenMatchesKeyword(_peek(), Keyword.IN) ||
+                _tokenMatches(_peek(), TokenType.COLON))) {
           List<VariableDeclaration> variables = new List<VariableDeclaration>();
           SimpleIdentifier variableName = parseSimpleIdentifier();
           variables.add(
               new VariableDeclaration(null, null, variableName, null, null));
           variableList = new VariableDeclarationList(
               commentAndMetadata.comment,
               commentAndMetadata.metadata,
               null,
               null,
               variables);
@@ skipping 1492 matching lines @@
    *   | mapLiteral
    *   | listLiteral
    * </pre>
    *
    * @return the primary expression that was parsed
    */
   Expression _parsePrimaryExpression() {
     if (_matchesKeyword(Keyword.THIS)) {
       return new ThisExpression(getAndAdvance());
     } else if (_matchesKeyword(Keyword.SUPER)) {
-      return _parseAssignableSelector(new SuperExpression(getAndAdvance()), false);
+      return _parseAssignableSelector(
+          new SuperExpression(getAndAdvance()),
+          false);
     } else if (_matchesKeyword(Keyword.NULL)) {
       return new NullLiteral(getAndAdvance());
     } else if (_matchesKeyword(Keyword.FALSE)) {
       return new BooleanLiteral(getAndAdvance(), false);
     } else if (_matchesKeyword(Keyword.TRUE)) {
       return new BooleanLiteral(getAndAdvance(), true);
     } else if (_matches(TokenType.DOUBLE)) {
       Token token = getAndAdvance();
       double value = 0.0;
       try {
@@ skipping 698 matching lines @@
       Token operator = getAndAdvance();
       if (_matchesKeyword(Keyword.SUPER)) {
         if (_tokenMatches(_peek(), TokenType.OPEN_SQUARE_BRACKET) ||
             _tokenMatches(_peek(), TokenType.PERIOD)) {
           //     "prefixOperator unaryExpression"
           // --> "prefixOperator postfixExpression"
           // --> "prefixOperator primary                    selector*"
           // --> "prefixOperator 'super' assignableSelector selector*"
           return new PrefixExpression(operator, _parseUnaryExpression());
         }
-        return new PrefixExpression(operator, new SuperExpression(getAndAdvance()));
+        return new PrefixExpression(
+            operator,
+            new SuperExpression(getAndAdvance()));
       }
       return new PrefixExpression(operator, _parseUnaryExpression());
     } else if (_currentToken.type.isIncrementOperator) {
       Token operator = getAndAdvance();
       if (_matchesKeyword(Keyword.SUPER)) {
         if (_tokenMatches(_peek(), TokenType.OPEN_SQUARE_BRACKET) ||
             _tokenMatches(_peek(), TokenType.PERIOD)) {
           // --> "prefixOperator 'super' assignableSelector selector*"
           return new PrefixExpression(operator, _parseUnaryExpression());
         }
@@ skipping 3524 matching lines @@
    * Copy resolution data from one node to another.
    *
    * @param fromNode the node from which resolution information will be copied
    * @param toNode the node to which resolution information will be copied
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }