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

runtime/vm/dart_api_impl_test.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 "platform/assert.h"
 #include "platform/json.h"
 #include "platform/utils.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/thread.h"
 #include "vm/unit_test.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
+DECLARE_FLAG(bool, enable_type_checks);
+
 // Only ia32 and x64 can run execution tests.
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
 
 TEST_CASE(ErrorHandleBasics) {
   const char* kScriptChars =
       "void testMain() {\n"
       "  throw new Exception(\"bad news\");\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
@@ skipping 2351 matching lines @@
   EXPECT_VALID(Dart_StringToCString(dflt_name, &dflt_name_cstr));
   EXPECT_STREQ("MyDefault", dflt_name_cstr);
 
   EXPECT(Dart_IsNull(Dart_ClassGetDefault(cls)));
   EXPECT_ERROR(
       Dart_ClassGetDefault(Dart_True()),
       "Dart_ClassGetDefault expects argument 'clazz' to be of type Class.");
   EXPECT_ERROR(Dart_ClassGetDefault(Dart_NewApiError("MyError")), "MyError");
 }
 
+TEST_CASE(ClassTypedefsEtc) {
+  const char* kScriptChars =
+      "class SomeClass {\n"
+      "}\n"
+      "typedef void SomeHandler(String a);\n";
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
+  EXPECT_VALID(lib);
+  Dart_Handle normal_cls = Dart_GetClass(lib, Dart_NewString("SomeClass"));
+  EXPECT_VALID(normal_cls);
+  Dart_Handle typedef_cls = Dart_GetClass(lib, Dart_NewString("SomeHandler"));
+  EXPECT_VALID(typedef_cls);
+
+  EXPECT(Dart_IsClass(normal_cls));
+  EXPECT(!Dart_ClassIsTypedef(normal_cls));
+  EXPECT(!Dart_ClassIsFunctionType(normal_cls));
+
+  EXPECT(Dart_IsClass(typedef_cls));
+  EXPECT(Dart_ClassIsTypedef(typedef_cls));
+  EXPECT(!Dart_ClassIsFunctionType(typedef_cls));
+
+  // Exercise the typedef class api.
+  Dart_Handle functype_cls = Dart_ClassGetTypedefReferent(typedef_cls);
+  EXPECT_VALID(functype_cls);
+
+  // Pass the wrong class kind to Dart_ClassGetTypedefReferent
+  EXPECT_ERROR(Dart_ClassGetTypedefReferent(normal_cls),
+               "class 'SomeClass' is not a typedef class.");
+
+  EXPECT(Dart_IsClass(functype_cls));
+  EXPECT(!Dart_ClassIsTypedef(functype_cls));
+  EXPECT(Dart_ClassIsFunctionType(functype_cls));
+
+  // Exercise the function type class.
+  Dart_Handle sig_func = Dart_ClassGetFunctionTypeSignature(functype_cls);
+  EXPECT_VALID(sig_func);
+  EXPECT(Dart_IsFunction(sig_func));
+  int64_t fixed_params = -1;
+  int64_t opt_params = -1;
+  EXPECT_VALID(
+      Dart_FunctionParameterCounts(sig_func, &fixed_params, &opt_params));
+  EXPECT_EQ(1, fixed_params);
+  EXPECT_EQ(0, opt_params);
+
+  // Pass the wrong class kind to Dart_ClassGetFunctionTypeSignature
+  EXPECT_ERROR(Dart_ClassGetFunctionTypeSignature(normal_cls),
+               "class 'SomeClass' is not a function-type class.");
+}
 
 #define CHECK_INTERFACE(handle, name)                                   \
   {                                                                     \
     Dart_Handle tmp = (handle);                                         \
     EXPECT_VALID(tmp);                                                  \
     EXPECT(Dart_IsInterface(tmp));                                      \
     Dart_Handle intf_name = Dart_ClassName(tmp);                        \
     EXPECT_VALID(intf_name);                                            \
     const char* intf_name_cstr = "";                                    \
     EXPECT_VALID(Dart_StringToCString(intf_name, &intf_name_cstr));     \
@@ skipping 2104 matching lines @@
   // Lookup a class using an error class name.  The error propagates.
   func = Dart_LookupFunction(cls, Api::NewError("myerror"));
   EXPECT_ERROR(func, "myerror");
 
   // Lookup a class from an error library.  The error propagates.
   func = Dart_LookupFunction(Api::NewError("myerror"), Dart_NewString("foo"));
   EXPECT_ERROR(func, "myerror");
 }
 
 
+TEST_CASE(TypeReflection) {
+  const char* kScriptChars =
+      "void func(String a, int b) {}\n"
+      "int variable;\n";
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
+  EXPECT_VALID(lib);
+
+  Dart_Handle func = Dart_LookupFunction(lib, Dart_NewString("func"));
+  EXPECT_VALID(func);
+  EXPECT(Dart_IsFunction(func));
+
+  // Make sure parameter counts are right.
+  int64_t fixed_params = -1;
+  int64_t opt_params = -1;
+  EXPECT_VALID(Dart_FunctionParameterCounts(func, &fixed_params, &opt_params));
+  EXPECT_EQ(2, fixed_params);
+  EXPECT_EQ(0, opt_params);
+
+  // Check the return type.
+  Dart_Handle type = Dart_FunctionReturnType(func);
+  EXPECT_VALID(type);
+  Dart_Handle cls_name = Dart_ClassName(type);
+  EXPECT_VALID(cls_name);
+  const char* cls_name_cstr = "";
+  EXPECT_VALID(Dart_StringToCString(cls_name, &cls_name_cstr));
+  EXPECT_STREQ("void", cls_name_cstr);
+
+  // Check a parameter type.
+  type = Dart_FunctionParameterType(func, 0);
+  EXPECT_VALID(type);
+  cls_name = Dart_ClassName(type);
+  EXPECT_VALID(cls_name);
+  cls_name_cstr = "";
+  EXPECT_VALID(Dart_StringToCString(cls_name, &cls_name_cstr));
+  EXPECT_STREQ("String", cls_name_cstr);
+
+  Dart_Handle var = Dart_LookupVariable(lib, Dart_NewString("variable"));
+  EXPECT_VALID(var);
+  EXPECT(Dart_IsVariable(var));
+
+  // Check the variable type.
+  type = Dart_VariableType(var);
+  EXPECT_VALID(type);
+  cls_name = Dart_ClassName(type);
+  EXPECT_VALID(cls_name);
+  cls_name_cstr = "";
+  EXPECT_VALID(Dart_StringToCString(cls_name, &cls_name_cstr));
+  if (FLAG_enable_type_checks) {
+    EXPECT_STREQ("int", cls_name_cstr);
+  } else {
+    EXPECT_STREQ("Dynamic", cls_name_cstr);
+  }
+}
+
+
 static void BuildVariableDescription(TextBuffer* buffer, Dart_Handle var) {
   buffer->Clear();
   Dart_Handle name = Dart_VariableName(var);
   EXPECT_VALID(name);
   const char* name_cstr = "";
   EXPECT_VALID(Dart_StringToCString(name, &name_cstr));
   bool is_static = false;
   bool is_final = false;
   EXPECT_VALID(Dart_VariableIsStatic(var, &is_static));
   EXPECT_VALID(Dart_VariableIsFinal(var, &is_final));
@@ skipping 125 matching lines @@
   // Lookup a class from an error library.  The error propagates.
   var = Dart_LookupVariable(Api::NewError("myerror"), Dart_NewString("foo"));
   EXPECT_ERROR(var, "myerror");
 
   // Lookup a class using an error class name.  The error propagates.
   var = Dart_LookupVariable(lib, Api::NewError("myerror"));
   EXPECT_ERROR(var, "myerror");
 }
 
 
+TEST_CASE(TypeVariableReflection) {
+  const char* kScriptChars =
+      "interface UpperBound {}\n"
+      "class GenericClass<U, T extends UpperBound> {\n"
+      "  T func1() { return null; }\n"
+      "  U func2() { return null; }\n"
+      "}\n";
+
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
+  Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("GenericClass"));
+  EXPECT_VALID(cls);
+
+  // Test Dart_GetTypeVariableNames.
+  Dart_Handle names = Dart_GetTypeVariableNames(cls);
+  EXPECT_VALID(names);
+  Dart_Handle names_str = Dart_ToString(names);
+  EXPECT_VALID(names_str);
+  const char* cstr = "";
+  EXPECT_VALID(Dart_StringToCString(names_str, &cstr));
+  EXPECT_STREQ("[U, T]", cstr);
+
+  // Test variable U.
+  Dart_Handle type_var = Dart_LookupTypeVariable(cls, Dart_NewString("U"));
+  EXPECT_VALID(type_var);
+  EXPECT(Dart_IsTypeVariable(type_var));
+  Dart_Handle type_var_name = Dart_TypeVariableName(type_var);
+  EXPECT_VALID(type_var_name);
+  EXPECT_VALID(Dart_StringToCString(type_var_name, &cstr));
+  EXPECT_STREQ("U", cstr);
+  Dart_Handle type_var_owner = Dart_TypeVariableOwner(type_var);
+  EXPECT_VALID(type_var_owner);
+  EXPECT(Dart_IdentityEquals(cls, type_var_owner));
+  Dart_Handle type_var_bound = Dart_TypeVariableUpperBound(type_var);
+  Dart_Handle bound_name = Dart_ClassName(type_var_bound);
+  EXPECT_VALID(Dart_StringToCString(bound_name, &cstr));
+  EXPECT_STREQ("Object", cstr);
+
+  // Test variable T.
+  type_var = Dart_LookupTypeVariable(cls, Dart_NewString("T"));
+  EXPECT_VALID(type_var);
+  EXPECT(Dart_IsTypeVariable(type_var));
+  type_var_name = Dart_TypeVariableName(type_var);
+  EXPECT_VALID(type_var_name);
+  EXPECT_VALID(Dart_StringToCString(type_var_name, &cstr));
+  EXPECT_STREQ("T", cstr);
+  type_var_owner = Dart_TypeVariableOwner(type_var);
+  EXPECT_VALID(type_var_owner);
+  EXPECT(Dart_IdentityEquals(cls, type_var_owner));
+  type_var_bound = Dart_TypeVariableUpperBound(type_var);
+  bound_name = Dart_ClassName(type_var_bound);
+  EXPECT_VALID(Dart_StringToCString(bound_name, &cstr));
+  EXPECT_STREQ("UpperBound", cstr);
+}
+
+
 TEST_CASE(InstanceOf) {
   const char* kScriptChars =
       "class OtherClass {\n"
       "  static returnNull() { return null; }\n"
       "}\n"
       "class InstanceOfTest {\n"
       "  InstanceOfTest() {}\n"
       "  static InstanceOfTest testMain() {\n"
       "    return new InstanceOfTest();\n"
       "  }\n"
@@ skipping 1824 matching lines @@
   EXPECT(Dart_IsString(str));
   len = -1;
   EXPECT_VALID(Dart_StringLength(str, &len));
   EXPECT_EQ(0, len);
 }
 
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart