Remove support for interfaces.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 661 matching lines @@
   RawField* LookupField(const String& name) const;
 
   RawLibraryPrefix* LookupLibraryPrefix(const String& name) const;
 
   void InsertCanonicalConstant(intptr_t index, const Instance& constant) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawClass));
   }
 
-  bool is_interface() const {
-    return InterfaceBit::decode(raw_ptr()->state_bits_);
-  }
-  void set_is_interface() const;
-
   bool is_implemented() const {
     return ImplementedBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_implemented() const;
 
   bool is_abstract() const {
     return AbstractBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_abstract() const;
 
@@ skipping 28 matching lines @@
 
   RawArray* constants() const;
 
   void Finalize() const;
 
   const char* ApplyPatch(const Class& patch) const;
 
   // Allocate a class used for VM internal objects.
   template <class FakeObject> static RawClass* New();
 
-  // Allocate instance classes and interfaces.
+  // Allocate instance classes.
   static RawClass* New(const String& name,
                        const Script& script,
                        intptr_t token_pos);
-  static RawClass* NewInterface(const String& name,
-                                const Script& script,
-                                intptr_t token_pos);
   static RawClass* NewNativeWrapper(const Library& library,
                                     const String& name,
                                     int num_fields);
 
   // Allocate the raw string classes.
   static RawClass* NewStringClass(intptr_t class_id);
 
   // Allocate a class representing a function signature described by
   // signature_function, which must be a closure function or a signature
   // function.
   // The class may be type parameterized unless the signature_function is in a
   // static scope. In that case, the type parameters are copied from the owner
   // class of signature_function.
   static RawClass* NewSignatureClass(const String& name,
                                      const Function& signature_function,
                                      const Script& script);
 
   // Return a class object corresponding to the specified kind. If
   // a canonicalized version of it exists then that object is returned
   // otherwise a new object is allocated and returned.
   static RawClass* GetClass(intptr_t class_id, bool is_signature_class);
 
  private:
   enum {
     kConstBit = 1,
-    kInterfaceBit = 2,
-    kImplementedBit = 3,
-    kAbstractBit = 4,
-    kStateTagBit = 5,
+    kImplementedBit = 2,
+    kAbstractBit = 3,
+    kStateTagBit = 4,
     kStateTagSize = 2,
   };
   class ConstBit : public BitField<bool, kConstBit, 1> {};
-  class InterfaceBit : public BitField<bool, kInterfaceBit, 1> {};
   class ImplementedBit : public BitField<bool, kImplementedBit, 1> {};
   class AbstractBit : public BitField<bool, kAbstractBit, 1> {};
   class StateBits : public BitField<RawClass::ClassState,
                                     kStateTagBit, kStateTagSize> {};  // NOLINT
 
   void set_name(const String& value) const;
   void set_token_pos(intptr_t value) const;
   void set_signature_function(const Function& value) const;
   void set_signature_type(const AbstractType& value) const;
   void set_class_state(RawClass::ClassState state) const;
@@ skipping 67 matching lines @@
 
 // AbstractTypeArguments is an abstract superclass.
 // Subclasses of AbstractTypeArguments are TypeArguments and
 // InstantiatedTypeArguments.
 class AbstractTypeArguments : public Object {
  public:
   // Returns true if both arguments represent vectors of equal types.
   static bool AreEqual(const AbstractTypeArguments& arguments,
                        const AbstractTypeArguments& other_arguments);
 
-  // Returns true if both arguments represent vectors of possibly still
-  // unresolved identical types.
-  static bool AreIdentical(const AbstractTypeArguments& arguments,
-                           const AbstractTypeArguments& other_arguments,
-                           bool check_type_parameter_bounds);
-
   // Return 'this' if this type argument vector is instantiated, i.e. if it does
   // not refer to type parameters. Otherwise, return a new type argument vector
   // where each reference to a type parameter is replaced with the corresponding
   // type of the instantiator type argument vector.
   virtual RawAbstractTypeArguments* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
 
   // Do not canonicalize InstantiatedTypeArguments or NULL objects
   virtual RawAbstractTypeArguments* Canonicalize() const { return this->raw(); }
 
@@ skipping 16 matching lines @@
 
   // Check if this type argument vector would consist solely of DynamicType if
   // it was instantiated from a raw (null) instantiator, i.e. consider each type
   // parameter as it would be first instantiated from a vector of dynamic types.
   // Consider only a prefix of length 'len'.
   bool IsRawInstantiatedRaw(intptr_t len) const {
     return IsDynamicTypes(true, len);
   }
 
   // Check that this type argument vector is within the declared bounds of the
-  // given class or interface. If not, set malformed_error (if not yet set).
+  // given class. If not, set malformed_error (if not yet set).
   bool IsWithinBoundsOf(const Class& cls,
                         const AbstractTypeArguments& bounds_instantiator,
                         Error* malformed_error) const;
 
   // Check the subtype relationship, considering only a prefix of length 'len'.
   bool IsSubtypeOf(const AbstractTypeArguments& other,
                    intptr_t len,
                    Error* malformed_error) const {
     return TypeTest(kIsSubtypeOf, other, len, malformed_error);
   }
@@ skipping 2260 matching lines @@
   virtual RawError* malformed_error() const;
   virtual void set_malformed_error(const Error& value) const;
   virtual bool IsResolved() const;
   virtual bool HasResolvedTypeClass() const;
   virtual RawClass* type_class() const;
   virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawAbstractTypeArguments* arguments() const;
   virtual intptr_t token_pos() const;
   virtual bool IsInstantiated() const;
   virtual bool Equals(const Instance& other) const;
-  virtual bool IsIdentical(const AbstractType& other,
-                           bool check_type_parameter_bound) const;
 
   // Instantiate this type using the given type argument vector.
   // Return a new type, or return 'this' if it is already instantiated.
   virtual RawAbstractType* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
 
   // Return the canonical version of this type.
   virtual RawAbstractType* Canonicalize() const;
 
   // The name of this type, including the names of its type arguments, if any.
@@ skipping 42 matching lines @@
 
   // Check if this type represents the 'num' type.
   bool IsNumberType() const;
 
   // Check if this type represents the 'String' type.
   bool IsStringType() const;
 
   // Check if this type represents the 'Function' type.
   bool IsFunctionType() const;
 
-  // Check if this type is an interface type.
-  bool IsInterfaceType() const {
-    if (!HasResolvedTypeClass()) {
-      return false;
-    }
-    const Class& cls = Class::Handle(type_class());
-    return !cls.IsNull() && cls.is_interface();
-  }
-
   // Check the subtype relationship.
   bool IsSubtypeOf(const AbstractType& other, Error* malformed_error) const {
     return TypeTest(kIsSubtypeOf, other, malformed_error);
   }
 
   // Check the 'more specific' relationship.
   bool IsMoreSpecificThan(const AbstractType& other,
                           Error* malformed_error) const {
     return TypeTest(kIsMoreSpecificThan, other, malformed_error);
   }
@@ skipping 46 matching lines @@
   virtual bool HasResolvedTypeClass() const;  // Own type class resolved.
   virtual RawClass* type_class() const;
   void set_type_class(const Object& value) const;
   virtual RawUnresolvedClass* unresolved_class() const;
   RawString* TypeClassName() const;
   virtual RawAbstractTypeArguments* arguments() const;
   void set_arguments(const AbstractTypeArguments& value) const;
   virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated() const;
   virtual bool Equals(const Instance& other) const;
-  virtual bool IsIdentical(const AbstractType& other,
-                           bool check_type_parameter_bound) const;
   virtual RawAbstractType* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
   virtual RawAbstractType* Canonicalize() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawType));
   }
 
   // The type of the literal 'null'.
   static RawType* NullType();
@@ skipping 15 matching lines @@
 
   // The 'Smi' type.
   static RawType* SmiType();
 
   // The 'Mint' type.
   static RawType* MintType();
 
   // The 'double' type.
   static RawType* Double();
 
-  // The 'num' interface type.
+  // The 'num' type.
   static RawType* Number();
 
   // The 'String' type.
   static RawType* StringType();
 
   // The 'Array' type.
   static RawType* ArrayType();
 
-  // The 'Function' interface type.
+  // The 'Function' type.
   static RawType* Function();
 
   // The finalized type of the given non-parameterized class.
   static RawType* NewNonParameterizedType(const Class& type_class);
 
   static RawType* New(const Object& clazz,
                       const AbstractTypeArguments& arguments,
                       intptr_t token_pos,
                       Heap::Space space = Heap::kOld);
 
@@ skipping 33 matching lines @@
     return raw_ptr()->parameterized_class_;
   }
   RawString* name() const { return raw_ptr()->name_; }
   intptr_t index() const { return raw_ptr()->index_; }
   void set_index(intptr_t value) const;
   RawAbstractType* bound() const { return raw_ptr()->bound_; }
   void set_bound(const AbstractType& value) const;
   virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated() const { return false; }
   virtual bool Equals(const Instance& other) const;
-  virtual bool IsIdentical(const AbstractType& other,
-                           bool check_type_parameter_bound) const;
   virtual RawAbstractType* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
   virtual RawAbstractType* Canonicalize() const { return raw(); }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawTypeParameter));
   }
 
   static RawTypeParameter* New(const Class& parameterized_class,
                                intptr_t index,
@@ skipping 2557 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_