Allow the optimizer to canonicalize instantiated function types (issue 11775).

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 1426 matching lines @@
 
 RawType* Class::SignatureType() const {
   ASSERT(IsSignatureClass());
   const Function& function = Function::Handle(signature_function());
   ASSERT(!function.IsNull());
   if (function.signature_class() != raw()) {
     // This class is a function type alias. Return the canonical signature type.
     const Class& canonical_class = Class::Handle(function.signature_class());
     return canonical_class.SignatureType();
   }
-  // Return the first canonical signature type if already computed.
+  // Return the first canonical signature type if already computed at class
+  // finalization time. The optimizer may canonicalize instantiated function
+  // types of the same signature class, but these will be added after the
+  // uninstantiated signature class at index 0.
   const Array& signature_types = Array::Handle(canonical_types());
   // The canonical_types array is initialized to the empty array.
   ASSERT(!signature_types.IsNull());
   if (signature_types.Length() > 0) {
-    // At most one signature type per signature class.
-    ASSERT((signature_types.Length() == 1) ||
-           ((signature_types.Length() == 2) &&
-            (signature_types.At(1) == Type::null())));
     Type& signature_type = Type::Handle();
     signature_type ^= signature_types.At(0);
     ASSERT(!signature_type.IsNull());
     return signature_type.raw();
   }
   // A signature class extends class Instance and is parameterized in the same
   // way as the owner class of its non-static signature function.
   // It is not type parameterized if its signature function is static.
   // See Class::NewSignatureClass() for the setup of its type parameters.
   // During type finalization, the type arguments of the super class of the
@@ skipping 9083 matching lines @@
   // list of canonicalized types.
   // TODO(asiva): Try to re-factor this lookup code to make sharing
   // easy between the 4 versions of this loop.
   Type& type = Type::Handle();
   intptr_t index = 0;
   while (index < canonical_types_len) {
     type ^= canonical_types.At(index);
     if (type.IsNull()) {
       break;
     }
-    if (!type.IsFinalized()) {
-      ASSERT((index == 0) && cls.IsSignatureClass());
-      index++;
-      continue;
-    }
+    ASSERT(type.IsFinalized());
     if (this->Equals(type)) {
       return type.raw();
     }
     index++;
   }
   // Canonicalize the type arguments.
   AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(arguments());
   type_args = type_args.Canonicalize();
   set_arguments(type_args);
   // The type needs to be added to the list. Grow the list if it is full.
   if (index == canonical_types_len) {
     const intptr_t kLengthIncrement = 2;  // Raw and parameterized.
     const intptr_t new_length = canonical_types.Length() + kLengthIncrement;
     const Array& new_canonical_types =
         Array::Handle(Array::Grow(canonical_types, new_length, Heap::kOld));
     cls.set_canonical_types(new_canonical_types);
     new_canonical_types.SetAt(index, *this);
   } else {
     canonical_types.SetAt(index, *this);
   }
+#ifdef DEBUG
+  if ((index == 0) && cls.IsCanonicalSignatureClass()) {
+    // Verify that the first canonical type is the signature type by checking
+    // that the type argument vector of the canonical type ends with the
+    // uninstantiated type parameters of the signature class.
+    // The signature type is finalized during class finalization, before the
+    // optimizer may canonicalize instantiated function types of the same
+    // signature class.
+    // Although the signature class extends class Instance, the type arguments
+    // of the super class of the owner class of its signature function will be
+    // prepended to the type argument vector during class finalization.
+    const TypeArguments& type_params =
+      TypeArguments::Handle(cls.type_parameters());
+    const intptr_t num_type_params = cls.NumTypeParameters();
+    const intptr_t num_type_args = cls.NumTypeArguments();
+    TypeParameter& type_arg = TypeParameter::Handle();
+    TypeParameter& type_param = TypeParameter::Handle();
+    for (intptr_t i = 0; i < num_type_params; i++) {
+      type_arg ^= type_args.TypeAt(num_type_args - num_type_params + i);
+      type_param ^= type_params.TypeAt(i);
+      ASSERT(type_arg.Equals(type_param));
+    }
+  }
+#endif
   ASSERT(IsOld());
   SetCanonical();
   return this->raw();
 }
 
 
 intptr_t Type::Hash() const {
   ASSERT(IsFinalized());
   uword result = 1;
   if (IsMalformed()) return result;
@@ skipping 3617 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart