}
        JApiMethod jApiMethod = (JApiMethod) jApiCompatibility;
        Map<UpgradedAccessorKey, UpgradedAccessor> oldMethods = context.getUserData(OLD_ACCESSORS_OF_UPGRADED_PROPERTIES);
        UpgradedAccessorKey key = UpgradedAccessorKey.ofOldMethod(jApiMethod);
        return oldMethods.containsKey(key) ? Optional.of(key) : Optional.empty();
    }

        def metadata = KotlinMetadataQueries.INSTANCE

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

        def oldIsOperator = metadata.isKotlinOperatorFunction(oldMethod)
        def newIsOperator = metadata.isKotlinOperatorFunction(newMethod)

        def oldIsInfix = metadata.isKotlinInfixFunction(oldMethod)
        def newIsInfix = metadata.isKotlinInfixFunction(newMethod)

        } else if (member instanceof JApiMethod) {

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

            inspectParametersNullabilityOf(oldMethod, newMethod)

            def oldNullability = oldMethod.annotations.any { isNullableCtAnnotation(it) }

        Set<CtMethod> oldMethods = collectAllPublicApiMethods(oldClass.superclass)
        Set<CtMethod> newMethods = collectAllPublicApiMethods(newClass.superclass)

        oldMethods.removeAll(newMethods)

        if (oldMethods.isEmpty()) {
            return null
        }

        List<String> changes = filterChangesToReport(oldClass, oldMethods)
        if (changes.isEmpty()) {
            return null

    }

    /**
     * A method that returns String.
     */
    String stringMethod(String stringParam) {
        return "value";
    }

    /**
     * A method that returns void.
     */
    void voidMethod() {
    }

    /**
     * A method that returns a reference type.
     */
    CombinedInterface refTypeMethod(JavaInterface refParam, boolean aFlag) {
        return null;
    }

    /**

        }

        MethodMetaData method = findMethod(methodSignature, targetClass);
        if (method == null) {
            return null;
        }

        return linkRenderer.link(method, listener);
    }

    private MethodMetaData findMethod(String name, ClassMetaData targetClass) {
        List<MethodMetaData> candidates = new ArrayList<MethodMetaData>();

    }

    /**
     * A method that returns String.
     */
    String stringMethod(String stringParam) {
        'value'
    }

    /**
     * A method that returns void.
     */
    void voidMethod() {
    }

    /**
     * A method that returns a reference type.
     */
    public final CombinedInterface refTypeMethod(JavaInterface someThing, boolean aFlag) {
        null
    }

    /**

        MethodLinkMetaData methodMetaData = findMethod(method);
        String urlFragment = methodMetaData.getUrlFragment(className);
        String displayName = String.format("%s.%s", simpleName, methodMetaData.getDisplayName());
        return new LinkMetaData(methodMetaData.style, displayName, urlFragment);
    }

    private MethodLinkMetaData findMethod(String method) {
        if (method.endsWith("...)")) {

            String containingType = jApiMethod.getjApiClass().getFullyQualifiedName();
            return new UpgradedAccessorKey(containingType, name, descriptor);
        }

        public static UpgradedAccessorKey ofOldMethod(JApiMethod jApiMethod) {
            String name = jApiMethod.getName();
            String descriptor = jApiMethod.getOldMethod().get().getSignature();

      return new BadEquals();
    }

    // primitive ignored
    public int returnsInt() {
      throw new UnsupportedOperationException();
    }

    // void ignored
    public void voidMethod() {
      throw new UnsupportedOperationException();
    }

    // non-public method ignored
    static Object badButNotPublic() {
      return new BadEquals();
    }
  }