Canonicalize TypeArguments.

runtime/vm/class_finalizer.cc

 // Copyright (c) 2011, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 618 matching lines @@
   // However, subtyping constraints are checked below, even for a raw type.
   if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
     // TODO(regis): We need to store the token_index in each type.
     ReportError("wrong number of type arguments in type '%s'\n",
                 String::Handle(type.Name()).ToCString());
   }
   // The full type argument vector consists of the type arguments of the
   // super types of type_class, which may be initialized from the parsed
   // type arguments, followed by the parsed type arguments.
   if (num_type_arguments > 0) {
-    const TypeArguments& full_arguments = TypeArguments::Handle(
+    TypeArguments& full_arguments = TypeArguments::Handle(
         TypeArguments::New(num_type_arguments));
     // Copy the parsed type arguments at the correct offset in the full type
     // argument vector.
     const intptr_t offset = num_type_arguments - num_type_parameters;
     AbstractType& type = AbstractType::Handle(Type::DynamicType());
     for (intptr_t i = 0; i < num_type_parameters; i++) {
       // If no type parameters were provided, a raw type is desired, so we
       // create a vector of DynamicType.
       if (!arguments.IsNull()) {
         type = arguments.TypeAt(i);
       }
       full_arguments.SetTypeAt(offset + i, type);
     }
     if (type_class.IsSignatureClass()) {
       const Function& signature_fun =
           Function::Handle(type_class.signature_function());
       ASSERT(!signature_fun.is_static());
       const Class& signature_fun_owner = Class::Handle(signature_fun.owner());
       FinalizeTypeArguments(signature_fun_owner, full_arguments);
     } else {
       FinalizeTypeArguments(type_class, full_arguments);
     }
+    // FinalizeTypeArguments can modify 'full_arguments',
+    // canonicalize afterwards.
+    full_arguments ^= full_arguments.Canonicalize();
     parameterized_type.set_arguments(full_arguments);
 
     // Mark the type as finalized before finalizing the upper bounds, because
     // cycles via upper bounds are legal at compile time.
     parameterized_type.set_is_finalized();
 
     ResolveAndFinalizeUpperBounds(type_class);
     if (FLAG_enable_type_checks) {
       VerifyUpperBounds(type_class, full_arguments);
     }
@@ skipping 619 matching lines @@
   va_end(args);
   if (FLAG_warning_as_error) {
     Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
     UNREACHABLE();
   } else {
     OS::Print(message_buffer);
   }
 }
 
 }  // namespace dart