Remove support for interfaces.

runtime/vm/object.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 "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 284 matching lines @@
     sentinel_ = sentinel.raw();
 
     Instance& transition_sentinel = Instance::Handle();
     transition_sentinel ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
     transition_sentinel_ = transition_sentinel.raw();
   }
 
   cls = Class::New<Instance>(kDynamicCid);
   cls.set_is_finalized();
-  cls.set_is_interface();
+  cls.set_is_abstract();
   dynamic_class_ = cls.raw();
 
   // Allocate the remaining VM internal classes.
   cls = Class::New<UnresolvedClass>();
   unresolved_class_class_ = cls.raw();
 
   cls = Class::New<Instance>(kVoidCid);
   cls.set_is_finalized();
   void_class_ = cls.raw();
 
@@ skipping 1461 matching lines @@
 
 
 RawClass* Class::New(const String& name,
                      const Script& script,
                      intptr_t token_pos) {
   Class& result = Class::Handle(New<Instance>(name, script, token_pos));
   return result.raw();
 }
 
 
-RawClass* Class::NewInterface(const String& name,
-                              const Script& script,
-                              intptr_t token_pos) {
-  Class& result = Class::Handle(New<Instance>(name, script, token_pos));
-  result.set_is_interface();
-  return result.raw();
-}
-
-
 RawClass* Class::NewSignatureClass(const String& name,
                                    const Function& signature_function,
                                    const Script& script) {
   ASSERT(!signature_function.IsNull());
   const Class& owner_class = Class::Handle(signature_function.Owner());
   ASSERT(!owner_class.IsNull());
   TypeArguments& type_parameters = TypeArguments::Handle();
   // A signature class extends class Instance and is parameterized in the same
   // way as the owner class of its non-static signature function.
   // It is not type parameterized if its signature function is static.
@@ skipping 102 matching lines @@
   StorePointer(&raw_ptr()->script_, value.raw());
 }
 
 
 void Class::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
   raw_ptr()->token_pos_ = token_pos;
 }
 
 
-void Class::set_is_interface() const {
-  set_state_bits(InterfaceBit::update(true, raw_ptr()->state_bits_));
-}
-
-
 void Class::set_is_implemented() const {
   set_state_bits(ImplementedBit::update(true, raw_ptr()->state_bits_));
 }
 
 
 void Class::set_is_abstract() const {
   set_state_bits(AbstractBit::update(true, raw_ptr()->state_bits_));
 }
 
 
@@ skipping 110 matching lines @@
   // Check for NullType, which is not a subtype of any type, but is more
   // specific than any type.
   if (IsNullClass()) {
     // User code cannot refer to class Null, therefore, we can only encounter
     // NullType here as the type of the null constant, which must be treated
     // separately in 'instance of' checks. Therefore, the NullType can only
     // be encountered here during optimizations in 'more specific than' tests.
     ASSERT(test_kind == kIsMoreSpecificThan);
     return true;
   }
+  // Check for ObjectType. Any type that is not NullType or DynamicType (already
+  // checked above), is more specific than ObjectType.
+  if (other.IsObjectClass()) {
+    return true;
+  }
   // Check for reflexivity.
   if (raw() == other.raw()) {
     const intptr_t len = NumTypeArguments();
     if (len == 0) {
       return true;
     }
     // Since we do not truncate the type argument vector of a subclass (see
     // below), we only check a prefix of the proper length.
     // Check for covariance.
     if (other_type_arguments.IsNull() ||
         other_type_arguments.IsRawInstantiatedRaw(len)) {
       return true;
     }
     if (type_arguments.IsNull() ||
         type_arguments.IsRawInstantiatedRaw(len)) {
       return test_kind == kIsSubtypeOf;
     }
     return type_arguments.TypeTest(test_kind,
                                    other_type_arguments,
                                    len,
                                    malformed_error);
   }
-  // TODO(regis): Check for interface type S implementing method call() of
-  // function type T.
+  // TODO(regis): Check if type S has a call() method of function type T.
   // Check for two function types.
   if (IsSignatureClass() && other.IsSignatureClass()) {
     const Function& fun = Function::Handle(signature_function());
     const Function& other_fun = Function::Handle(other.signature_function());
     return fun.TypeTest(test_kind,
                         type_arguments,
                         other_fun,
                         other_type_arguments,
                         malformed_error);
   }
-  // Check for 'direct super type' in the case of an interface
-  // (i.e. other.is_interface()) or implicit interface (i.e.
-  // !other.is_interface()) and check for transitivity at the same time.
+  // Check for 'direct super type' specified in the implements clause
+  // and check for transitivity at the same time.
   Array& interfaces = Array::Handle(this->interfaces());
   AbstractType& interface = AbstractType::Handle();
   Class& interface_class = Class::Handle();
   AbstractTypeArguments& interface_args = AbstractTypeArguments::Handle();
   for (intptr_t i = 0; i < interfaces.Length(); i++) {
     interface ^= interfaces.At(i);
     interface_class = interface.type_class();
     interface_args = interface.arguments();
     if (!interface_args.IsNull() && !interface_args.IsInstantiated()) {
       // This type class implements an interface that is parameterized with
@@ skipping 21 matching lines @@
       }
     }
     if (interface_class.TypeTest(test_kind,
                                  interface_args,
                                  other,
                                  other_type_arguments,
                                  malformed_error)) {
       return true;
     }
   }
-  // Check the interface case.
-  if (is_interface()) {
-    // We already checked the case where 'other' is an interface. Now, 'this',
-    // an interface, cannot be more specific than a class, except class Object,
-    // because although Object is not considered an interface by the vm, it is
-    // one. In other words, all classes implementing this interface also extend
-    // class Object. An interface is also more specific than the DynamicType.
-    return (other.IsDynamicClass() || other.IsObjectClass());
-  }
   const Class& super_class = Class::Handle(SuperClass());
   if (super_class.IsNull()) {
     return false;
   }
   // Instead of truncating the type argument vector to the length of the super
   // type argument vector, we make sure that the code works with a vector that
   // is longer than necessary.
   return super_class.TypeTest(test_kind,
                               type_arguments,
                               other,
@@ skipping 201 matching lines @@
   const Object& obj = Object::Handle(isolate, lib.LookupLocalObject(name));
   if (!obj.IsNull() && obj.IsLibraryPrefix()) {
     const LibraryPrefix& lib_prefix = LibraryPrefix::Cast(obj);
     return lib_prefix.raw();
   }
   return LibraryPrefix::null();
 }
 
 
 const char* Class::ToCString() const {
-  const char* format = is_interface()
-      ? "%s Interface: %s" : "%s Class: %s";
+  const char* format = "%s Class: %s";
   const Library& lib = Library::Handle(library());
   const char* library_name = lib.IsNull() ? "" : lib.ToCString();
   const char* class_name = String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, library_name, class_name) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, library_name, class_name);
   return chars;
 }
 
 
@@ skipping 181 matching lines @@
   if (arguments.IsNull()) {
     return other_arguments.IsDynamicTypes(false, other_arguments.Length());
   }
   if (other_arguments.IsNull()) {
     return arguments.IsDynamicTypes(false, arguments.Length());
   }
   return arguments.Equals(other_arguments);
 }
 
 
-bool AbstractTypeArguments::AreIdentical(
-    const AbstractTypeArguments& arguments,
-    const AbstractTypeArguments& other_arguments,
-    bool check_type_parameter_bounds) {
-  if (arguments.raw() == other_arguments.raw()) {
-    return true;
-  }
-  if (arguments.IsNull() || other_arguments.IsNull()) {
-    return false;
-  }
-  intptr_t num_types = arguments.Length();
-  if (num_types != other_arguments.Length()) {
-    return false;
-  }
-  AbstractType& type = AbstractType::Handle();
-  AbstractType& other_type = AbstractType::Handle();
-  for (intptr_t i = 0; i < num_types; i++) {
-    type = arguments.TypeAt(i);
-    ASSERT(!type.IsNull());
-    other_type = other_arguments.TypeAt(i);
-    if (!type.IsIdentical(other_type, check_type_parameter_bounds)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-
 RawAbstractTypeArguments* AbstractTypeArguments::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments) const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 bool AbstractTypeArguments::IsDynamicTypes(bool raw_instantiated,
                                            intptr_t len) const {
@@ skipping 1570 matching lines @@
     tokens_iterator.Advance();
   }
   result = result & ((static_cast<uint32_t>(1) << 31) - 1);
   ASSERT(result <= static_cast<uint32_t>(kMaxInt32));
   return result;
 }
 
 
 bool Function::CheckSourceFingerprint(intptr_t fp) const {
   if (SourceFingerprint() != fp) {
-    OS::Print("FP mismatch while recogbnizing method %s:"
+    OS::Print("FP mismatch while recognizing method %s:"
       " expecting %"Pd" found %d\n",
       ToFullyQualifiedCString(),
       fp,
       SourceFingerprint());
     return false;
   }
   return true;
 }
 
 
@@ skipping 2157 matching lines @@
   Error& error = Error::Handle();
   const GrowableObjectArray& libs = GrowableObjectArray::Handle(
       Isolate::Current()->object_store()->libraries());
   Library& lib = Library::Handle();
   Class& cls = Class::Handle();
   for (int i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     ClassDictionaryIterator it(lib);
     while (it.HasNext()) {
       cls ^= it.GetNextClass();
-      if (!cls.is_interface()) {
-        error = Compiler::CompileAllFunctions(cls);
-        if (!error.IsNull()) {
-          return error.raw();
-        }
+      error = Compiler::CompileAllFunctions(cls);
+      if (!error.IsNull()) {
+        return error.raw();
       }
     }
     Array& anon_classes = Array::Handle(lib.raw_ptr()->anonymous_classes_);
     for (int i = 0; i < lib.raw_ptr()->num_anonymous_; i++) {
       cls ^= anon_classes.At(i);
-      ASSERT(!cls.is_interface());
       error = Compiler::CompileAllFunctions(cls);
       if (!error.IsNull()) {
         return error.raw();
       }
     }
   }
   return error.raw();
 }
 
 
@@ skipping 2036 matching lines @@
 }
 
 
 bool AbstractType::Equals(const Instance& other) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
-bool AbstractType::IsIdentical(const AbstractType& other,
-                               bool check_type_parameter_bound) const {
-  // AbstractType is an abstract class.
-  UNREACHABLE();
-  return false;
-}
-
-
 RawAbstractType* AbstractType::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 RawAbstractType* AbstractType::Canonicalize() const {
   // AbstractType is an abstract class.
@@ skipping 403 matching lines @@
   }
   if (type_class() != other_type.type_class()) {
     return false;
   }
   return AbstractTypeArguments::AreEqual(
       AbstractTypeArguments::Handle(arguments()),
       AbstractTypeArguments::Handle(other_type.arguments()));
 }
 
 
-bool Type::IsIdentical(const AbstractType& other,
-                       bool check_type_parameter_bounds) const {
-  if (raw() == other.raw()) {
-    return true;
-  }
-  if (!other.IsType()) {
-    return false;
-  }
-  // Both type classes may not be resolved yet.
-  String& name = String::Handle(TypeClassName());
-  String& other_name = String::Handle(Type::Cast(other).TypeClassName());
-  if (!name.Equals(other_name)) {
-    return false;
-  }
-  return AbstractTypeArguments::AreIdentical(
-      AbstractTypeArguments::Handle(arguments()),
-      AbstractTypeArguments::Handle(other.arguments()),
-      false);  // Bounds are only checked at the top level.
-}
-
-
 RawAbstractType* Type::Canonicalize() const {
   ASSERT(IsFinalized());
   if (IsCanonical() || IsMalformed()) {
     ASSERT(IsMalformed() || AbstractTypeArguments::Handle(arguments()).IsOld());
     return this->raw();
   }
   const Class& cls = Class::Handle(type_class());
   Array& canonical_types = Array::Handle(cls.canonical_types());
   if (canonical_types.IsNull()) {
     // Types defined in the VM isolate are canonicalized via the object store.
@@ skipping 144 matching lines @@
   }
   if (index() != other_type_param.index()) {
     return false;
   }
   const String& type_param_name = String::Handle(name());
   const String& other_type_param_name = String::Handle(other_type_param.name());
   return type_param_name.Equals(other_type_param_name);
 }
 
 
-bool TypeParameter::IsIdentical(const AbstractType& other,
-                                bool check_type_parameter_bound) const {
-  if (raw() == other.raw()) {
-    return true;
-  }
-  if (!other.IsTypeParameter()) {
-    return false;
-  }
-  const TypeParameter& other_type_param = TypeParameter::Cast(other);
-  // IsIdentical may be called on type parameters belonging to different
-  // classes, e.g. to an interface and to its default factory class.
-  // Therefore, both type parameters may have different parameterized classes
-  // and different indices. Compare the type parameter names only, and their
-  // bounds if requested.
-  String& type_param_name = String::Handle(name());
-  String& other_type_param_name = String::Handle(other_type_param.name());
-  if (!type_param_name.Equals(other_type_param_name)) {
-    return false;
-  }
-  if (check_type_parameter_bound) {
-    AbstractType& this_bound = AbstractType::Handle(bound());
-    AbstractType& other_bound = AbstractType::Handle(other_type_param.bound());
-    // Bounds are only checked at the top level.
-    const bool check_type_parameter_bounds = false;
-    if (!this_bound.IsIdentical(other_bound, check_type_parameter_bounds)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-
 void TypeParameter::set_parameterized_class(const Class& value) const {
   // Set value may be null.
   StorePointer(&raw_ptr()->parameterized_class_, value.raw());
 }
 
 
 void TypeParameter::set_index(intptr_t value) const {
   ASSERT(value >= 0);
   raw_ptr()->index_ = value;
 }
@@ skipping 3105 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart