Implement more of the mirrors library, primarily stuff to do with types.

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 266 matching lines @@
           reinterpret_cast<RawExternalFourByteString*>(raw_obj)->ptr();
       ExternalStringData<uint32_t>* data = raw_string->external_data_;
       *peer = data->peer();
       return true;
     }
   }
   return false;
 }
 
 
+// When we want to return a handle to a type to the user, we handle
+// class-types differently than some other types.
+static Dart_Handle TypeToHandle(Isolate* isolate,
+                                const char* function_name,
+                                const AbstractType& type) {
+  if (type.HasResolvedTypeClass()) {
+    const Class& cls = Class::Handle(isolate, type.type_class());
+#if defined(DEBUG)
+    const Library& lib = Library::Handle(cls.library());
+    if (lib.IsNull()) {
+      ASSERT(cls.IsDynamicClass() || cls.IsVoidClass());
+    }
+#endif
+    return Api::NewHandle(isolate, cls.raw());
+  } else if (type.IsTypeParameter()) {
+    return Api::NewHandle(isolate, type.raw());
+  } else {
+    return Api::NewError("%s: unexpected type '%s' encountered.",
+                         function_name, type.ToCString());
+  }
+}
+
+
 // --- Handles ---
 
 
 DART_EXPORT bool Dart_IsError(Dart_Handle handle) {
   return RawObject::IsErrorClassId(Api::ClassId(handle));
 }
 
 
 DART_EXPORT bool Dart_IsApiError(Dart_Handle object) {
   return Api::ClassId(object) == kApiErrorCid;
@@ skipping 2157 matching lines @@
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
 
 #if defined(DEBUG)
   const Library& lib = Library::Handle(cls.library());
   if (lib.IsNull()) {
-    ASSERT(cls.IsDynamicClass() || cls.IsVoidClass());
+    // ASSERT(cls.IsDynamicClass() || cls.IsVoidClass());

[cshapiro, 2012/09/12 18:52:07]

This should have a TODO for the commented out code.

+    if (!cls.IsDynamicClass() && !cls.IsVoidClass()) {
+      fprintf(stderr, "NO LIBRARY: %s\n", cls.ToCString());

[cshapiro, 2012/09/12 18:52:07]

fprintf?  Why not use something in OS instead ?

+    }
   }
 #endif
 
   return Api::NewHandle(isolate, cls.library());
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassGetDefault(Dart_Handle clazz) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
@@ skipping 58 matching lines @@
   if (interface_type.HasResolvedTypeClass()) {
     return Api::NewHandle(isolate, interface_type.type_class());
   }
   const String& type_name =
       String::Handle(isolate, interface_type.TypeClassName());
   return Api::NewError("%s: internal error: found unresolved type class '%s'.",
                        CURRENT_FUNC, type_name.ToCString());
 }
 
 
+DART_EXPORT bool Dart_ClassIsTypedef(Dart_Handle clazz) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
+  if (cls.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  }
+  // For now, the only typedefs are non-canonical signature classes.

[cshapiro, 2012/09/12 18:52:07]

For now all typedefs are non-canonical signature classes.

[turnidge, 2012/09/12 21:39:30]

Done.

+  return cls.IsSignatureClass() && !cls.IsCanonicalSignatureClass();
+}
+
+
+DART_EXPORT Dart_Handle Dart_ClassGetTypedefReferent(Dart_Handle clazz) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
+  if (cls.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  }
+
+  if (!cls.IsSignatureClass() && !cls.IsCanonicalSignatureClass()) {
+    const String& cls_name = String::Handle(cls.UserVisibleName());
+    return Api::NewError("%s: class '%s' is not a typedef class. "
+                         "See Dart_ClassIsTypedef.",
+                         CURRENT_FUNC, cls_name.ToCString());
+  }
+
+  const Function& func = Function::Handle(isolate, cls.signature_function());
+  return Api::NewHandle(isolate, func.signature_class());
+}
+
+
+DART_EXPORT bool Dart_ClassIsFunctionType(Dart_Handle clazz) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
+  if (cls.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  }
+  // A class represents a function type when it is a canonical
+  // signature class.
+  return cls.IsCanonicalSignatureClass();
+}
+
+
+DART_EXPORT Dart_Handle Dart_ClassGetFunctionTypeSignature(Dart_Handle clazz) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
+  if (cls.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  }
+  if (!cls.IsCanonicalSignatureClass()) {
+    const String& cls_name = String::Handle(cls.UserVisibleName());
+    return Api::NewError("%s: class '%s' is not a function-type class. "
+                         "See Dart_ClassIsFunctionType.",
+                         CURRENT_FUNC, cls_name.ToCString());
+  }
+  return Api::NewHandle(isolate, cls.signature_function());
+}
+
+
 // --- Function and Variable Reflection ---
 
 
 // Outside of the vm, we expose setter names with a trailing '='.
 static bool HasExternalSetterSuffix(const String& name) {
   return name.CharAt(name.Length() - 1) == '=';
 }
 
 
 static RawString* RemoveExternalSetterSuffix(const String& name) {
@@ skipping 257 matching lines @@
   }
   const Function& func = Api::UnwrapFunctionHandle(isolate, function);
   if (func.IsNull()) {
     RETURN_TYPE_ERROR(isolate, function, Function);
   }
   *is_setter = (func.kind() == RawFunction::kSetterFunction);
   return Api::Success(isolate);
 }
 
 
+DART_EXPORT Dart_Handle Dart_FunctionReturnType(Dart_Handle function) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Function& func = Api::UnwrapFunctionHandle(isolate, function);
+  if (func.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, function, Function);
+  }
+
+  const AbstractType& return_type =
+      AbstractType::Handle(isolate, func.result_type());
+  return TypeToHandle(isolate, "Dart_FunctionReturnType", return_type);
+}
+
+
 DART_EXPORT Dart_Handle Dart_FunctionParameterCounts(
     Dart_Handle function,
     int64_t* fixed_param_count,
     int64_t* opt_param_count) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (fixed_param_count == NULL) {
     RETURN_NULL_ERROR(fixed_param_count);
   }
   if (opt_param_count == NULL) {
@@ skipping 11 matching lines @@
                         func.NumberOfImplicitParameters());
   *opt_param_count = func.num_optional_parameters();
 
   ASSERT(*fixed_param_count >= 0);
   ASSERT(*opt_param_count >= 0);
 
   return Api::Success(isolate);
 }
 
 
+DART_EXPORT Dart_Handle Dart_FunctionParameterType(Dart_Handle function,
+                                                   int parameter_index) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Function& func = Api::UnwrapFunctionHandle(isolate, function);
+  if (func.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, function, Function);
+  }
+
+  const intptr_t num_implicit_params = func.NumberOfImplicitParameters();
+  const intptr_t num_params = func.NumberOfParameters() - num_implicit_params;
+  if (parameter_index < 0 || parameter_index >= num_params) {
+    return Api::NewError(
+        "%s: argument 'parameter_index' out of range. "
+        "Expected 0..%d but saw %d.",
+        CURRENT_FUNC, num_params, parameter_index);
+  }
+  const AbstractType& param_type =
+      AbstractType::Handle(isolate, func.ParameterTypeAt(
+          num_implicit_params + parameter_index));
+  return TypeToHandle(isolate, "Dart_FunctionParameterType", param_type);
+}
+
+
 DART_EXPORT Dart_Handle Dart_GetVariableNames(Dart_Handle target) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(target));
   if (obj.IsError()) {
     return target;
   }
 
   const GrowableObjectArray& names =
       GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
@@ skipping 103 matching lines @@
     RETURN_NULL_ERROR(is_final);
   }
   const Field& var = Api::UnwrapFieldHandle(isolate, variable);
   if (var.IsNull()) {
     RETURN_TYPE_ERROR(isolate, variable, Field);
   }
   *is_final = var.is_final();
   return Api::Success(isolate);
 }
 
+
+DART_EXPORT Dart_Handle Dart_VariableType(Dart_Handle variable) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Field& var = Api::UnwrapFieldHandle(isolate, variable);
+  if (var.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, variable, Field);
+  }
+
+  const AbstractType& type = AbstractType::Handle(isolate, var.type());
+  return TypeToHandle(isolate, "Dart_VariableType", type);
+}
+
+
+DART_EXPORT Dart_Handle Dart_GetTypeVariableNames(Dart_Handle clazz) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
+  if (cls.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  }
+
+  const intptr_t num_type_params = cls.NumTypeParameters();
+  const TypeArguments& type_params =
+      TypeArguments::Handle(cls.type_parameters());
+
+  const GrowableObjectArray& names =
+      GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
+  TypeParameter& type_param = TypeParameter::Handle(isolate);
+  String& name = String::Handle(isolate);
+  for (intptr_t i = 0; i < num_type_params; i++) {
+    type_param ^= type_params.TypeAt(i);
+    name = type_param.name();
+    names.Add(name);
+  }
+  return Api::NewHandle(isolate, Array::MakeArray(names));
+}
+
+
+DART_EXPORT Dart_Handle Dart_LookupTypeVariable(
+    Dart_Handle clazz,
+    Dart_Handle type_variable_name) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
+  if (cls.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  }
+  const String& var_name = Api::UnwrapStringHandle(isolate, type_variable_name);
+  if (var_name.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, type_variable_name, String);
+  }
+
+  const intptr_t num_type_params = cls.NumTypeParameters();
+  const TypeArguments& type_params =
+      TypeArguments::Handle(cls.type_parameters());
+
+  TypeParameter& type_param = TypeParameter::Handle(isolate);
+  String& name = String::Handle(isolate);
+  for (intptr_t i = 0; i < num_type_params; i++) {
+    type_param ^= type_params.TypeAt(i);
+    name = type_param.name();
+    if (name.Equals(var_name)) {
+      return Api::NewHandle(isolate, type_param.raw());
+    }
+  }
+  const String& cls_name = String::Handle(cls.UserVisibleName());
+  return Api::NewError(
+      "%s: Could not find type variable named '%s' for class %s.\n",
+      var_name.ToCString(), cls_name.ToCString());
+}
+
+
+DART_EXPORT bool Dart_IsTypeVariable(Dart_Handle handle) {
+  return Api::ClassId(handle) == kTypeParameterCid;
+}
+
+DART_EXPORT Dart_Handle Dart_TypeVariableName(Dart_Handle type_variable) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const TypeParameter& type_var =
+      Api::UnwrapTypeParameterHandle(isolate, type_variable);
+  if (type_var.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, type_variable, TypeParameter);
+  }
+  return Api::NewHandle(isolate, type_var.name());
+}
+
+
+DART_EXPORT Dart_Handle Dart_TypeVariableOwner(Dart_Handle type_variable) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const TypeParameter& type_var =
+      Api::UnwrapTypeParameterHandle(isolate, type_variable);
+  if (type_var.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, type_variable, TypeParameter);
+  }
+  const Class& owner = Class::Handle(type_var.parameterized_class());
+  ASSERT(!owner.IsNull() && owner.IsClass());
+  return Api::NewHandle(isolate, owner.raw());
+}
+
+
+DART_EXPORT Dart_Handle Dart_TypeVariableUpperBound(Dart_Handle type_variable) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const TypeParameter& type_var =
+      Api::UnwrapTypeParameterHandle(isolate, type_variable);
+  if (type_var.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, type_variable, TypeParameter);
+  }
+  const AbstractType& bound = AbstractType::Handle(type_var.bound());
+  return TypeToHandle(isolate, "Dart_TypeVariableUpperBound", bound);
+}
+
+
 // --- Constructors, Methods, and Fields ---
 
 
 static RawObject* ResolveConstructor(const char* current_func,
                                      const Class& cls,
                                      const String& class_name,
                                      const String& dotted_name,
                                      int num_args) {
   // The constructor must be present in the interface.
   String& constr_name = String::Handle(String::Concat(class_name, dotted_name));
@@ skipping 985 matching lines @@
     RETURN_TYPE_ERROR(isolate, library, Library);
   }
 
   const GrowableObjectArray& names =
       GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
   ClassDictionaryIterator it(lib);
   Class& cls = Class::Handle();
   String& name = String::Handle();
   while (it.HasNext()) {
     cls = it.GetNextClass();
-    // For now we suppress the signature classes of closures.
-    //
-    // TODO(turnidge): Add this to the unit test.
-    const Function& signature_func = Function::Handle(cls.signature_function());
-    if (signature_func.IsNull()) {
+    if (cls.IsSignatureClass()) {
+      if (!cls.IsCanonicalSignatureClass()) {
+        // This is a typedef.  Add it to the list of class names.
+        name = cls.UserVisibleName();
+        names.Add(name);
+      } else {
+        // Skip canonical signature classes.  These are not named.
+      }
+    } else {
       name = cls.UserVisibleName();
       names.Add(name);
     }
   }
   return Api::NewHandle(isolate, Array::MakeArray(names));
 }
 
 
 DART_EXPORT Dart_Handle Dart_LookupLibrary(Dart_Handle url) {
   Isolate* isolate = Isolate::Current();
@@ skipping 180 matching lines @@
 DART_EXPORT void Dart_InitPerfEventsSupport(Dart_FileWriterFunction function) {
   Dart::set_perf_events_writer(function);
 }
 
 
 DART_EXPORT void Dart_InitFlowGraphPrinting(Dart_FileWriterFunction function) {
   Dart::set_flow_graph_writer(function);
 }
 
 }  // namespace dart