getInterfaces method

List<ResolvableType> getInterfaces()

Returns an array of ResolvableTypes representing the direct interfaces implemented by this type.

This method returns all interfaces that this type directly implements, not including inherited interfaces from supertypes.

Returns:

  • List of ResolvableType instances representing implemented interfaces
  • Empty list if no interfaces are implemented

Example:

// Assuming a class that implements multiple interfaces
class MyList<T> implements List<T>, Comparable<MyList<T>> {
  // Implementation
}

final myListType = ResolvableType.forClass(MyList<String>);
final interfaces = myListType.getInterfaces();

for (final interface in interfaces) {
  print(interface.resolve()?.getType());
}
// Output: List<String>, Comparable<MyList<String>>

// Useful for interface analysis
bool implementsInterface(ResolvableType type, Type interfaceType) {
  final interfaces = type.getInterfaces();
  return interfaces.any((iface) => 
    iface.resolve()?.getType() == interfaceType ||
    iface.as(interfaceType) != ResolvableType.NONE
  );
}

Implementation

List<ResolvableType> getInterfaces() {
  final resolved = resolve();
  if (resolved == null) return _EMPTY_TYPES_ARRAY;

  List<ResolvableType>? interfaces = _interfaces;
  if (interfaces == null) {
    final interfaceClasses = resolved.getAllInterfaces();
    if (interfaceClasses.isNotEmpty) {
      interfaces = interfaceClasses.map((ifc) => forType(ifc.getType(), this)).toList();
    } else {
      interfaces = _EMPTY_TYPES_ARRAY;
    }
    _interfaces = interfaces;
  }
  return interfaces;
}