Merge pull request #28 from icon-project/mksong-fix-compile-error

Fix compile errors of generated class by annotation processor

Author: jspark-icon

unittest/src/main/java/com/iconloop/score/test/GenerateTScoreProcessor.java

@@ -352,8 +352,28 @@ private String objectArray(List<String> names) {
     }
 
     static TypeName externalAnnName = TypeName.get(TExternal.class);
+    static TypeName optionalAnnName = TypeName.get(TOptional.class);
     static TypeName eventAnnName = TypeName.get(EventLog.class);
 
+    private static boolean hasOptional(ParameterSpec p) {
+        return p.annotations.stream().anyMatch(
+                a -> a.type.equals(optionalAnnName)
+        );
+    }
+
+    private List<List<ParameterSpec>> explodeOptionalParameters(List<ParameterSpec> params) {
+        List<List<ParameterSpec>> specs = new ArrayList<>();
+        List<ParameterSpec> spec = new ArrayList<>();
+        for (var p : params) {
+            if (hasOptional(p)) {
+                specs.add(List.copyOf(spec));
+            }
+            spec.add(ParameterSpec.builder(p.type, p.name, p.modifiers.toArray(Modifier[]::new)).build());
+        }
+        specs.add(List.copyOf(spec));
+        return specs;
+    }
+
     private TypeSpec clientTypeSpec(ClassName tScoreClassName, List<MethodSpec> methods) {
         ClassName className = tScoreClassName.nestedClass("Client");
         String FILED_SCORE = "score";
@@ -382,7 +402,7 @@ private TypeSpec clientTypeSpec(ClassName tScoreClassName, List<MethodSpec> meth
                 .map(m -> m.parameters)
                 .orElse(new ArrayList<>());
         MethodSpec.Builder deployMethodBuilder = MethodSpec.methodBuilder("deploy")
-                .addModifiers(Modifier.STATIC)
+                .addModifiers(Modifier.STATIC, Modifier.PUBLIC)
                 .addException(Exception.class)
                 .addParameter(ServiceManager.class, "sm")
                 .addParameter(Account.class, "caller")
@@ -410,33 +430,37 @@ private TypeSpec clientTypeSpec(ClassName tScoreClassName, List<MethodSpec> meth
         for (MethodSpec method : methods) {
             AnnotationSpec ann = method.annotations.stream().filter(a -> a.type.equals(externalAnnName)).findAny().orElse(null);
             if (ann != null) {
-                MethodSpec.Builder externalMethodBuilder = MethodSpec.methodBuilder(method.name)
-                        .addModifiers(method.modifiers)
-                        .returns(method.returnType);
                 boolean readonly = ann.members.get("readonly").get(0).toString().equals("true");
                 boolean payable = ann.members.get("payable").get(0).toString().equals("true");
-                List<String> paramNames = method.parameters.stream().map(p -> p.name).collect(Collectors.toList());
-                String params = paramJoin(paramNames);
-                if (paramNames.size() > 0) {
-                    params = ", " + params;
-                }
-                if (readonly) {
-                    externalMethodBuilder.addStatement("return this.$L.call($T.class, \"$L\"$L)",
-                            FILED_SCORE, method.returnType, method.name, params);
-                } else {
-                    if (payable) {
-                        String PARAM_VALUE = resolveName(paramNames, "valueForPayable");
-                        externalMethodBuilder.addParameter(ParameterSpec.builder(BigInteger.class, PARAM_VALUE).build());
-                        externalMethodBuilder.addStatement("this.$L.invoke(this.$L, $L, \"$L\"$L)",
-                                FILED_SCORE, FILED_FROM, PARAM_VALUE, method.name, params);
+
+                List<List<ParameterSpec>> parameterSets =
+                        explodeOptionalParameters(method.parameters);
+                for (var parameters : parameterSets) {
+                    MethodSpec.Builder externalMethodBuilder = MethodSpec.methodBuilder(method.name)
+                            .addModifiers(method.modifiers);
+                    List<String> paramNames = parameters.stream().map(p -> p.name).collect(Collectors.toList());
+                    String params = paramJoin(paramNames);
+                    if (paramNames.size() > 0) {
+                        params = ", " + params;
+                    }
+                    if (readonly) {
+                        externalMethodBuilder.addStatement("return this.$L.call($T.class, \"$L\"$L)",
+                                FILED_SCORE, method.returnType, method.name, params).returns(method.returnType);
                     } else {
-                        externalMethodBuilder.addStatement("this.$L.invoke(this.$L, \"$L\"$L)",
-                                FILED_SCORE, FILED_FROM, method.name, params);
+                        if (payable) {
+                            String PARAM_VALUE = resolveName(paramNames, "valueForPayable");
+                            externalMethodBuilder.addParameter(ParameterSpec.builder(BigInteger.class, PARAM_VALUE).build());
+                            externalMethodBuilder.addStatement("this.$L.invoke(this.$L, $L, \"$L\"$L)",
+                                    FILED_SCORE, FILED_FROM, PARAM_VALUE, method.name, params);
+                        } else {
+                            externalMethodBuilder.addStatement("this.$L.invoke(this.$L, \"$L\"$L)",
+                                    FILED_SCORE, FILED_FROM, method.name, params);
+                        }
                     }
+                    builder.addMethod(externalMethodBuilder
+                            .addParameters(parameters)
+                            .build());
                 }
-                builder.addMethod(externalMethodBuilder
-                        .addParameters(method.parameters)
-                        .build());
             } else {
                 boolean isEvent = method.annotations.stream().anyMatch(a -> a.type.equals(eventAnnName));
                 if (isEvent) {