refactor assignment expr of default value on method arguments

src/main/java/com/google/api/generator/gapic/composer/ServiceClientClassComposer.java

@@ -80,6 +80,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -479,11 +480,11 @@ private static List<MethodDefinition> createServiceMethods(
       Map<String, TypeNode> types,
       Map<String, ResourceName> resourceNames) {
     List<MethodDefinition> javaMethods = new ArrayList<>();
-    String clientName = getClientClassName(service);
     for (Method method : service.methods()) {
       if (method.stream().equals(Stream.NONE)) {
         javaMethods.addAll(
-            createMethodVariants(method, messageTypes, types, clientName, resourceNames));
+            createMethodVariants(
+                method, getClientClassName(service), messageTypes, types, resourceNames));
         javaMethods.add(createMethodDefaultMethod(method, types));
       }
       if (method.hasLro()) {
@@ -499,9 +500,9 @@ private static List<MethodDefinition> createServiceMethods(
 
   private static List<MethodDefinition> createMethodVariants(
       Method method,
+      String clientName,
       Map<String, Message> messageTypes,
       Map<String, TypeNode> types,
-      String clientName,
       Map<String, ResourceName> resourceNames) {
     List<MethodDefinition> javaMethods = new ArrayList<>();
     String methodName = JavaStyle.toLowerCamelCase(method.name());
@@ -564,13 +565,14 @@ private static List<MethodDefinition> createMethodVariants(
               .setReturnType(methodOutputType)
               .build();
 
-      String methodSampleCode = "";
+      Optional<String> methodSampleCode = Optional.empty();
       if (!method.isPaged() && !method.hasLro()) {
         // TODO(summerji): Remove the condition check once finished the implementation on paged
         // sample code and lro sample code.
         methodSampleCode =
-            ServiceClientSampleCodeComposer.composeRpcMethodHeaderSampleCode(
-                method, signature, types.get(clientName), resourceNames);
+            Optional.of(
+                ServiceClientSampleCodeComposer.composeRpcMethodHeaderSampleCode(
+                    method, signature, types.get(clientName), resourceNames));
       }
       MethodDefinition.Builder methodVariantBuilder =
           MethodDefinition.builder()

src/main/java/com/google/api/generator/gapic/composer/ServiceClientCommentComposer.java

@@ -25,6 +25,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -162,17 +163,17 @@ static CommentStatement createCreateMethodStubArgComment(
   }
 
   static List<CommentStatement> createRpcMethodHeaderComment(
-      Method method, List<MethodArgument> methodArguments, String sampleCode) {
+      Method method, List<MethodArgument> methodArguments, Optional<String> sampleCode) {
     JavaDocComment.Builder methodJavadocBuilder = JavaDocComment.builder();
 
     if (method.hasDescription()) {
       methodJavadocBuilder =
           processProtobufComment(method.description(), methodJavadocBuilder, null);
     }
 
-    if (!Strings.isNullOrEmpty(sampleCode)) {
+    if (sampleCode.isPresent()) {
       methodJavadocBuilder.addParagraph(METHOD_DESCRIPTION_SAMPLE_CODE_SUMMARY_STRING);
-      methodJavadocBuilder.addSampleCode(sampleCode);
+      methodJavadocBuilder.addSampleCode(sampleCode.get());
     }
 
     if (methodArguments.isEmpty()) {
@@ -199,7 +200,7 @@ static List<CommentStatement> createRpcMethodHeaderComment(
 
   static List<CommentStatement> createRpcMethodHeaderComment(Method method) {
     // TODO(summerji): Refactor this method when implement default method sample code.
-    return createRpcMethodHeaderComment(method, Collections.emptyList(), "");
+    return createRpcMethodHeaderComment(method, Collections.emptyList(), Optional.empty());
   }
 
   static CommentStatement createMethodNoArgComment(String serviceName) {

src/main/java/com/google/api/generator/gapic/composer/ServiceClientSampleCodeComposer.java

@@ -30,14 +30,15 @@
 import com.google.api.generator.gapic.model.MethodArgument;
 import com.google.api.generator.gapic.model.ResourceName;
 import com.google.api.generator.gapic.utils.JavaStyle;
+import com.google.common.base.Preconditions;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 public class ServiceClientSampleCodeComposer {
-  // TODO(summerji): Add unit tests for ServiceClientSampleCodeComposer.
 
   public static String composeClassHeaderCredentialsSampleCode(
       // TODO(summerji): Add unit tests for composeClassHeaderCredentialsSampleCode.
@@ -185,7 +186,7 @@ public static String composeRpcMethodHeaderSampleCode(
       List<MethodArgument> arguments,
       TypeNode clientType,
       Map<String, ResourceName> resourceNames) {
-    // TODO(summerji): Add Other types RPC methods' sample code.
+    // TODO(summerji): Add other types RPC methods' sample code.
     return SampleCodeWriter.write(
         composeUnaryRpcMethodSampleCode(method, arguments, clientType, resourceNames));
   }
@@ -201,38 +202,88 @@ public static TryCatchStatement composeUnaryRpcMethodSampleCode(
                 .setName(JavaStyle.toLowerCamelCase(clientType.reference().name()))
                 .setType(clientType)
                 .build());
-    // Assign each method arguments with its default value.
-    List<Expr> methodArgExprs = createMethodArgVarExprs(arguments, resourceNames);
-    List<Expr> bodyExpr =
-        assignMethodArgumentsWithDefaultValues(arguments, methodArgExprs, resourceNames);
+    // List of rpc method arguments' variable expressions.
+    List<Expr> rpcMethodArgVarExprs =
+        arguments.stream()
+            .map(
+                arg ->
+                    VariableExpr.withVariable(
+                        Variable.builder()
+                            .setName(JavaStyle.toLowerCamelCase(arg.name()))
+                            .setType(arg.type())
+                            .build()))
+            .collect(Collectors.toList());
+    // List of rpc method arguments' default value expression.
+    List<ResourceName> resourceNameList =
+        resourceNames.values().stream().collect(Collectors.toList());
+    List<Expr> rpcMethodArgDefaultValueExprs =
+        arguments.stream()
+            .map(
+                arg ->
+                    !isStringTypedResourceName(arg, resourceNames)
+                        ? DefaultValueComposer.createDefaultValue(arg, resourceNames)
+                        : MethodInvocationExpr.builder()
+                            .setExprReferenceExpr(
+                                DefaultValueComposer.createDefaultValue(
+                                    resourceNames.get(
+                                        arg.field().resourceReference().resourceTypeString()),
+                                    resourceNameList,
+                                    arg.field().name()))
+                            .setMethodName("toString")
+                            .setReturnType(TypeNode.STRING)
+                            .build())
+            .collect(Collectors.toList());
+
+    List<Expr> bodyExprs = new ArrayList<>();
+    Preconditions.checkState(
+        rpcMethodArgVarExprs.size() == rpcMethodArgDefaultValueExprs.size(), "Error message here");
+    bodyExprs.addAll(
+        IntStream.range(0, rpcMethodArgVarExprs.size())
+            .mapToObj(
+                i ->
+                    AssignmentExpr.builder()
+                        .setVariableExpr(
+                            ((VariableExpr) rpcMethodArgVarExprs.get(i))
+                                .toBuilder()
+                                .setIsDecl(true)
+                                .build())
+                        .setValueExpr(rpcMethodArgDefaultValueExprs.get(i))
+                        .build())
+            .collect(Collectors.toList()));
     // Invoke current method based on return type.
     // e.g. if return void, echoClient.echo(..); or,
     // e.g. if return other type, EchoResponse response = echoClient.echo(...);
     boolean returnsVoid = isProtoEmptyType(method.outputType());
     if (returnsVoid) {
-      bodyExpr.add(
+      bodyExprs.add(
           MethodInvocationExpr.builder()
               .setExprReferenceExpr(clientVarExpr)
               .setMethodName(JavaStyle.toLowerCamelCase(method.name()))
-              .setArguments(methodArgExprs)
+              .setArguments(rpcMethodArgVarExprs)
               .setReturnType(clientType)
               .build());
     } else {
       VariableExpr responseVarExpr =
           VariableExpr.withVariable(
-              Variable.builder().setName(RESPONSE).setType(method.outputType()).build());
-      bodyExpr.add(
-          createAssignExprForVariableWithClientMethod(
-              responseVarExpr,
-              clientVarExpr,
-              JavaStyle.toLowerCamelCase(method.name()),
-              methodArgExprs));
+              Variable.builder().setName("response").setType(method.outputType()).build());
+      MethodInvocationExpr clientMethodInvocationExpr =
+          MethodInvocationExpr.builder()
+              .setExprReferenceExpr(clientVarExpr)
+              .setMethodName(JavaStyle.toLowerCamelCase(method.name()))
+              .setArguments(rpcMethodArgVarExprs)
+              .setReturnType(responseVarExpr.variable().type())
+              .build();
+      bodyExprs.add(
+          AssignmentExpr.builder()
+              .setVariableExpr(responseVarExpr.toBuilder().setIsDecl(true).build())
+              .setValueExpr(clientMethodInvocationExpr)
+              .build());
     }
 
     return TryCatchStatement.builder()
         .setTryResourceExpr(assignClientVariableWithCreateMethodExpr(clientVarExpr))
         .setTryBody(
-            bodyExpr.stream().map(e -> ExprStatement.withExpr(e)).collect(Collectors.toList()))
+            bodyExprs.stream().map(e -> ExprStatement.withExpr(e)).collect(Collectors.toList()))
         .setIsSampleCode(true)
         .build();
   }
@@ -255,7 +306,7 @@ private static AssignmentExpr assignClientVariableWithCreateMethodExpr(
   }
 
   // Create a list of Expr for method argument variable expression.
-  private static List<Expr> createMethodArgVarExprs(
+  private static List<Expr> createRpcMethodArgVarExprs(
       List<MethodArgument> arguments, Map<String, ResourceName> resourceNames) {
     return arguments.stream()
         .map(
@@ -280,64 +331,11 @@ private static List<Expr> createMethodArgVarExprs(
         .collect(Collectors.toList());
   }
 
-  // Return a list of AssignmentExpr for method argument with its default value.
-  private static List<Expr> assignMethodArgumentsWithDefaultValues(
-      List<MethodArgument> arguments,
-      List<Expr> argVarExprs,
-      Map<String, ResourceName> resourceNames) {
-    List<ResourceName> resourceNameList =
-        resourceNames.values().stream().collect(Collectors.toList());
-    List<Expr> assignmentExprs = new ArrayList<>();
-    for (int i = 0; i < arguments.size(); i++) {
-      MethodArgument arg = arguments.get(i);
-      VariableExpr argVarExpr =
-          (argVarExprs.get(i) instanceof VariableExpr) ? (VariableExpr) argVarExprs.get(i) : null;
-      Expr defaultValueExpr = DefaultValueComposer.createDefaultValue(arg, resourceNames);
-      if (arg.type().equals(TypeNode.STRING)
-          && arg.field().hasResourceReference()
-          && resourceNames.containsKey(arg.field().resourceReference().resourceTypeString())) {
-        ResourceName resourceName =
-            resourceNames.get(arg.field().resourceReference().resourceTypeString());
-        defaultValueExpr =
-            DefaultValueComposer.createDefaultValue(
-                resourceName, resourceNameList, arg.field().name());
-        TypeNode resourceReferenceType =
-            arg.field().resourceReference().isChildType()
-                ? TypeNode.withReference(
-                    ConcreteReference.withClazz(com.google.api.resourcenames.ResourceName.class))
-                : defaultValueExpr.type();
-        argVarExpr =
-            VariableExpr.withVariable(
-                Variable.builder()
-                    .setName(JavaStyle.toLowerCamelCase(arg.name()))
-                    .setType(resourceReferenceType)
-                    .build());
-      }
-      assignmentExprs.add(
-          AssignmentExpr.builder()
-              .setVariableExpr(argVarExpr.toBuilder().setIsDecl(true).build())
-              .setValueExpr(defaultValueExpr)
-              .build());
-    }
-    return assignmentExprs;
-  }
-
-  private static Expr createAssignExprForVariableWithClientMethod(
-      VariableExpr variableExpr,
-      VariableExpr clientVarExpr,
-      String methodName,
-      List<Expr> argumentsVarExprs) {
-    MethodInvocationExpr clientMethodInvocationExpr =
-        MethodInvocationExpr.builder()
-            .setExprReferenceExpr(clientVarExpr)
-            .setMethodName(JavaStyle.toLowerCamelCase(methodName))
-            .setArguments(argumentsVarExprs)
-            .setReturnType(variableExpr.variable().type())
-            .build();
-    return AssignmentExpr.builder()
-        .setVariableExpr(variableExpr.toBuilder().setIsDecl(true).build())
-        .setValueExpr(clientMethodInvocationExpr)
-        .build();
+  private static boolean isStringTypedResourceName(
+      MethodArgument arg, Map<String, ResourceName> resourceNames) {
+    return arg.type().equals(TypeNode.STRING)
+        && arg.field().hasResourceReference()
+        && resourceNames.containsKey(arg.field().resourceReference().resourceTypeString());
   }
 
   private static boolean isProtoEmptyType(TypeNode type) {

src/test/java/com/google/api/generator/gapic/composer/ServiceClientSampleCodeComposerTest.java

@@ -178,8 +178,8 @@ public void composeUnaryRpcMethodSampleCode_stringWithResourceReferenceMethodArg
                 unaryMethod, signatures.get(0), clientType, resourceNames));
     String expected =
         "try (EchoClient echoClient = EchoClient.create()) {\n"
-            + "  FoobarName name = FoobarName.ofProjectFoobarName(\"[PROJECT]\", \"[FOOBAR]\");\n"
-            + "  EchoResponse response = echoClient.echo(name.toString());\n"
+            + "  String name = FoobarName.ofProjectFoobarName(\"[PROJECT]\", \"[FOOBAR]\").toString();\n"
+            + "  EchoResponse response = echoClient.echo(name);\n"
             + "}";
     assertEquals(expected, results);
   }
@@ -219,8 +219,8 @@ public void composeUnaryRpcMethodSampleCode_stringWithParentResourceReferenceMet
                 unaryMethod, signatures.get(0), clientType, resourceNames));
     String expected =
         "try (EchoClient echoClient = EchoClient.create()) {\n"
-            + "  ResourceName parent = FoobarName.ofProjectFoobarName(\"[PROJECT]\", \"[FOOBAR]\");\n"
-            + "  EchoResponse response = echoClient.echo(parent.toString());\n"
+            + "  String parent = FoobarName.ofProjectFoobarName(\"[PROJECT]\", \"[FOOBAR]\").toString();\n"
+            + "  EchoResponse response = echoClient.echo(parent);\n"
             + "}";
     assertEquals(expected, results);
   }
@@ -320,9 +320,9 @@ public void composeUnaryRpcMethodSampleCode_multipleWordNameMethodArgument() {
                 unaryMethod, signatures.get(0), clientType, resourceNames));
     String expected =
         "try (EchoClient echoClient = EchoClient.create()) {\n"
-            + "  ResourceName displayName = FoobarName.ofProjectFoobarName(\"[PROJECT]\", \"[FOOBAR]\");\n"
+            + "  String displayName = FoobarName.ofProjectFoobarName(\"[PROJECT]\", \"[FOOBAR]\").toString();\n"
             + "  String otherName = \"other_name-182411686\";\n"
-            + "  EchoResponse response = echoClient.echo(displayName.toString(), otherName);\n"
+            + "  EchoResponse response = echoClient.echo(displayName, otherName);\n"
             + "}";
     assertEquals(expected, results);
   }

src/test/java/com/google/api/generator/gapic/composer/goldens/EchoClient.golden

@@ -244,8 +244,8 @@ public class EchoClient implements BackgroundResource {
    *
    * <pre>{@code
    * try (EchoClient echoClient = EchoClient.create()) {
-   *   FoobarName name = FoobarName.ofProjectFoobarName("[PROJECT]", "[FOOBAR]");
-   *   EchoResponse response = echoClient.echo(name.toString());
+   *   String name = FoobarName.ofProjectFoobarName("[PROJECT]", "[FOOBAR]").toString();
+   *   EchoResponse response = echoClient.echo(name);
    * }
    * }</pre>
    *
@@ -263,8 +263,8 @@ public class EchoClient implements BackgroundResource {
    *
    * <pre>{@code
    * try (EchoClient echoClient = EchoClient.create()) {
-   *   ResourceName parent = FoobarName.ofProjectFoobarName("[PROJECT]", "[FOOBAR]");
-   *   EchoResponse response = echoClient.echo(parent.toString());
+   *   String parent = FoobarName.ofProjectFoobarName("[PROJECT]", "[FOOBAR]").toString();
+   *   EchoResponse response = echoClient.echo(parent);
    * }
    * }</pre>
    *