Lines Matching defs:interface
556 // Create array interface entries to populate once we can load system classes.
3146 // Interface object should get the right size here. Regular class will
4237 // there. Do this by clearing the interface list so the GC will just
4253 // Arrays can't be used as a superclass or interface, so we want to add "abstract final"
4254 // and remove "interface".
4568 // recursive initialization by themselves. This is because when an interface is initialized
4585 // We had a hard failure while verifying this interface. Just return immediately.
5074 // Set the original interface method.
5089 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
5302 // We have already done this for this interface. Skip it.
5306 // interfaces with default methods are initialized. Non-default interface initialization
5465 // Mark that this interface has undergone recursive default interface initialization so we know we
5467 // interface since we can still avoid the traversal. This is purely a performance optimization.
5471 // interface. It is bad (Java) style, but not impossible. Marking the recursive
5543 super_klass->IsInterface() ? "interface" : "superclass",
5565 super_klass->IsInterface() ? "interface" : "superclass",
5579 super_klass->IsInterface() ? "interface" : "superclass",
6007 ObjPtr<mirror::Class> interface = ResolveType(idx, klass.Get());
6008 if (interface == nullptr) {
6013 if (!klass->CanAccess(interface)) {
6016 "Interface %s implemented by class %s is inaccessible",
6017 interface->PrettyDescriptor().c_str(),
6058 "Superclass %s of %s is an interface",
6116 // Link virtual methods then interface methods.
6117 // We set up the interface lookup table first because we need it to determine if we need to update
6253 ThrowClassFormatError(klass.Get(), "Too many methods on interface: %zu", num_virtual_methods);
6481 // - ifstart: The index of the interface we are checking to see if anything overrides
6482 // - iface: The interface we are checking to see if anything overrides.
6487 // - True: There is some method that matches the target comparator defined in an interface that
6489 // - False: There is no method that matches the target comparator in any interface that is a subtype
6510 // Skip ifstart since our current interface obviously cannot override itself.
6512 // Iterate through every method on this interface. The order does not matter.
6516 // Check if the i'th interface is a subtype of this one.
6542 // We organize the interface table so that, for interface I any subinterfaces J follow it in the
6568 // Iterate through every declared method on this interface. The order does not matter.
6580 LOG(WARNING) << "Interface method " << current_method->PrettyMethod()
6588 // default implementation or is overridden by a non-default interface method. In either case
6604 break; // Continue checking at the next interface.
6614 // Don't set this as the chosen interface if something else is overriding it (because that
6615 // other interface would be potentially chosen instead if it was default). If the other
6616 // interface was abstract then we wouldn't select this interface as chosen anyway since
6694 // This is an interface implemented by a super-class. Therefore we can just copy the method
6702 // If we are working on a super interface, try extending the existing method array.
6834 ObjPtr<mirror::Class> interface = if_table->GetInterface(i);
6835 const size_t num_virtuals = interface->NumVirtualMethods();
6843 DCHECK_EQ(interface->NumDeclaredVirtualMethods(), method_array_count);
6857 // Miranda methods cannot be used to implement an interface method, but they are safe to put
6858 // in the IMT since their entrypoint is the interface trampoline. If we put any copied methods
6859 // or interface methods in the IMT here they will not create extra conflicts since we compare
6861 ArtMethod* interface_method = interface->GetVirtualMethod(j, image_pointer_size_);
6864 // There is only any conflicts if all of the interface methods for an IMT slot don't have
6901 ObjPtr<mirror::Class> interface = if_table->GetInterface(i);
6915 ArtMethod* interface_method = interface->GetVirtualMethod(j, image_pointer_size_);
6947 // Fills in and flattens the interface inheritance hierarchy.
6950 // the iftable and every interface precedes all of its sub-interfaces in this list.
6952 // all I, J: Interface | I <: J implies J precedes I
6960 // interfaces are added in subclass's interface tables.
6981 for (ObjPtr<mirror::Class> interface : to_process) {
6989 if (!ContainsElement(classes_in_iftable, interface)) {
6990 // We haven't seen this interface so add all of its super-interfaces onto the
6992 int32_t ifcount = interface->GetIfTableCount();
6994 ObjPtr<mirror::Class> super_interface = interface->GetIfTable()->GetInterface(j);
7002 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, interface)) << "Bad ordering";
7003 // Place this interface onto the current-iface-list after all of its super-interfaces.
7004 classes_in_iftable.insert(interface);
7005 iftable->SetInterface(filled_ifcount, interface);
7009 int32_t ifcount = interface->GetIfTableCount();
7011 ObjPtr<mirror::Class> super_interface = interface->GetIfTable()->GetInterface(j);
7014 << ", a superinterface of " << interface->PrettyClass();
7026 << "Bad interface order: " << mirror::Class::PrettyClass(if_a) << " (index " << i
7029 << "interface list.";
7069 // Check that every class being implemented is an interface.
7071 ObjPtr<mirror::Class> interface = have_interfaces
7074 DCHECK(interface != nullptr);
7075 if (UNLIKELY(!interface->IsInterface())) {
7078 "Class %s implements non-interface class %s",
7080 PrettyDescriptor(interface->GetDescriptor(&temp)).c_str());
7083 ifcount += interface->GetIfTableCount();
7085 // Create the interface function table.
7110 ObjPtr<mirror::Class> interface = have_interfaces ? interfaces->Get(i) :
7112 to_add.push_back(interface);
7563 // Note that we do this even if we are an interface since we need to create this and
7593 // would make lookup for interface super much faster. (We would only need to scan
7639 // Point the interface table at a phantom slot.
7707 // interface but will have different ArtMethod*s for them. This also means we cannot compare a
7708 // default method found on a class with one found on the declaring interface directly and must
7752 // (possibly default) interface method. We need to set it entry point to be the bridge so
7830 // Normal default method (changed from an older default or abstract interface method).
7960 // looking for the implementation of a super-interface method but that is rather dirty.
7963 // If we are overwriting a super class interface, try to only virtual methods instead of the
7969 // For a new interface, however, we need the whole vtable in case a new
7970 // interface method is implemented in the whole superclass.
7977 // For each method in interface
7984 // For each method listed in the interface's method list, find the
8009 "Method '%s' implementing interface method '%s' is not public",
8050 // there. We don't bother if this is not a super-classes interface since in that case we
8060 // in some class). Therefore move onto the next interface method.
8084 // interface we searched the entire vtable (and all default methods) for an
8100 } // For each method in interface end.
8102 } // For each interface.
8103 // TODO don't extend virtuals of interface unless necessary (when is it?).
8564 // If there was an interface method with the same signature, we would have
8565 // found it in the "copied" methods. Only DCHECK that the interface method
9159 // class of the resolved method which may be super class or default interface method
