Implement stricter rule about self referencing typedefs (fix issue 13675).

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 2398 matching lines @@
   result.set_type_arguments_field_offset(Closure::type_arguments_offset());
   if (!signature_function.IsNull()) {
     result.PatchSignatureFunction(signature_function);
   }
   return result.raw();
 }
 
 
 void Class::PatchSignatureFunction(const Function& signature_function) const {
   ASSERT(!signature_function.IsNull());
+  set_signature_function(signature_function);
   const Class& owner_class = Class::Handle(signature_function.Owner());
   ASSERT(!owner_class.IsNull());
-  TypeArguments& type_parameters = TypeArguments::Handle();
-  // 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.
-  // In case of a function type alias, the function owner is the alias class
-  // instead of the enclosing class.
-  if (!signature_function.is_static() &&
-      (owner_class.NumTypeParameters() > 0) &&
-      !signature_function.HasInstantiatedSignature()) {
-    type_parameters = owner_class.type_parameters();
-  }
-  set_signature_function(signature_function);
-  set_type_parameters(type_parameters);
+  // A signature class extends class Instance and is either not parameterized or
+  // parameterized with exactly the same list of type parameters as the owner
+  // class of its function.
+  // In case of a function type alias, the function owner is the alias class,
+  // which is also the signature class. The signature class is therefore
+  // parameterized according to the alias class declaration, even if the
+  // function type is not generic.
+  // Otherwise, if the function is static or if its signature type is
+  // non-generic, i.e. it does not depend on any type parameter of the owner
+  // class, then the signature class is not parameterized, although the owner
+  // class may be.
   if (owner_class.raw() == raw()) {
     // This signature class is an alias, which cannot be the canonical
     // signature class for this signature function.
     ASSERT(!IsCanonicalSignatureClass());
-  } else if (signature_function.signature_class() == Object::null()) {
-    // Make this signature class the canonical signature class.
-    signature_function.set_signature_class(*this);
-    ASSERT(IsCanonicalSignatureClass());
+    // Do not modify the declared type parameters of the alias, even if unused.
+  } else {
+    // Copy the type parameters only for an instance function type that is not
+    // instantiated, i.e. that depends on the type parameters of the owner
+    // class.
+    // TODO(regis): Verify that it is not a problem for the copied type
+    // parameters to refer to the owner class rather than to the signature
+    // class. In other words, uninstantiated function types should only get
+    // instantiated by the owner class as instantiator and never by the
+    // signature class itself.
+    TypeArguments& type_parameters = TypeArguments::Handle();
+    if (!signature_function.is_static() &&
+        (owner_class.NumTypeParameters() > 0) &&
+        !signature_function.HasInstantiatedSignature()) {
+      type_parameters = owner_class.type_parameters();
+    }
+    set_type_parameters(type_parameters);
+    if (signature_function.signature_class() == Object::null()) {
+      // Make this signature class the canonical signature class.
+      signature_function.set_signature_class(*this);
+      ASSERT(IsCanonicalSignatureClass());
+    }
   }
   set_is_prefinalized();
 }
 
 
 RawClass* Class::NewNativeWrapper(const Library& library,
                                   const String& name,
                                   int field_count) {
   Class& cls = Class::Handle(library.LookupClass(name));
   if (cls.IsNull()) {
@@ skipping 13132 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart