Set type argument vector at compile time in type of closure parameters; this

runtime/vm/object.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/object.h"
 
 #include "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 678 matching lines @@
 RawString* Class::Name() const {
   if (raw_ptr()->name_ != String::null()) {
     return raw_ptr()->name_;
   }
   ASSERT(class_class() != null_);  // Or GetSingletonClassIndex will not work.
   intptr_t index = GetSingletonClassIndex(raw());
   return String::NewSymbol(GetSingletonClassName(index));
 }
 
 
+RawType* Class::SignatureType() const {
+  // Return the cached signature type if any.
+  if (raw_ptr()->signature_type_ != Type::null()) {
+    return raw_ptr()->signature_type_;
+  }
+  ASSERT(IsSignatureClass());
+  TypeArguments& signature_type_arguments = TypeArguments::Handle();
+  const intptr_t num_type_params = NumTypeParameters();
+  // If the signature class extends a parameterized class, the type arguments of
+  // the super class will be prepended to the type argument vector during type
+  // finalization. We only need to provide the type parameters of the signature
+  // class here.
+  if (num_type_params > 0) {
+    const Array& type_params = Array::Handle(type_parameters());
+    signature_type_arguments = TypeArguments::NewTypeArray(num_type_params);
+    String& type_param_name = String::Handle();
+    Type& type_param = Type::Handle();
+    for (int i = 0; i < num_type_params; i++) {
+      type_param_name ^= type_params.At(i);
+      type_param = Type::NewTypeParameter(i, type_param_name);
+      signature_type_arguments.SetTypeAt(i, type_param);
+    }
+  }
+  const ParameterizedType& signature_type = ParameterizedType::Handle(
+      ParameterizedType::New(*this, signature_type_arguments));
+
+  // Cache and return the still unfinalized signature type.
+  ASSERT(!signature_type.IsFinalized());
+  set_signature_type(signature_type);
+  return signature_type.raw();
+}
+
+
 template <class FakeObject>
 RawClass* Class::New() {
   Class& class_class = Class::Handle(Object::class_class());
   Class& result = Class::Handle();
   {
     RawObject* raw = Object::Allocate(class_class,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     if (class_class.IsNull()) {
@@ skipping 50 matching lines @@
   StorePointer(&raw_ptr()->functions_, value.raw());
 }
 
 
 void Class::set_signature_function(const Function& value) const {
   ASSERT(value.IsClosureFunction() || value.IsSignatureFunction());
   StorePointer(&raw_ptr()->signature_function_, value.raw());
 }
 
 
+void Class::set_signature_type(const Type& value) const {
+  StorePointer(&raw_ptr()->signature_type_, value.raw());
+}
+
+
 void Class::set_class_state(int8_t state) const {
   ASSERT(state == RawClass::kAllocated ||
          state == RawClass::kPreFinalized ||
          state == RawClass::kFinalized);
   raw_ptr()->class_state_ = state;
 }
 
 
 void Class::set_library(const Library& value) const {
   StorePointer(&raw_ptr()->library_, value.raw());
@@ skipping 16 matching lines @@
     return 0;
   } else {
     return type_params.Length();
   }
 }
 
 
 intptr_t Class::NumTypeArguments() const {
   intptr_t num_type_args = NumTypeParameters();
   const Class& superclass = Class::Handle(SuperClass());
-  if (!superclass.IsNull()) {
+  // Object is its own super class during bootstrap.
+  if (!superclass.IsNull() && (superclass.raw() != raw())) {
     num_type_args += superclass.NumTypeArguments();
   }
   return num_type_args;
 }
 
 
 RawClass* Class::SuperClass() const {
   const Type& sup_type = Type::Handle(super_type());
   if (sup_type.IsNull()) {
     return Class::null();
@@ skipping 154 matching lines @@
   return result.raw();
 }
 
 
 RawClass* Class::NewSignatureClass(const String& name,
                                    const Function& signature_function,
                                    const Script& script,
                                    intptr_t token_index) {
   ASSERT(!signature_function.IsNull());
   Type& super_type = Type::Handle(Type::ObjectType());
+  const Class& owner_class = Class::Handle(signature_function.owner());
+  ASSERT(!owner_class.IsNull());
   Array& type_parameters = Array::Handle();
   TypeArray& type_parameter_extends = TypeArray::Handle();
   if (!signature_function.is_static()) {
-    const Class& owner_class = Class::Handle(signature_function.owner());
-    ASSERT(!owner_class.IsNull());
-    ASSERT(!owner_class.is_interface());
-    if (owner_class.IsParameterized()) {
+    if (owner_class.IsParameterized() &&
+        !signature_function.HasInstantiatedSignature()) {
       // Share the function owner super class as the super class of the
       // signature class, so that the type argument vector of the closure at
       // run time  matches the type argument vector of the closure instantiator.
       type_parameters = owner_class.type_parameters();
       type_parameter_extends = owner_class.type_parameter_extends();
-      super_type = owner_class.super_type();
+      if (!owner_class.is_interface()) {
+        super_type = owner_class.super_type();
+      }
     }
   }
   Class& result = Class::Handle(New<Closure>(name, script));
   result.set_super_type(super_type);
   result.set_signature_function(signature_function);
   result.set_type_parameters(type_parameters);
   result.set_type_parameter_extends(type_parameter_extends);
   result.SetFields(Array::Handle(Array::Empty()));
   result.SetFunctions(Array::Handle(Array::Empty()));
   // Implements interface Function.
@@ skipping 576 matching lines @@
 }
 
 
 bool Type::IsFinalized() const {
   // Type is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
+bool Type::IsBeingFinalized() const {
+  // Type is an abstract class.
+  UNREACHABLE();
+  return false;
+}
+
+
 RawType* Type::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   // Type is an abstract class.
   UNREACHABLE();
   return Type::null();
 }
 
 
 RawString* Type::Name() const {
   const TypeArguments& args = TypeArguments::Handle(arguments());
   const intptr_t num_args = args.IsNull() ? 0 : args.Length();
   String& class_name = String::Handle();
   intptr_t first_type_param_index;
   intptr_t num_type_params;  // Number of type parameters to print.
   if (HasResolvedTypeClass()) {
     const Class& cls = Class::Handle(type_class());
     class_name = cls.Name();
     num_type_params = cls.NumTypeParameters();  // Do not print the full vector.
     if (num_type_params > num_args) {
-      ASSERT(!IsFinalized());
+      ASSERT(num_args == 0);  // Type is raw.
       // We fill up with "var".
       first_type_param_index = 0;
     } else {
       first_type_param_index = num_args - num_type_params;
     }
+    if (cls.IsSignatureClass()) {
+      const Function& signature_function = Function::Handle(
+          cls.signature_function());
+      // We may be reporting an error about an illformed function type. In that
+      // case, avoid instantiating the signature, since it may lead to cycles.
+      if (IsBeingFinalized()) {
+        return class_name.raw();
+      }
+      return signature_function.InstantiatedSignatureFrom(
+          args, first_type_param_index);
+    }
   } else {
     const UnresolvedClass& type = UnresolvedClass::Handle(unresolved_class());
     class_name = type.Name();
     num_type_params = num_args;
     first_type_param_index = 0;
   }
   String& type_name = String::Handle();
   if (num_type_params == 0) {
     type_name = class_name.raw();
   } else {
@@ skipping 13 matching lines @@
       type_name = type.Name();
       strings.SetAt(s++, type_name);
       if (i < num_type_params - 1) {
         strings.SetAt(s++, kCommaSpace);
       }
     }
     strings.SetAt(s++, String::Handle(String::NewSymbol(">")));
     ASSERT(s == num_strings);
     type_name = String::ConcatAll(strings);
   }
-  // The name is only used for naming function types and for debugging purposes.
+  // The name is only used for type checking and debugging purposes.
   // Unless profiling data shows otherwise, it is not worth caching the name in
   // the type.
   return String::NewSymbol(type_name);
 }
 
 
 intptr_t Type::Index() const {
   // Type is an abstract class.
   UNREACHABLE();
   return -1;
@@ skipping 176 matching lines @@
 }
 
 
 void ParameterizedType::set_is_finalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawParameterizedType::kFinalized);
 }
 
 
 void ParameterizedType::set_is_being_finalized() const {
-  ASSERT(!IsFinalized() && !is_being_finalized());
+  ASSERT(!IsFinalized() && !IsBeingFinalized());
   set_type_state(RawParameterizedType::kBeingFinalized);
 }
 
 
 bool ParameterizedType::IsResolved() const {
   if (!HasResolvedTypeClass()) {
     return false;
   }
   const TypeArguments& args = TypeArguments::Handle(arguments());
   return args.IsNull() || args.IsResolved();
@@ skipping 38 matching lines @@
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   ASSERT(IsFinalized());
   ASSERT(!IsInstantiated());
   TypeArguments& type_arguments = TypeArguments::Handle();
   if (!instantiator_type_arguments.IsNull()) {
     type_arguments = arguments();
     type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments,
                                                     offset);
   }
+  const Class& cls = Class::Handle(type_class());
   ParameterizedType& instantiated_type = ParameterizedType::Handle(
-      ParameterizedType::New(Object::Handle(type_class()), type_arguments));
+      ParameterizedType::New(cls, type_arguments));
+  ASSERT(type_arguments.IsNull() ||
+         (type_arguments.Length() == cls.NumTypeArguments()));
   instantiated_type.set_is_finalized();
   return instantiated_type.raw();
 }
 
 
 void ParameterizedType::set_type_class(const Object& value) const {
   ASSERT(!value.IsNull() && (value.IsClass() || value.IsUnresolvedClass()));
   StorePointer(&raw_ptr()->type_class_, value.raw());
 }
 
@@ skipping 987 matching lines @@
 template<typename T>
 static RawArray* NewArray(const GrowableArray<T*>& objs) {
   Array& a = Array::Handle(Array::New(objs.length(), Heap::kOld));
   for (int i = 0; i < objs.length(); i++) {
     a.SetAt(i, *objs[i]);
   }
   return a.raw();
 }
 
 
-// Build a string of the form '<T>(A, [b: B, c: C]) => R)' representing the
-// signature of the given function.
-RawString* Function::Signature() const {
+RawString* Function::BuildSignature(bool instantiate,
+                                    const TypeArguments& instantiator,
+                                    intptr_t offset) const {
   GrowableArray<const String*> pieces;
-  const String& kSpaceExtendsSpace =
-      String::Handle(String::NewSymbol(" extends "));
   const String& kCommaSpace = String::Handle(String::NewSymbol(", "));
   const String& kColonSpace = String::Handle(String::NewSymbol(": "));
-  const String& kLAngleBracket = String::Handle(String::NewSymbol("<"));
-  const String& kRAngleBracket = String::Handle(String::NewSymbol(">"));
   const String& kLParen = String::Handle(String::NewSymbol("("));
   const String& kRParen = String::Handle(String::NewSymbol(") => "));
   const String& kLBracket = String::Handle(String::NewSymbol("["));
   const String& kRBracket = String::Handle(String::NewSymbol("]"));
-  if (!is_static()) {
+  if (!instantiate && !is_static()) {
+    const String& kSpaceExtendsSpace =
+        String::Handle(String::NewSymbol(" extends "));
+    const String& kLAngleBracket = String::Handle(String::NewSymbol("<"));
+    const String& kRAngleBracket = String::Handle(String::NewSymbol(">"));
     const Class& function_class = Class::Handle(owner());
     ASSERT(!function_class.IsNull());
     const Array& type_parameters = Array::Handle(
         function_class.type_parameters());
     if (!type_parameters.IsNull()) {
       intptr_t num_type_parameters = type_parameters.Length();
       pieces.Add(&kLAngleBracket);
       const TypeArray& type_parameter_extends = TypeArray::Handle(
           function_class.type_parameter_extends());
       Type& parameter_extends = Type::Handle();
@@ skipping 15 matching lines @@
   }
   Type& param_type = Type::Handle();
   const intptr_t num_params = NumberOfParameters();
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_params = num_optional_parameters();
   ASSERT((num_fixed_params + num_opt_params) == num_params);
   pieces.Add(&kLParen);
   for (intptr_t i = 0; i < num_fixed_params; i++) {
     param_type = ParameterTypeAt(i);
     ASSERT(!param_type.IsNull());
+    if (instantiate && !param_type.IsInstantiated()) {
+      param_type = param_type.InstantiateFrom(instantiator, offset);
+    }
     pieces.Add(&String::ZoneHandle(param_type.Name()));
     if (i != (num_params - 1)) {
       pieces.Add(&kCommaSpace);
     }
   }
   if (num_opt_params > 0) {
     pieces.Add(&kLBracket);
     for (intptr_t i = num_fixed_params; i < num_params; i++) {
       pieces.Add(&String::ZoneHandle(ParameterNameAt(i)));
       pieces.Add(&kColonSpace);
       param_type = ParameterTypeAt(i);
+      if (instantiate && !param_type.IsInstantiated()) {
+        param_type = param_type.InstantiateFrom(instantiator, offset);
+      }
       ASSERT(!param_type.IsNull());
       pieces.Add(&String::ZoneHandle(param_type.Name()));
       if (i != (num_params - 1)) {
         pieces.Add(&kCommaSpace);
       }
     }
     pieces.Add(&kRBracket);
   }
   pieces.Add(&kRParen);
-  const Type& res_type = Type::Handle(result_type());
+  Type& res_type = Type::Handle(result_type());
+  if (instantiate && !res_type.IsInstantiated()) {
+    res_type = res_type.InstantiateFrom(instantiator, offset);
+  }
   pieces.Add(&String::Handle(res_type.Name()));
   const Array& strings = Array::Handle(NewArray<const String>(pieces));
   return String::NewSymbol(String::Handle(String::ConcatAll(strings)));
 }
 
 
+bool Function::HasInstantiatedSignature() const {
+  Type& type = Type::Handle(result_type());
+  if (!type.IsInstantiated()) {
+    return false;
+  }
+  const intptr_t num_parameters = NumberOfParameters();
+  for (intptr_t i = 0; i < num_parameters; i++) {
+    type = ParameterTypeAt(i);
+    if (!type.IsInstantiated()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+
 const char* Function::ToCString() const {
   const char* f0 = is_static() ? " static" : "";
   const char* f1 = NULL;
   const char* f2 = is_const() ? " const" : "";
   switch (kind()) {
     case RawFunction::kFunction:
     case RawFunction::kClosureFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
       f1 = "";
@@ skipping 3358 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart