Use null type argument vector instead of vector of Dynamic for a generic raw

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 2891 matching lines @@
     unresolved_factory_class.set_factory_signature_class(factory_class);
     interface.set_factory_class(unresolved_factory_class);
     // If a type parameter list is included in the default factory clause (it
     // can be omitted), verify that it matches the list of type parameters of
     // the interface in number and names.
     if (factory_class.NumTypeParameters() > 0) {
       const TypeArguments& interface_type_parameters =
           TypeArguments::Handle(interface.type_parameters());
       const TypeArguments& factory_type_parameters =
           TypeArguments::Handle(factory_class.type_parameters());
-      if (!AbstractTypeArguments::AreEqual(interface_type_parameters,
-                                           factory_type_parameters)) {
+      if (!TypeArguments::AreIdenticalTypeParameters(interface_type_parameters,
+                                                     factory_type_parameters)) {
         const String& interface_name = String::Handle(interface.Name());
         ErrorMsg(factory_name.ident_pos,
                  "mismatch in number or names of type parameters between "
                  "interface '%s' and default factory class '%s'.\n",
                  interface_name.ToCString(),
                  factory_name.ident->ToCString());
       }
     }
   }
 
@@ skipping 80 matching lines @@
         GrowableObjectArray::Handle(GrowableObjectArray::New());
     intptr_t index = 0;
     AbstractType& type_parameter = TypeParameter::Handle();
     AbstractType& bound = Type::Handle();
     do {
       ConsumeToken();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
-      type_parameter = TypeParameter::New(index,
+      type_parameter = TypeParameter::New(cls,
+                                          index,
                                           type_parameter_name,
                                           token_index_);
       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 5233 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart