Unify parsing of constructor references.

dart/lib/compiler/implementation/scanner/parser.dart

 // Copyright (c) 2012, 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.
 
 part of scanner;
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list (aka a token stream).
  *
@@ skipping 959 matching lines @@
     Token start = token;
     if (identical(token.stringValue, 'external')) token = token.next;
     Token constKeyword = null;
     if (optional('const', token)) {
       constKeyword = token;
       token = token.next;
     }
     Token factoryKeyword = token;
     listener.beginFactoryMethod(factoryKeyword);
     token = token.next; // Skip 'factory'.
-    token = parseIdentifier(token);
-    token = parseQualifiedRestOpt(token);
-    token = parseTypeVariablesOpt(token);
-    Token period = null;
-    if (optional('.', token)) {
-      period = token;
-      token = parseIdentifier(token.next);
-    }
+    token = parseConstructorReference(token);
     token = parseFormalParameters(token);
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
       token = parseFunctionBody(token, false);
     }
-    listener.endFactoryMethod(start, period, token);
+    listener.endFactoryMethod(start, token);
     return token.next;
   }
 
   Token parseOperatorName(Token token) {
     assert(optional('operator', token));
     if (isUserDefinableOperator(token.next.stringValue)) {
       Token operator = token;
       token = token.next;
       listener.handleOperatorName(operator, token);
       return token.next;
@@ skipping 640 matching lines @@
     if (optional('(', token)) {
       BeginGroupToken begin = token;
       String afterParens = begin.endGroup.next.stringValue;
       if (identical(afterParens, '{') || identical(afterParens, '=>')) {
         return true;
       }
     }
     return false;
   }
 
-  Token parseNewExpression(Token token) {
-    Token newKeyword = token;
-    token = expect('new', token);
-    token = parseType(token);
-    bool named = false;
-    if (optional('.', token)) {
-      named = true;
-      token = parseIdentifier(token.next);
-    }
+  Token parseRequiredArguments(Token token) {
     if (optional('(', token)) {
       token = parseArguments(token);
     } else {
       listener.handleNoArguments(token);
       token = listener.unexpected(token);
     }
-    listener.handleNewExpression(newKeyword, named);
     return token;
   }
 
+  Token parseNewExpression(Token token) {
+    Token newKeyword = token;
+    token = expect('new', token);
+    token = parseConstructorReference(token);
+    token = parseRequiredArguments(token);
+    listener.handleNewExpression(newKeyword);
+    return token;
+  }
+
   Token parseConstExpression(Token token) {
     Token constKeyword = token;
     token = expect('const', token);
     final String value = token.stringValue;
     if ((identical(value, '<')) ||
         (identical(value, '[')) ||
         (identical(value, '[]')) ||
         (identical(value, '{'))) {
       return parseLiteralListOrMap(constKeyword);
     }
-    token = parseType(token);
-    bool named = false;
-    if (optional('.', token)) {
-      named = true;
-      token = parseIdentifier(token.next);
-    }
-    expect('(', token);
-    token = parseArguments(token);
-    listener.handleConstExpression(constKeyword, named);
+    token = parseConstructorReference(token);
+    token = parseRequiredArguments(token);
+    listener.handleConstExpression(constKeyword);
     return token;
   }
 
   Token parseLiteralInt(Token token) {
     listener.handleLiteralInt(token);
     return token.next;
   }
 
   Token parseLiteralDouble(Token token) {
     listener.handleLiteralDouble(token);
@@ skipping 459 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }