Don't create parameter records when there are no parameters for error

Author: Pritham Marupaka

conjure-java-core/src/integrationInput/java/com/palantir/another/EndpointSpecificErrors.java

@@ -179,8 +179,9 @@ default boolean excludeDialogueAsyncInterfaces() {
     }
 
     /**
-     * TODO(pm): flesh this out more. For errors associated with endpoints, this option enables the generated Dialogue
-     *  clients to return a result type.
+     * If enabled, endpoints that have associated errors will return a result type: a sealed interface permitting
+     * subclasses for the endpoint's return value, and each endpoint error. Each endpoint error is a subclass of
+     * {@link com.palantir.conjure.java.lib.internal.ConjureErrors.BaseEndpointError}.
      */
     @Value.Default
     default boolean generateDialogueEndpointErrorResultTypes() {

conjure-java-core/src/integrationInput/java/com/palantir/product/EndpointSpecificTwoErrors.java

@@ -120,7 +120,7 @@ public MethodSpec generate(ServiceDefinition def) {
                                     Packages.getPrefixedPackage(
                                             def.getServiceName().getPackage(), options.packagePrefix()),
                                     className.simpleName(),
-                                    ErrorGenerationUtils.responseTypeName(endpoint.getEndpointName())),
+                                    ErrorGenerationUtils.endpointResponseResultTypeName(endpoint.getEndpointName())),
                             endpoint,
                             endpoint.getEndpointName(),
                             endpoint.getReturns())
@@ -178,16 +178,19 @@ private Optional<FieldSpec> serializer(EndpointName endpointName, Type type) {
     private Optional<FieldSpec> deserializer(
             TypeName responseType, EndpointDefinition endpointDef, EndpointName endpointName, Optional<Type> type) {
         TypeName className = Primitives.box(returnTypes.baseType(type));
-        if (isBinaryOrOptionalBinary(className, returnTypes) && !options.generateDialogueEndpointErrorResultTypes()) {
+        boolean generateResultTypes = shouldGenerateDialogueEndpointErrorResultTypesForEndpoint(options, endpointDef);
+
+        if (isBinaryOrOptionalBinary(className, returnTypes) && !generateResultTypes) {
             return Optional.empty();
         }
-        ParameterizedTypeName deserializerType =
-                ParameterizedTypeName.get(ClassName.get(Deserializer.class), responseType);
+
+        ParameterizedTypeName deserializerType = ParameterizedTypeName.get(
+                ClassName.get(Deserializer.class), generateResultTypes ? responseType : className);
 
         CodeBlock initializer = CodeBlock.of(
                 "$L.bodySerDe().$L",
                 StaticFactoryMethodGenerator.RUNTIME,
-                options.generateDialogueEndpointErrorResultTypes()
+                generateResultTypes
                         ? constructDeserializerWithEndpointErrors(endpointDef, className, responseType)
                         : constructDeserializer(type, className));
 
@@ -208,16 +211,14 @@ private CodeBlock constructDeserializerWithEndpointErrors(
         CodeBlock.Builder deserializerArgsBuilder = CodeBlock.builder()
                 .add("$T.<$T>builder()", DeserializerArgs.class, responseType)
                 .add(".baseType(new $T<>() {})", TypeMarker.class)
-                // TODO(pm): consider making "Success" a constant string for re-use in the record creation.
                 .add(".success(new $T<$T.Success>() {})", TypeMarker.class, responseType);
         for (EndpointError err : endpointDef.getErrors()) {
             ErrorTypeName errorTypeName = err.getError();
             String errorName = errorTypeName.getName();
-            String errorType = CaseFormat.UPPER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, errorName);
             ClassName errorClass = ClassName.get(
                     errorTypeName.getPackage(),
                     ErrorGenerationUtils.errorTypesClassName(errorTypeName.getNamespace()),
-                    errorType);
+                    CaseFormat.UPPER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, errorName));
             deserializerArgsBuilder.add(
                     ".error($T.name(), new $T<$T.$L>() {})", errorClass, TypeMarker.class, responseType, errorName);
         }
@@ -239,6 +240,12 @@ private static boolean isBinaryOrOptionalBinary(TypeName className, ReturnTypeMa
         return isBinary(className, returnTypes) || isOptionalBinary(className, returnTypes);
     }
 
+    private static boolean shouldGenerateDialogueEndpointErrorResultTypesForEndpoint(
+            Options options, EndpointDefinition endpointDefinition) {
+        return options.generateDialogueEndpointErrorResultTypes()
+                && !endpointDefinition.getErrors().isEmpty();
+    }
+
     private static boolean isBinary(TypeName className, ReturnTypeMapper returnTypes) {
         return className.equals(returnTypes.baseType(Type.primitive(PrimitiveType.BINARY)));
     }
@@ -280,13 +287,14 @@ private MethodSpec clientImpl(ClassName className, EndpointDefinition def) {
                 .build();
         String codeBlock = methodType.switchBy(
                 "$L.clients().callBlocking($L, $L.build(), $L);", "$L.clients().call($L, $L.build" + "(), $L);");
+        boolean generateResultTypes = shouldGenerateDialogueEndpointErrorResultTypesForEndpoint(options, def);
         CodeBlock execute = CodeBlock.of(
                 codeBlock,
                 StaticFactoryMethodGenerator.RUNTIME,
                 Names.endpointChannel(def),
                 REQUEST,
                 def.getReturns()
-                        .filter(type -> !options.generateDialogueEndpointErrorResultTypes()
+                        .filter(type -> !generateResultTypes
                                 && isBinaryOrOptionalBinary(returnTypes.baseType(type), returnTypes))
                         .map(type -> StaticFactoryMethodGenerator.RUNTIME
                                 + (isOptionalBinary(returnTypes.baseType(type), returnTypes)
@@ -295,27 +303,22 @@ && isBinaryOrOptionalBinary(returnTypes.baseType(type), returnTypes))
                         .orElseGet(() -> def.getEndpointName().get() + "Deserializer"));
 
         methodBuilder.addCode(request);
-        methodBuilder.addCode(methodType.switchBy(
-                def.getReturns().isPresent()
-                                || (options.generateDialogueEndpointErrorResultTypes()
-                                        && !def.getErrors().isEmpty())
-                        ? "return "
-                        : "",
-                "return "));
+        methodBuilder.addCode(
+                methodType.switchBy(def.getReturns().isPresent() || generateResultTypes ? "return " : "", "return "));
         methodBuilder.addCode(execute);
 
         return methodBuilder.build();
     }
 
     private TypeName getReturnType(EndpointDefinition def, ClassName className) {
-        if (options.generateDialogueEndpointErrorResultTypes()
-                && !def.getErrors().isEmpty()) {
-            ClassName returnType = ClassName.get(
+        if (shouldGenerateDialogueEndpointErrorResultTypesForEndpoint(options, def)) {
+            ClassName responseResultTypeName = ClassName.get(
                     className.packageName(),
                     className.simpleName(),
-                    ErrorGenerationUtils.responseTypeName(def.getEndpointName()));
+                    ErrorGenerationUtils.endpointResponseResultTypeName(def.getEndpointName()));
             return methodType.switchBy(
-                    returnType, ParameterizedTypeName.get(ClassName.get(ListenableFuture.class), returnType));
+                    responseResultTypeName,
+                    ParameterizedTypeName.get(ClassName.get(ListenableFuture.class), responseResultTypeName));
         }
         return methodType.switchBy(returnTypes.baseType(def.getReturns()), returnTypes.async(def.getReturns()));
     }