}
        return extractOriginalTypeFromGeneric(method, method.getReturnType());
    }

    private static Type extractOriginalTypeFromGeneric(ExecutableElement method, TypeMirror typeMirror) {
        String typeName = method.getReturnType() instanceof DeclaredType
            ? ((DeclaredType) method.getReturnType()).asElement().toString()
            : method.getReturnType().toString();

        return typeMirror.accept(new TypeMirrorToType(), null);
    }

    public static Type extractReturnType(ExecutableElement methodElement) {
        return extractType(methodElement.getReturnType());
    }

    public static String extractMethodDescriptor(ExecutableElement methodElement) {
        return Type.getMethodDescriptor(
            extractReturnType(methodElement),

        }
    }

    protected boolean isVoidMethod(MethodRuleDefinition<?, ?> ruleDefinition) {
        return ruleDefinition.getReturnType().equals(VOID);
    }

        this.beanDesc = beanDesc;
        this.method = method;
        methodName = method.getName();
        parameterTypes = method.getParameterTypes();
        returnType = method.getReturnType();
        parameterizedClassDescs = new ParameterizedClassDesc[parameterTypes.length];
        for (int i = 0; i < parameterTypes.length; ++i) {

    public static String interceptedJvmMethodName(CallableInfo callableInfo) {
        if (callableInfo.getKind() == CallableKindInfo.GROOVY_PROPERTY_GETTER) {
            return getterName(callableInfo.getCallableName(), callableInfo.getReturnType().getType());
        }
        if (callableInfo.getKind() == CallableKindInfo.GROOVY_PROPERTY_SETTER) {
            return setterName(callableInfo.getCallableName());
        }

    String getMethodName();

    boolean isAnnotationPresent(Class<? extends Annotation> annotationType);

    @Nullable
    <A extends Annotation> A getAnnotation(Class<A> annotationType);

    ModelType<R> getReturnType();

    List<ModelReference<?>> getReferences();

    List<List<Annotation>> getParameterAnnotations();

    @Nullable
    ModelReference<S> getSubjectReference();

        return owner;
    }

    @Override
    public String getCallableName() {
        return callableName;
    }

    @Override
    public CallableReturnTypeInfo getReturnType() {
        return returnType;
    }

    @Override
    public List<ParameterInfo> getParameters() {
        return parameters;
    }

 */
public final class MethodSignature {
    public static MethodSignature from(Method method) {
        return new MethodSignature(method.getName(), MethodType.methodType(
            method.getReturnType(),
            method.getParameterTypes()
        ));
    }

    private final String methodName;
    private final MethodType methodType;

        section.setAttribute("role", "detail");

        Element title = document.createElement("title");
        section.appendChild(title);
        title.appendChild(linkRenderer.link(methodDoc.getMetaData().getReturnType(), listener));
        title.appendChild(document.createTextNode(" "));
        Element literal = document.createElement("literal");
        title.appendChild(literal);

  public final <R1 extends R> Invokable<T, R1> returning(TypeToken<R1> returnType) {
    if (!returnType.isSupertypeOf(getReturnType())) {
      throw new IllegalArgumentException(
          "Invokable is known to return " + getReturnType() + ", not " + returnType);
    }
    @SuppressWarnings("unchecked") // guarded by previous check
    Invokable<T, R1> specialized = (Invokable<T, R1>) this;