Fix for issue 11262.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
@@ skipping 1223 matching lines @@
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return GetListInstance(isolate, obj) != Instance::null();
 }
 
 
 DART_EXPORT bool Dart_IsLibrary(Dart_Handle object) {
   return Api::ClassId(object) == kLibraryCid;
 }
 
 
+DART_EXPORT bool Dart_IsType(Dart_Handle handle) {
+  return Api::ClassId(handle) == kTypeCid;
+}
+
+
 DART_EXPORT bool Dart_IsClass(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   return obj.IsClass();
 }
 
 
-DART_EXPORT bool Dart_IsAbstractClass(Dart_Handle handle) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
-  if (obj.IsClass()) {
-    return Class::Cast(obj).is_abstract();
-  }
-  return false;
-}
-
-
 DART_EXPORT bool Dart_IsFunction(Dart_Handle handle) {
   return Api::ClassId(handle) == kFunctionCid;
 }
 
 
 DART_EXPORT bool Dart_IsVariable(Dart_Handle handle) {
   return Api::ClassId(handle) == kFieldCid;
 }
 
 
 DART_EXPORT bool Dart_IsTypeVariable(Dart_Handle handle) {
   return Api::ClassId(handle) == kTypeParameterCid;
 }
 
 
 DART_EXPORT bool Dart_IsClosure(Dart_Handle object) {
   // We can't use a fast class index check here because there are many
   // different signature classes for closures.
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Instance& closure_obj = Api::UnwrapInstanceHandle(isolate, object);
   return (!closure_obj.IsNull() && closure_obj.IsClosure());
 }
 
 
 // --- Instances ----
 
-// TODO(turnidge): Technically, null has a class.  Should we allow it?
+DART_EXPORT Dart_Handle Dart_InstanceGetType(Dart_Handle instance) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(instance));
+  if (obj.IsNull()) {
+    return Api::NewHandle(isolate, isolate->object_store()->null_type());
+  }
+  if (!obj.IsInstance()) {
+    RETURN_TYPE_ERROR(isolate, instance, Instance);
+  }
+  const Type& type = Type::Handle(Instance::Cast(obj).GetType());
+  return Api::NewHandle(isolate, type.Canonicalize());
+}
+
+// TODO(asiva): Deprecate this method.
 DART_EXPORT Dart_Handle Dart_InstanceGetClass(Dart_Handle instance) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Instance& obj = Api::UnwrapInstanceHandle(isolate, instance);
   if (obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, instance, Instance);
   }
   return Api::NewHandle(isolate, obj.clazz());
 }
 
@@ skipping 1406 matching lines @@
                              "constructor '%s': %s.",
                              current_func,
                              constr_name.ToCString(),
                              error_message.ToCString()));
     return ApiError::New(message);
   }
   return constructor.raw();
 }
 
 
-DART_EXPORT Dart_Handle Dart_New(Dart_Handle clazz,
+DART_EXPORT Dart_Handle Dart_New(Dart_Handle type,
                                  Dart_Handle constructor_name,
                                  int number_of_arguments,
                                  Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_CALLBACK_STATE(isolate);
   Object& result = Object::Handle(isolate);
 
   if (number_of_arguments < 0) {
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
 
   // Get the class to instantiate.
-  Class& cls =
-      Class::Handle(isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
-  if (cls.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  result = Api::UnwrapHandle(type);
+  if (result.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, type, Type);
+  }
+  Class& cls = Class::Handle(isolate);
+  if (result.IsType()) {
+    cls = Type::Cast(result).type_class();
+  } else if (result.IsClass()) {
+    // For backwards compatibility we allow class objects to be passed in
+    // for now. This needs to be removed once all code that uses class
+    // objects to invoke Dart_New is removed.
+    cls ^= result.raw();
+  } else {
+    RETURN_TYPE_ERROR(isolate, type, Type);
   }
 
   String& base_constructor_name = String::Handle();
   base_constructor_name = cls.Name();
 
   // And get the name of the constructor to invoke.
   String& dot_name = String::Handle(isolate);
-  const Object& name_obj =
-      Object::Handle(isolate, Api::UnwrapHandle(constructor_name));
-  if (name_obj.IsNull()) {
+  result = Api::UnwrapHandle(constructor_name);
+  if (result.IsNull()) {
     dot_name = Symbols::Dot().raw();
-  } else if (name_obj.IsString()) {
-    dot_name = String::Concat(Symbols::Dot(), String::Cast(name_obj));
+  } else if (result.IsString()) {
+    dot_name = String::Concat(Symbols::Dot(), String::Cast(result));
   } else {
     RETURN_TYPE_ERROR(isolate, constructor_name, String);
   }
   Dart_Handle state = Api::CheckIsolateState(isolate);
   if (::Dart_IsError(state)) {
     return state;
   }
 
   // Resolve the constructor.
   String& constr_name =
@@ skipping 81 matching lines @@
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(target));
   if (obj.IsError()) {
     return target;
   }
 
   // Check for malformed arguments in the arguments list.
-  intptr_t num_receiver = (obj.IsNull() || obj.IsInstance()) ? 1 : 0;
+  intptr_t num_receiver =
+      (obj.IsNull() || (obj.IsInstance() && !obj.IsType())) ? 1 : 0;
   const Array& args =
       Array::Handle(isolate, Array::New(number_of_arguments + num_receiver));
   Object& arg = Object::Handle(isolate);
   for (int i = 0; i < number_of_arguments; i++) {
     arg = Api::UnwrapHandle(arguments[i]);
     if (!arg.IsNull() && !arg.IsInstance()) {
       if (arg.IsError()) {
         return Api::NewHandle(isolate, arg.raw());
       } else {
         return Api::NewError(
             "%s expects arguments[%d] to be an Instance handle.",
             CURRENT_FUNC, i);
       }
     }
     args.SetAt((i + num_receiver), arg);
   }
 
-  if (obj.IsNull() || obj.IsInstance()) {
-    Instance& instance = Instance::Handle(isolate);
-    instance ^= obj.raw();
-    const Function& function = Function::Handle(
-        isolate,
-        Resolver::ResolveDynamic(instance,
-                                 function_name,
-                                 (number_of_arguments + 1),
-                                 Resolver::kIsQualified));
-    args.SetAt(0, instance);
-    if (function.IsNull()) {
-      const Array& args_descriptor =
-          Array::Handle(ArgumentsDescriptor::New(args.Length()));
-      return Api::NewHandle(isolate,
-                            DartEntry::InvokeNoSuchMethod(instance,
-                                                          function_name,
-                                                          args,
-                                                          args_descriptor));
-    }
-    return Api::NewHandle(isolate, DartEntry::InvokeFunction(function, args));
-
-  } else if (obj.IsClass()) {
+  if (obj.IsType() || obj.IsClass()) {
     // Finalize all classes.
     Dart_Handle state = Api::CheckIsolateState(isolate);
     if (::Dart_IsError(state)) {
       return state;
     }
 
-    const Class& cls = Class::Cast(obj);
+    // For backwards compatibility we allow class objects to be passed in
+    // for now. This needs to be removed once all code that uses class
+    // objects to invoke Dart_Invoke is removed.
+    Class& cls = Class::Handle();
+    if (obj.IsType()) {
+      cls = Type::Cast(obj).type_class();
+    } else {
+      cls = Class::Cast(obj).raw();
+    }
     const Function& function = Function::Handle(
         isolate,
         Resolver::ResolveStatic(cls,
                                 function_name,
                                 number_of_arguments,
                                 Object::empty_array(),
                                 Resolver::kIsQualified));
     if (function.IsNull()) {
       const String& cls_name = String::Handle(isolate, cls.Name());
       return Api::NewError("%s: did not find static method '%s.%s'.",
                            CURRENT_FUNC,
                            cls_name.ToCString(),
                            function_name.ToCString());
     }
     return Api::NewHandle(isolate, DartEntry::InvokeFunction(function, args));
 
+  } else if (obj.IsNull() || obj.IsInstance()) {
+    Instance& instance = Instance::Handle(isolate);
+    instance ^= obj.raw();
+    const Function& function = Function::Handle(
+        isolate,
+        Resolver::ResolveDynamic(instance,
+                                 function_name,
+                                 (number_of_arguments + 1),
+                                 Resolver::kIsQualified));
+    args.SetAt(0, instance);
+    if (function.IsNull()) {
+      const Array& args_descriptor =
+          Array::Handle(ArgumentsDescriptor::New(args.Length()));
+      return Api::NewHandle(isolate,
+                            DartEntry::InvokeNoSuchMethod(instance,
+                                                          function_name,
+                                                          args,
+                                                          args_descriptor));
+    }
+    return Api::NewHandle(isolate, DartEntry::InvokeFunction(function, args));
+
   } else if (obj.IsLibrary()) {
     // Check whether class finalization is needed.
     bool finalize_classes = true;
     const Library& lib = Library::Cast(obj);
 
     // When calling functions in the dart:builtin library do not finalize as it
     // should have been prefinalized.
     Library& builtin =
         Library::Handle(isolate, isolate->object_store()->builtin_library());
     if (builtin.raw() == lib.raw()) {
@@ skipping 23 matching lines @@
                                          &error_message)) {
       return Api::NewError("%s: wrong argument count for function '%s': %s.",
                            CURRENT_FUNC,
                            function_name.ToCString(),
                            error_message.ToCString());
     }
     return Api::NewHandle(isolate, DartEntry::InvokeFunction(function, args));
 
   } else {
     return Api::NewError(
-        "%s expects argument 'target' to be an object, class, or library.",
+        "%s expects argument 'target' to be an object, type, or library.",
         CURRENT_FUNC);
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeClosure(Dart_Handle closure,
                                            int number_of_arguments,
                                            Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
@@ skipping 52 matching lines @@
   Dart_Handle state = Api::CheckIsolateState(isolate);
   if (::Dart_IsError(state)) {
     return state;
   }
   Field& field = Field::Handle(isolate);
   Function& getter = Function::Handle(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(container));
   if (obj.IsNull()) {
     return Api::NewError("%s expects argument 'container' to be non-null.",
                          CURRENT_FUNC);
+  } else if (obj.IsType() || obj.IsClass()) {
+    // To access a static field we may need to use the Field or the
+    // getter Function.
+    // For backwards compatibility we allow class objects to be passed in
+    // for now. This needs to be removed once all code that uses class
+    // objects to invoke Dart_GetField is removed.
+    Class& cls = Class::Handle();
+    if (obj.IsType()) {
+      cls = Type::Cast(obj).type_class();
+    } else {
+      cls = Class::Cast(obj).raw();
+    }
+    field = cls.LookupStaticField(field_name);
+    if (field.IsNull() || FieldIsUninitialized(isolate, field)) {
+      const String& getter_name =
+          String::Handle(isolate, Field::GetterName(field_name));
+      getter = cls.LookupStaticFunctionAllowPrivate(getter_name);
+    }
+
+    if (!getter.IsNull()) {
+      // Invoke the getter and return the result.
+      return Api::NewHandle(
+          isolate, DartEntry::InvokeFunction(getter, Object::empty_array()));
+    } else if (!field.IsNull()) {
+      return Api::NewHandle(isolate, field.value());
+    } else {
+      return Api::NewError("%s: did not find static field '%s'.",
+                           CURRENT_FUNC, field_name.ToCString());
+    }
+
   } else if (obj.IsInstance()) {
     // Every instance field has a getter Function.  Try to find the
     // getter in any superclass and use that function to access the
     // field.
     const Instance& instance = Instance::Cast(obj);
     Class& cls = Class::Handle(isolate, instance.clazz());
     String& getter_name =
         String::Handle(isolate, Field::GetterName(field_name));
     while (!cls.IsNull()) {
       getter = cls.LookupDynamicFunctionAllowPrivate(getter_name);
@@ skipping 11 matching lines @@
       const Array& args_descriptor =
           Array::Handle(ArgumentsDescriptor::New(args.Length()));
       return Api::NewHandle(isolate,
                             DartEntry::InvokeNoSuchMethod(instance,
                                                           getter_name,
                                                           args,
                                                           args_descriptor));
     }
     return Api::NewHandle(isolate, DartEntry::InvokeFunction(getter, args));
 
-  } else if (obj.IsClass()) {
-    // To access a static field we may need to use the Field or the
-    // getter Function.
-    const Class& cls = Class::Cast(obj);
-    field = cls.LookupStaticField(field_name);
-    if (field.IsNull() || FieldIsUninitialized(isolate, field)) {
-      const String& getter_name =
-          String::Handle(isolate, Field::GetterName(field_name));
-      getter = cls.LookupStaticFunctionAllowPrivate(getter_name);
-    }
-
-    if (!getter.IsNull()) {
-      // Invoke the getter and return the result.
-      return Api::NewHandle(
-          isolate, DartEntry::InvokeFunction(getter, Object::empty_array()));
-    } else if (!field.IsNull()) {
-      return Api::NewHandle(isolate, field.value());
-    } else {
-      return Api::NewError("%s: did not find static field '%s'.",
-                           CURRENT_FUNC, field_name.ToCString());
-    }
-
   } else if (obj.IsLibrary()) {
     // To access a top-level we may need to use the Field or the
     // getter Function.  The getter function may either be in the
     // library or in the field's owner class, depending.
     const Library& lib = Library::Cast(obj);
     field = lib.LookupFieldAllowPrivate(field_name);
     if (field.IsNull()) {
       // No field found.  Check for a getter in the lib.
       const String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
@@ skipping 14 matching lines @@
       return Api::NewHandle(isolate, field.value());
     } else {
       return Api::NewError("%s: did not find top-level variable '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
   } else if (obj.IsError()) {
       return container;
   } else {
     return Api::NewError(
-        "%s expects argument 'container' to be an object, class, or library.",
+        "%s expects argument 'container' to be an object, type, or library.",
         CURRENT_FUNC);
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetField(Dart_Handle container,
                                       Dart_Handle name,
                                       Dart_Handle value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
@@ skipping 16 matching lines @@
   Dart_Handle state = Api::CheckIsolateState(isolate);
   if (::Dart_IsError(state)) {
     return state;
   }
   Field& field = Field::Handle(isolate);
   Function& setter = Function::Handle(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(container));
   if (obj.IsNull()) {
     return Api::NewError("%s expects argument 'container' to be non-null.",
                          CURRENT_FUNC);
+  } else if (obj.IsType() || obj.IsClass()) {
+    // To access a static field we may need to use the Field or the
+    // setter Function.
+    // For backwards compatibility we allow class objects to be passed in
+    // for now. This needs to be removed once all code that uses class
+    // objects to invoke Dart_SetField is removed.
+    Class& cls = Class::Handle();
+    if (obj.IsType()) {
+      cls = Type::Cast(obj).type_class();
+    } else {
+      cls = Class::Cast(obj).raw();
+    }
+    field = cls.LookupStaticField(field_name);
+    if (field.IsNull()) {
+      String& setter_name =
+          String::Handle(isolate, Field::SetterName(field_name));
+      setter = cls.LookupStaticFunctionAllowPrivate(setter_name);
+    }
+
+    if (!setter.IsNull()) {
+      // Invoke the setter and return the result.
+      const int kNumArgs = 1;
+      const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
+      args.SetAt(0, value_instance);
+      const Object& result =
+          Object::Handle(isolate, DartEntry::InvokeFunction(setter, args));
+      if (result.IsError()) {
+        return Api::NewHandle(isolate, result.raw());
+      } else {
+        return Api::Success();
+      }
+    } else if (!field.IsNull()) {
+      if (field.is_final()) {
+        return Api::NewError("%s: cannot set final field '%s'.",
+                             CURRENT_FUNC, field_name.ToCString());
+      } else {
+        field.set_value(value_instance);
+        return Api::Success();
+      }
+    } else {
+      return Api::NewError("%s: did not find static field '%s'.",
+                           CURRENT_FUNC, field_name.ToCString());
+    }
+
   } else if (obj.IsInstance()) {
     // Every instance field has a setter Function.  Try to find the
     // setter in any superclass and use that function to access the
     // field.
     const Instance& instance = Instance::Cast(obj);
     Class& cls = Class::Handle(isolate, instance.clazz());
     String& setter_name =
         String::Handle(isolate, Field::SetterName(field_name));
     while (!cls.IsNull()) {
       field = cls.LookupInstanceField(field_name);
@@ skipping 17 matching lines @@
       const Array& args_descriptor =
           Array::Handle(ArgumentsDescriptor::New(args.Length()));
       return Api::NewHandle(isolate,
                             DartEntry::InvokeNoSuchMethod(instance,
                                                           setter_name,
                                                           args,
                                                           args_descriptor));
     }
     return Api::NewHandle(isolate, DartEntry::InvokeFunction(setter, args));
 
-  } else if (obj.IsClass()) {
-    // To access a static field we may need to use the Field or the
-    // setter Function.
-    const Class& cls = Class::Cast(obj);
-    field = cls.LookupStaticField(field_name);
-    if (field.IsNull()) {
-      String& setter_name =
-          String::Handle(isolate, Field::SetterName(field_name));
-      setter = cls.LookupStaticFunctionAllowPrivate(setter_name);
-    }
-
-    if (!setter.IsNull()) {
-      // Invoke the setter and return the result.
-      const int kNumArgs = 1;
-      const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
-      args.SetAt(0, value_instance);
-      const Object& result =
-          Object::Handle(isolate, DartEntry::InvokeFunction(setter, args));
-      if (result.IsError()) {
-        return Api::NewHandle(isolate, result.raw());
-      } else {
-        return Api::Success();
-      }
-    } else if (!field.IsNull()) {
-      if (field.is_final()) {
-        return Api::NewError("%s: cannot set final field '%s'.",
-                             CURRENT_FUNC, field_name.ToCString());
-      } else {
-        field.set_value(value_instance);
-        return Api::Success();
-      }
-    } else {
-      return Api::NewError("%s: did not find static field '%s'.",
-                           CURRENT_FUNC, field_name.ToCString());
-    }
-
   } else if (obj.IsLibrary()) {
     // To access a top-level we may need to use the Field or the
     // setter Function.  The setter function may either be in the
     // library or in the field's owner class, depending.
     const Library& lib = Library::Cast(obj);
     field = lib.LookupFieldAllowPrivate(field_name);
     if (field.IsNull()) {
       const String& setter_name =
           String::Handle(isolate, Field::SetterName(field_name));
       setter ^= lib.LookupFunctionAllowPrivate(setter_name);
@@ skipping 21 matching lines @@
       }
     } else {
       return Api::NewError("%s: did not find top-level variable '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
   } else if (obj.IsError()) {
       return container;
   } else {
     return Api::NewError(
-        "%s expects argument 'container' to be an object, class, or library.",
+        "%s expects argument 'container' to be an object, type, or library.",
         CURRENT_FUNC);
   }
 }
 
 
 // --- Exceptions ----
 
 DART_EXPORT Dart_Handle Dart_ThrowException(Dart_Handle exception) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
@@ skipping 644 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success();
 }
 
 }  // namespace dart