}

    private boolean isClassFieldConstructorOrMethod(JApiCompatibility member) {
        return member instanceof JApiClass || member instanceof JApiField || member instanceof JApiConstructor || member instanceof JApiMethod;
    }

    private boolean isInject(JApiCompatibility member) {
        return member instanceof JApiHasAnnotations && isInject((JApiHasAnnotations) member);
    }

        if (member instanceof JApiClass) {
            return isIncubatingClass((JApiClass) member)
        }
        if (member instanceof JApiMethod) {
            return isIncubatingOrOverrideMethod((JApiMethod) member)
        }
        if (member instanceof JApiField) {
            return isIncubatingField((JApiField) member)
        }
        if (member instanceof JApiConstructor) {

    public Violation maybeViolation(final JApiCompatibility member) {
        if (!member.isBinaryCompatible()) {

            removeAnnotationChanges(member);

            if ((member instanceof JApiClass) && member.getCompatibilityChanges().isEmpty()) {
                // A member of the class breaks binary compatibility.
                // That will be handled when the member is passed to `maybeViolation`.
                return null;

            }
        }

    fun getSince(member: JApiCompatibility): SinceTagStatus =
        apiSourceFileFor(member).let { apiSourceFile ->
            when (apiSourceFile) {
                is ApiSourceFile.Java -> sources.executeQuery(apiSourceFile, JavaSourceQueries.getSince(member))
                is ApiSourceFile.Kotlin -> sources.executeQuery(apiSourceFile, KotlinSourceQueries.getSince(member))
            }
        }

    private

 *     31.0)
 */
public abstract class Invokable<T, R> implements AnnotatedElement, Member {
  private final AccessibleObject accessibleObject;
  private final Member member;

  <M extends AccessibleObject & Member> Invokable(M member) {
    checkNotNull(member);
    this.accessibleObject = member;
    this.member = member;
  }

  /** Returns {@link Invokable} of {@code method}. */

  }

  @J2ktIncompatible
  @GwtIncompatible // Only used by @GwtIncompatible code
  private static class MultisetHolder implements Serializable {
    private final Multiset<?> member;

    MultisetHolder(Multiset<?> multiset) {
      this.member = multiset;
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 1L;
  }

  @J2ktIncompatible

    }

    Violation maybeViolation(final JApiCompatibility member) {
        if (!(member instanceof JApiClass)) {
            return null
        }

        if (!changed(member)) {
            return null
        }

        Optional<CtClass> oldClass = member.oldClass
        Optional<CtClass> newClass = member.newClass
        if (!oldClass.isPresent() || !newClass.isPresent()) {

  }

  @J2ktIncompatible
  @GwtIncompatible // Only used by @GwtIncompatible code
  private static class MultisetHolder implements Serializable {
    private final Multiset<?> member;

    MultisetHolder(Multiset<?> multiset) {
      this.member = multiset;
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 1L;
  }

  @J2ktIncompatible

        interfaces = ['internal': internalInterface,
                      'incubating': incubatingInterface]
    }

    def "#member change should not be reported"() {
        expect:
        noViolation(rule)

        where:
        member << [Mock(JApiMethod), Mock(JApiField), Mock(JApiImplementedInterface), Mock(JApiConstructor)]
    }

    def "nothing should be reported if no changes"() {

    get() = when (this) {
        is JApiClass -> this
        is JApiField -> this.getjApiClass()
        is JApiBehavior -> this.getjApiClass()
        else -> error("Unsupported japicmp member type '${this::class}'")
    }


internal
val JApiClass.isKotlin: Boolean
    get() = newClass.orElse(null)?.isKotlin ?: false


internal
val JApiClass.simpleName: String