protected void checkMethod(MethodInfo methodInfo) { List<MethodInfo> methodsByName = methodMap.get(methodInfo.getName()); if (methodsByName != null) { // Overloaded methods must have same return type for (MethodInfo meth: methodsByName) { if (!meth.isContainingAnyJavaType() && !meth.getReturnType().equals(methodInfo.getReturnType())) { throw new GenException(this.modelElt, "Overloaded method " + methodInfo.getName() + " must have the same return type " + meth.getReturnType() + " != " + methodInfo.getReturnType()); } } } }
public static String invokeMethod(String target, TypeInfo type, MethodInfo method, Collection<TypeParamInfo> typeParams) { if (method.getReturnType().getKind() == ClassKind.OBJECT) { String ret = "toScala[" + method.getReturnType().getName() + "](" + invokeMethodWithoutConvertingReturn(target, type, method, typeParams) + ")"; if (method.getReturnType().isNullable()) return "scala.Option(" + ret + ")"; return ret; } else { return toScalaWithConversion(invokeMethodWithoutConvertingReturn(target, type, method, typeParams), method.getReturnType(), typeParams, method.getTypeParams()); } }
public static boolean shouldMethodReturnAFuture(MethodInfo method) { int size = method.getParams().size(); return size > 0 && isLastParamAsyncResultHandler(method) && !(method.getReturnType().getKind() == ClassKind.HANDLER); }
@Override protected void genRxMethod(ClassModel model, MethodInfo method, PrintWriter writer) { MethodInfo futMethod = genFutureMethod(method); ClassTypeInfo raw = futMethod.getReturnType().getRaw(); String methodSimpleName = raw.getSimpleName(); String adapterType = "io.vertx.reactivex.impl.AsyncResult" + methodSimpleName + ".to" + methodSimpleName; String rxType = raw.getName(); startMethodTemplate(model.getType(), futMethod, "", writer); writer.println(" { "); writer.print(" return "); writer.print(adapterType); writer.println("(handler -> {"); writer.print(" "); writer.print(method.getName()); writer.print("("); List<ParamInfo> params = futMethod.getParams(); writer.print(params.stream().map(ParamInfo::getName).collect(Collectors.joining(", "))); if (params.size() > 0) { writer.print(", "); } writer.println("handler);"); writer.println(" });"); writer.println(" }"); writer.println(); }
public static String invokeStaticMethod(String target, TypeInfo type, MethodInfo method) { /*class level typeparams aren"t needed for static methods*/ List<TypeParamInfo> typeParams = Collections.emptyList(); String paramString = String.join(", ", method.getParams().stream() .map(param -> toJavaWithConversion(escapeIfKeyword(param.getName()), param.getType(), typeParams, method.getTypeParams())) .collect(Collectors.toList())); String typeParamString = ""; if (!method.getTypeParams().isEmpty()) { typeParamString = String.join(", ", method.getTypeParams().stream() .map(param -> "Object") .collect(Collectors.toList())); typeParamString = "[" + typeParamString + "]"; } return toScalaWithConversion(target + "." + escapeIfKeyword(method.getName()) + typeParamString + "(" + paramString + ")", method.getReturnType(), typeParams, method.getTypeParams()); }
private boolean generateFilter(MethodInfo it) { MethodKind methodKind = it.getKind(); return !it.isDeprecated() && (it.isFluent() || it.getReturnType().isVoid()) && methodKind == MethodKind.FUTURE; }
if (!method.getReturnType().getName().equals("void")) { writer.print(" * @return "); if (method.getReturnDescription() != null) { writer.print(" "); writer.print(genTypeName(method.getReturnType())); writer.print(" "); writer.print(method.getName());
if (!method.getReturnType().getName().equals("void")) { writer.print(" * @return "); if (method.getReturnDescription() != null) { writer.print(" "); writer.print(genTypeName(method.getReturnType())); writer.print(" "); writer.print(method.getName());
private void generateDoc(ClassModel model, MethodInfo method, PrintWriter writer) { Doc doc = method.getDoc(); if (doc != null) { writer.print("/**\n"); Token.toHtml(doc.getTokens(), " *", KotlinCodeGenHelper::renderLinkToHtml, "\n", writer); writer.print(" *\n"); method.getParams() .stream() .limit(method.getParams().size() - 1) .forEach(p -> { writer.print(" * @param " + p.getName() + " "); if (p.getDescription() != null) { String docInfo = Token.toHtml(p.getDescription().getTokens(), "", KotlinCodeGenHelper::renderLinkToHtml, ""); writer.print(docInfo); } writer.print("\n"); }); if (!method.getReturnType().isVoid()) { writer.print(" * @return "); if (method.getReturnDescription() != null) { String docInfo = Token.toHtml(method.getReturnDescription().getTokens(), "", KotlinCodeGenHelper::renderLinkToHtml, ""); writer.print(docInfo); } } writer.print(" *\n"); writer.print(" * <p/>\n"); writer.print(" * NOTE: This function has been automatically generated from the [" + model.getType().getName() + " original] using Vert.x codegen.\n"); writer.print(" */\n"); } }
TypeInfo returnType = method.getReturnType(); Text returnDescription = method.getReturnDescription();
private void generateMethod(PrintWriter writer, ClassTypeInfo type, MethodInfo method) { generateDoc(writer, method.getDoc()); if (getOverrideArgs(type.getSimpleName(), method.getName()) != null) { writer.printf(" %s%s%s(%s", method.isStaticMethod() ? "static " : "", method.getName(), genGeneric(method.getTypeParams()), getOverrideArgs(type.getSimpleName(), method.getName())); } else { writer.printf(" %s%s%s(", method.isStaticMethod() ? "static " : "", method.getName(), genGeneric(method.getTypeParams())); boolean more = false; for (ParamInfo param : method.getParams()) { if (more) { writer.print(", "); } writer.printf("%s: %s%s", cleanReserved(param.getName()), genType(param.getType()), param.getType().isNullable() ? " | null | undefined" : ""); more = true; } } if (getOverrideReturn(type.getSimpleName(), method.getName()) != null) { writer.printf(") : %s%s;\n", getOverrideReturn(type.getSimpleName(), method.getName()), method.getReturnType().isNullable() ? " | null" : ""); } else { writer.printf(") : %s%s;\n", genType(method.getReturnType()), method.getReturnType().isNullable() ? " | null" : ""); } } }
@Test public void testInterfaceWithNullableReturnOverride() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi3 = methods.get(0); assertTrue(mi3.getReturnType().isNullable()); }, InterfaceWithNullableReturnOverride.class, InterfaceWithNullableReturnMethod.class); }
@Test public void testMethodWithCovariantNullableReturn() throws Exception { Consumer<ClassModel> check = model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi2 = methods.get(0); assertTrue(mi2.getReturnType().isNullable()); }; generateClass(check, MethodWithCovariantNullableReturn.class, MethodWithNullableReturn.class); generateClass(check, MethodWithCovariantNullableReturn.class); }
private void generateMethods(ProxyModel model, CodeWriter writer) { for (MethodInfo m : model.getMethods()) { if (!m.isStaticMethod()) { writer.code("@Override\n"); writer.code("public "); if (!m.getTypeParams().isEmpty()) { writer.write("<"); writer.writeSeq(m.getTypeParams().stream().map(TypeParamInfo::getName), ", "); writer.write(">"); } writer.write(" " + m.getReturnType().getSimpleName() + " " + m.getName() + "("); writer.writeSeq(m.getParams().stream().map(p -> p.getType().getSimpleName() + " " + p.getName()), ", "); writer.write("){\n"); writer.indent(); if (!((ProxyMethodInfo) m).isProxyIgnore()) generateMethodBody((ProxyMethodInfo) m, writer); if (m.isFluent()) writer.stmt("return this"); writer.unindent(); writer.code("}\n"); } } }
@Override protected void genMethodAdapter(ClassModel model, MethodInfo method, CodeWriter writer) { if (method.getReturnType().getKind() != VOID) { if (method.isFluent()) { writer.format("%s ;\n", genMethodCall(model, method)); writer.format("return %s;\n", method.isStaticMethod() ? model.getType().getSimpleName() : "that"); } else if (method.isCacheReturn()) { writer .format("if (that.cached%s == null) {\n", method.getName()) .indent() .format("that.cached%s = %s;\n", method.getName(), convReturn(model, method, method.getReturnType(), genMethodCall(model, method))) .unindent() .append("}\n") .format("return that.cached%s;\n", method.getName()); } else { writer.format("return %s ;\n", convReturn(model, method, method.getReturnType(), genMethodCall(model, method))); } } else { writer.format("%s;\n", genMethodCall(model, method)); } }
@Test public void testValidHandlerReturn() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithHandlerReturn.class); assertEquals(MethodWithHandlerReturn.class.getName(), model.getIfaceFQCN()); assertEquals(MethodWithHandlerReturn.class.getSimpleName(), model.getIfaceSimpleName()); assertTrue(model.getReferencedTypes().isEmpty()); assertTrue(model.getSuperTypes().isEmpty()); assertEquals(1, model.getMethods().size()); checkMethod(model.getMethods().get(0), "methodWithHandlerStringReturn", 0, new TypeLiteral<Handler<String>>() {}, MethodKind.OTHER); TypeInfo returnType = model.getMethods().get(0).getReturnType(); assertEquals(ClassKind.HANDLER, returnType.getKind()); assertEquals(ClassKind.STRING, ((ParameterizedTypeInfo)returnType).getArg(0).getKind()); }
List<TypeInfo> args = ((ParameterizedTypeInfo) m.getReturnType()).getArgs(); assertTrue("Expects " + m.getName() + " to have nullable return type", args.get(args.size() - 1).isNullable()); });
@Test public void testValidHandlerAsyncResultReturn() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithHandlerAsyncResultReturn.class); assertEquals(MethodWithHandlerAsyncResultReturn.class.getName(), model.getIfaceFQCN()); assertEquals(MethodWithHandlerAsyncResultReturn.class.getSimpleName(), model.getIfaceSimpleName()); assertTrue(model.getReferencedTypes().isEmpty()); assertTrue(model.getSuperTypes().isEmpty()); assertEquals(1, model.getMethods().size()); checkMethod(model.getMethods().get(0), "methodWithHandlerAsyncResultStringReturn", 0, new TypeLiteral<Handler<AsyncResult<String>>>() {}, MethodKind.OTHER); TypeInfo returnType = model.getMethods().get(0).getReturnType(); assertEquals(ClassKind.HANDLER, returnType.getKind()); assertEquals(ClassKind.ASYNC_RESULT, ((ParameterizedTypeInfo)returnType).getArg(0).getKind()); assertEquals(ClassKind.STRING, ((ParameterizedTypeInfo)((ParameterizedTypeInfo)returnType).getArg(0)).getArg(0).getKind()); }
@Test public void testValidClassTypeParams() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithValidClassTypeParams.class); List<MethodInfo> methods = model.getMethods(); assertEquals(2, methods.size()); MethodInfo methodParam = methods.get(0); checkMethod(methodParam, "methodParam", 2, "void", MethodKind.OTHER); ParamInfo resolved = methodParam.resolveClassTypeParam((TypeVariableInfo) methodParam.getParam(0).getType()); assertSame(resolved, methodParam.getParam(1)); MethodInfo returnParam = methods.get(1); checkMethod(returnParam, "returnParam", 1, "T", MethodKind.OTHER); resolved = methodParam.resolveClassTypeParam((TypeVariableInfo) returnParam.getReturnType()); assertSame(resolved, methodParam.getParam(1)); }
void checkMethod(MethodInfo meth, String name, int numParams, String returnType, MethodKind kind, Doc comment, MethodCheck... checks) { EnumSet<MethodCheck> checkSet = EnumSet.noneOf(MethodCheck.class); Collections.addAll(checkSet, checks); assertEquals(name, meth.getName()); if (comment != null) { assertNotNull(meth.getComment()); assertEquals(comment.getFirstSentence(), meth.getDoc().getFirstSentence()); assertEquals(comment.getBody(), meth.getDoc().getBody()); assertEquals(comment.getBlockTags(), meth.getDoc().getBlockTags()); } else { assertNull(meth.getComment()); } assertEquals(kind, meth.getKind()); assertEquals(returnType, meth.getReturnType().toString()); assertEquals(checkSet.contains(MethodCheck.CACHE_RETURN), meth.isCacheReturn()); assertEquals(checkSet.contains(MethodCheck.FLUENT), meth.isFluent()); assertEquals(checkSet.contains(MethodCheck.STATIC), meth.isStaticMethod()); assertEquals(numParams, meth.getParams().size()); }