}

        return false;
    }

    private static boolean isOldSetterOfUpgradedProperty(JApiMethod jApiMethod, Map<AccessorKey, ReplacedAccessor> upgradedMethods) {
        return isOldMethod(jApiMethod, upgradedMethods, SETTER_REGEX);
    }

    }

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

    private boolean isOverrideMethod(JApiCompatibility member) {
        return member instanceof JApiMethod && isOverride((JApiMethod) member);
    }

    /**

        given:
        def rule = withContext(new SinceAnnotationRule([:]))
        def jApiMethod = Stub(JApiMethod)
        jApiMethod.name >> implicitMethod
        jApiMethod.jApiClass >> jApiClassifier
        jApiMethod.parameters >> paramTypes.collect { paramStub(it) }

        when:
        sourceFile.text = """
            public enum $TEST_INTERFACE_SIMPLE_NAME {

            String descriptor = jApiMethod.getNewMethod().get().getSignature();
            String containingType = jApiMethod.getjApiClass().getFullyQualifiedName();
            return new AccessorKey(containingType, newName, descriptor);
        }


        public static AccessorKey ofNewMethod(JApiMethod jApiMethod) {
            String name = jApiMethod.getName();

    }

    @Override
    Violation maybeViolation(JApiCompatibility member) {

        if (isNewOrRemoved(member) || !(member instanceof JApiMethod)) {
            return null
        }

        JApiMethod method = (JApiMethod) member

        def metadata = KotlinMetadataQueries.INSTANCE

        def oldMethod = method.oldMethod.get()
        def newMethod = method.newMethod.get()

        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) {

private
fun JApiMethod.isEnumImplicitMethod(): Boolean =
    isEnumImplicitMethodValues() ||
        isEnumImplicitMethodValueOf()


private
fun JApiMethod.isEnumImplicitMethodValueOf(): Boolean {
    return name == "valueOf" && parameters.size == 1 && parameters.first().type == "java.lang.String"
}


private
fun JApiMethod.isEnumImplicitMethodValues(): Boolean {

            JApiConstructor ctor = (JApiConstructor) member
            inspectParametersNullabilityOf(ctor.oldConstructor.get(), ctor.newConstructor.get())

        } else if (member instanceof JApiMethod) {

            JApiMethod method = (JApiMethod) member
            CtMethod oldMethod = method.oldMethod.get()
            CtMethod newMethod = method.newMethod.get()

            inspectParametersNullabilityOf(oldMethod, newMethod)

import japicmp.model.JApiClass;
import japicmp.model.JApiCompatibility;
import japicmp.model.JApiConstructor;
import japicmp.model.JApiField;
import japicmp.model.JApiHasAnnotations;
import japicmp.model.JApiMethod;
import me.champeau.gradle.japicmp.report.Violation;

import java.util.Map;

public class IncubatingMissingRule extends AbstractGradleViolationRule {

    public IncubatingMissingRule(Map<String, Object> params) {

import gradlebuild.binarycompatibility.sources.SinceTagStatus
import gradlebuild.binarycompatibility.sources.SourcesRepository
import japicmp.model.JApiClass
import japicmp.model.JApiCompatibility
import japicmp.model.JApiMethod
import javassist.bytecode.SourceFileAttribute
import java.io.File


/**
 * Repository of sources for binary compatibility checks.
 *
 * `WARN` Holds resources open for performance, must be closed after use.