Version 0.8.10.4

dart/editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/parser/Parser.java

 /*
  * Copyright (c) 2012, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
  * 
  * http://www.eclipse.org/legal/epl-v10.html
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
@@ skipping 1916 matching lines @@
     return nextChar == '[';
   }
 
   /**
    * 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
    */
   private boolean isOperator(Token startToken) {
-    if (startToken.isOperator()) {
-      Token token = startToken.getNext();
-      while (token.isOperator()) {
-        token = token.getNext();
-      }
-      return matches(token, TokenType.OPEN_PAREN);
+    // Accept any operator here, even if it is not user definable.
+    if (!startToken.isOperator()) {
+      return false;
     }
-    return false;
+    // Token "=" means that it is actually field initializer.
+    if (startToken.getType() == TokenType.EQ) {
+      return false;
+    }
+    // Consume all operator tokens.
+    Token token = startToken.getNext();
+    while (token.isOperator()) {
+      token = token.getNext();
+    }
+    // Formal parameter list is expect now.
+    return matches(token, TokenType.OPEN_PAREN);
   }
 
   /**
    * Return {@code true} if the current token appears to be the beginning of a switch member.
    * 
    * @return {@code true} if the current token appears to be the beginning of a switch member
    */
   private boolean isSwitchMember() {
     Token token = currentToken;
     while (matches(token, TokenType.IDENTIFIER) && matches(token.getNext(), TokenType.COLON)) {
@@ skipping 3730 matching lines @@
    *   | 'var'
    *   | type
    * </pre>
    * 
    * @param startToken the token at which parsing is to begin
    * @return the token following the type that was parsed
    */
   private Token skipFinalConstVarOrType(Token startToken) {
     if (matches(startToken, Keyword.FINAL) || matches(startToken, Keyword.CONST)) {
       Token next = startToken.getNext();
-      if (matchesIdentifier(next.getNext()) || matches(next.getNext(), TokenType.LT)
-          || matches(next.getNext(), Keyword.THIS)) {
-        return skipTypeName(next);
+      if (matchesIdentifier(next)) {
+        Token next2 = next.getNext();
+        // "Type parameter" or "Type<" or "prefix.Type"
+        if (matchesIdentifier(next2) || matches(next2, TokenType.LT)
+            || matches(next2, TokenType.PERIOD)) {
+          return skipTypeName(next);
+        }
+        // "parameter"
+        return next;
       }
     } else if (matches(startToken, Keyword.VAR)) {
       return startToken.getNext();
     } else if (matchesIdentifier(startToken)) {
       Token next = startToken.getNext();
       if (matchesIdentifier(next)
           || matches(next, TokenType.LT)
           || matches(next, Keyword.THIS)
           || (matches(next, TokenType.PERIOD) && matchesIdentifier(next.getNext()) && (matchesIdentifier(next.getNext().getNext())
               || matches(next.getNext().getNext(), TokenType.LT) || matches(
@@ skipping 808 matching lines @@
       reportError(ParserErrorCode.EXTERNAL_TYPEDEF, modifiers.getExternalKeyword());
     }
     if (modifiers.getFinalKeyword() != null) {
       reportError(ParserErrorCode.FINAL_TYPEDEF, modifiers.getFinalKeyword());
     }
     if (modifiers.getVarKeyword() != null) {
       reportError(ParserErrorCode.VAR_TYPEDEF, modifiers.getVarKeyword());
     }
   }
 }