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();
+  if (IsParameterized()) {
+    const intptr_t num_type_params = NumTypeParameters();

[siva, 2011/10/17 18:36:59]

Should we add a num_type_params check? would avoid 4 handle creations.

if (num_type_params > 0) {
  ....
  ...
  ...
  ...
  for (int i = 0;.....) {
  }
}

Also what does TypeArguments::NewTypeArray(0) return?

[regis, 2011/10/17 19:02:47]

Good point. I actually can replace the test IsParameterized() by num_type_params
> 0.
Is it OK to leave the type argument vector as null if the class has no type
parameters on its own. Type finalization will extend the vector with the
arguments of the base class if necessary. 

+    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