Remove support for interfaces.

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"
@@ skipping 2361 matching lines @@
   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));     \
-    EXPECT_STREQ((name), intf_name_cstr);                               \
+#define CHECK_ABSTRACT_CLASS(handle, name)                                     \
+  {                                                                            \
+    Dart_Handle tmp = (handle);                                                \
+    EXPECT_VALID(tmp);                                                         \
+    EXPECT(Dart_IsAbstractClass(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));            \
+    EXPECT_STREQ((name), intf_name_cstr);                                      \
   }
 
 
 TEST_CASE(ClassGetInterfaces) {
   const char* kScriptChars =
       "class MyClass0 {\n"
       "}\n"
       "\n"
       "class MyClass1 implements MyInterface1 {\n"
       "}\n"
       "\n"
       "class MyClass2 implements MyInterface0, MyInterface1 {\n"
       "}\n"
       "\n"
-      "interface MyInterface0 {\n"
+      "abstract class MyInterface0 {\n"
       "}\n"
       "\n"
-      "interface MyInterface1 extends MyInterface0 {\n"
+      "abstract class MyInterface1 implements MyInterface0 {\n"
       "}\n";
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   Dart_Handle cls0 = Dart_GetClass(lib, NewString("MyClass0"));
   Dart_Handle cls1 = Dart_GetClass(lib, NewString("MyClass1"));
   Dart_Handle cls2 = Dart_GetClass(lib, NewString("MyClass2"));
   Dart_Handle intf0 = Dart_GetClass(lib, NewString("MyInterface0"));
   Dart_Handle intf1 = Dart_GetClass(lib, NewString("MyInterface1"));
 
   intptr_t len = -1;
   EXPECT_VALID(Dart_ClassGetInterfaceCount(cls0, &len));
   EXPECT_EQ(0, len);
 
   EXPECT_ERROR(Dart_ClassGetInterfaceAt(cls0, 0),
                "Dart_ClassGetInterfaceAt: argument 'index' out of bounds");
 
   len = -1;
   EXPECT_VALID(Dart_ClassGetInterfaceCount(cls1, &len));
   EXPECT_EQ(1, len);
-  CHECK_INTERFACE(Dart_ClassGetInterfaceAt(cls1, 0), "MyInterface1");
+  CHECK_ABSTRACT_CLASS(Dart_ClassGetInterfaceAt(cls1, 0), "MyInterface1");
 
   EXPECT_ERROR(Dart_ClassGetInterfaceAt(cls1, -1),
                "Dart_ClassGetInterfaceAt: argument 'index' out of bounds");
   EXPECT_ERROR(Dart_ClassGetInterfaceAt(cls1, 1),
                "Dart_ClassGetInterfaceAt: argument 'index' out of bounds");
 
   len = -1;
   EXPECT_VALID(Dart_ClassGetInterfaceCount(cls2, &len));
   EXPECT_EQ(2, len);
 
   // TODO(turnidge): The test relies on the ordering here.  Sort this.
-  CHECK_INTERFACE(Dart_ClassGetInterfaceAt(cls2, 0), "MyInterface0");
-  CHECK_INTERFACE(Dart_ClassGetInterfaceAt(cls2, 1), "MyInterface1");
+  CHECK_ABSTRACT_CLASS(Dart_ClassGetInterfaceAt(cls2, 0), "MyInterface0");
+  CHECK_ABSTRACT_CLASS(Dart_ClassGetInterfaceAt(cls2, 1), "MyInterface1");
 
   len = -1;
   EXPECT_VALID(Dart_ClassGetInterfaceCount(intf0, &len));
   EXPECT_EQ(0, len);
 
   len = -1;
   EXPECT_VALID(Dart_ClassGetInterfaceCount(intf1, &len));
   EXPECT_EQ(1, len);
-  CHECK_INTERFACE(Dart_ClassGetInterfaceAt(intf1, 0), "MyInterface0");
+  CHECK_ABSTRACT_CLASS(Dart_ClassGetInterfaceAt(intf1, 0), "MyInterface0");
 
   // Error cases.
   EXPECT_ERROR(Dart_ClassGetInterfaceCount(Dart_True(), &len),
                "Dart_ClassGetInterfaceCount expects argument 'clazz' to be of "
                "type Class.");
   EXPECT_ERROR(Dart_ClassGetInterfaceCount(Dart_NewApiError("MyError"), &len),
                "MyError");
 }
 
 
@@ skipping 4876 matching lines @@
   Dart_LoadSource(TestCase::lib(), url, source);
 
   dart_args[0] = Dart_NewInteger(1);
   result = Dart_Invoke(lib1, NewString("start"), 1, dart_args);
   EXPECT_VALID(result);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart