Address review comments missed in previous change.

runtime/vm/parser.cc

 // 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.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 1016 matching lines @@
     parameter.is_field_initializer = true;
   }
 
   // At this point, we must see an identifier for the parameter name.
   parameter.name_pos = token_index_;
   parameter.name = ExpectIdentifier("parameter name expected");
   if (parameter.is_field_initializer) {
     params->has_field_initializer = true;
   }
 
-  // Check that the formal parameter is not repeated.
+  // Check for duplicate formal parameters.
   const intptr_t num_existing_parameters =
       params->num_fixed_parameters + params->num_optional_parameters;
   for (intptr_t i = 0; i < num_existing_parameters; i++) {
     ParamDesc& existing_parameter = (*params->parameters)[i];
     if (existing_parameter.name->Equals(*parameter.name)) {
-      ErrorMsg(parameter.name_pos, "repeated formal parameter");
+      ErrorMsg(parameter.name_pos, "duplicate formal parameter '%s'",
+               parameter.name->ToCString());
     }
   }
 
   if (CurrentToken() == Token::kLPAREN) {
     // This parameter is probably a closure. If we saw the keyword 'var'
     // or 'final', a closure is not legal here and we ignore the
     // opening parens.
     if (!var_seen && !parameter.is_final) {
       // The parsed parameter type is actually the function result type.
       const AbstractType& result_type =
@@ skipping 2105 matching lines @@
     do {
       ConsumeToken();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
       type_parameter = TypeParameter::New(cls,
                                           index,
                                           type_parameter_name,
                                           token_index_);
-      // Check that the type parameter is not repeated.
+      // Check for duplicate type parameters.
       for (intptr_t i = 0; i < index; i++) {
         existing_type_parameter ^= type_parameters_array.At(i);
         existing_type_parameter_name = existing_type_parameter.Name();
         if (existing_type_parameter_name.Equals(type_parameter_name)) {
-          ErrorMsg("repeated type parameter");
+          ErrorMsg("duplicate type parameter '%s'",
+                   type_parameter_name.ToCString());
         }
       }
       ConsumeToken();
       bound = Type::DynamicType();
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
         // A bound may refer to the owner of the type parameter it applies to,
         // i.e. to the class or interface currently being parsed.
         // Postpone resolution in order to avoid resolving the class and its
         // type parameters, as they are not fully parsed yet.
@@ skipping 5319 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart