Added argument expression field to call site

Signed-off-by: Saurabh Sinha <[email protected]>

Author: sinha108

src/main/java/com/ibm/cldk/SymbolTable.java

@@ -894,7 +894,7 @@ private static List<CallSite> getCallSites(Optional<BlockStmt> callableBody) {
                         + exception.getMessage());
             }
             // resolve arguments of the method call to types
-            List<String> arguments = methodCallExpr.getArguments().stream().map(SymbolTable::resolveExpression)
+            List<String> argumentTypes = methodCallExpr.getArguments().stream().map(SymbolTable::resolveExpression)
                     .collect(Collectors.toList());
             // Get argument string from the callsite
             List<String> listOfArgumentStrings = methodCallExpr.getArguments().stream().map(Expression::toString)
@@ -930,7 +930,7 @@ private static List<CallSite> getCallSites(Optional<BlockStmt> callableBody) {
 
 
             callSites.add(createCallSite(methodCallExpr, methodCallExpr.getNameAsString(), receiverName, declaringType,
-                    arguments, returnType, calleeSignature, isStaticCall, false, crudOperation, crudQuery,
+                    argumentTypes, listOfArgumentStrings, returnType, calleeSignature, isStaticCall, false, crudOperation, crudQuery,
                     accessSpecifier));
         }
 
@@ -939,7 +939,11 @@ private static List<CallSite> getCallSites(Optional<BlockStmt> callableBody) {
             String instantiatedType = resolveType(objectCreationExpr.getType());
 
             // resolve arguments of the constructor call to types
-            List<String> arguments = objectCreationExpr.getArguments().stream().map(SymbolTable::resolveExpression)
+            List<String> argumentTypes = objectCreationExpr.getArguments().stream().map(SymbolTable::resolveExpression)
+                    .collect(Collectors.toList());
+
+            // get argument expressions for constructor call
+            List<String> argumentExpressions = objectCreationExpr.getArguments().stream().map(Expression::toString)
                     .collect(Collectors.toList());
 
             // resolve callee and get signature
@@ -955,7 +959,7 @@ private static List<CallSite> getCallSites(Optional<BlockStmt> callableBody) {
                     .add(createCallSite(objectCreationExpr, "<init>",
                             objectCreationExpr.getScope().isPresent() ? objectCreationExpr.getScope().get().toString()
                                     : "",
-                            instantiatedType, arguments, instantiatedType, calleeSignature, false, true, null, null,
+                            instantiatedType, argumentTypes, argumentExpressions, instantiatedType, calleeSignature, false, true, null, null,
                             AccessSpecifier.NONE));
         }
 
@@ -1006,17 +1010,24 @@ private static Optional<CRUDOperationType> findCRUDOperation(String declaringTyp
      * @param calleeName
      * @param receiverExpr
      * @param receiverType
-     * @param arguments
+     * @param argumentTypes
+     * @param argumentExpr
+     * @param returnType
+     * @param calleeSignature
      * @param isStaticCall
      * @param isConstructorCall
+     * @param crudOperation,
+     * @param crudQuery,
+     * @param accessSpecifier
      * @return
      */
     private static CallSite createCallSite(
             Expression callExpr,
             String calleeName,
             String receiverExpr,
             String receiverType,
-            List<String> arguments,
+            List<String> argumentTypes,
+            List<String> argumentExpr,
             String returnType,
             String calleeSignature,
             boolean isStaticCall,
@@ -1042,7 +1053,8 @@ private static CallSite createCallSite(
         callSite.setMethodName(calleeName);
         callSite.setReceiverExpr(receiverExpr);
         callSite.setReceiverType(receiverType);
-        callSite.setArgumentTypes(arguments);
+        callSite.setArgumentTypes(argumentTypes);
+        callSite.setArgumentExpr(argumentExpr);
         callSite.setReturnType(returnType);
         callSite.setCalleeSignature(calleeSignature);
         callSite.setStaticCall(isStaticCall);

src/main/java/com/ibm/cldk/entities/CallSite.java

@@ -42,6 +42,9 @@ public class CallSite {
     /** List of argument types for the method call */
     private List<String> argumentTypes;
 
+    /** List of argument expressions for the method call */
+    private List<String> argumentExpr;
+
     /** Return type of the called method */
     private String returnType;
 

src/test/java/com/ibm/cldk/SymbolTableTest.java

@@ -1,5 +1,6 @@
 package com.ibm.cldk;
 
+import com.ibm.cldk.entities.CallSite;
 import com.ibm.cldk.entities.Callable;
 import com.ibm.cldk.entities.JavaCompilationUnit;
 import com.ibm.cldk.entities.Type;
@@ -11,7 +12,7 @@
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.nio.charset.StandardCharsets;
-import java.nio.file.Paths;
+import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 
@@ -36,4 +37,22 @@ public void testExtractSingleGenricsDuplicateSignature() throws IOException {
         Assertions.assertEquals(17, callables.size());
     }
 
+    @Test
+    public void testCallSiteArgumentExpression() throws IOException {
+        String javaCode = getJavaCodeForTestResource("test-applications/generics-varargs-duplicate-signature-test/Validate.java");
+        Map<String, Type> typeDeclaration = SymbolTable.extractSingle(javaCode).getLeft()
+                .values().iterator().next().getTypeDeclarations();
+        Callable callable = typeDeclaration.values().iterator().next().getCallableDeclarations()
+                .get("notEmpty(java.util.Collection<?>, java.lang.String, java.lang.Object[])");
+        Assertions.assertNotNull(callable);
+        for (CallSite callSite : callable.getCallSites()) {
+            if (callSite.getMethodName().equals("requireNonNull")) {
+                String[] expectedArgumentExpr = {"collection", "toSupplier(message, values)"};
+                List<String> argumentExpr = callSite.getArgumentExpr();
+                Assertions.assertArrayEquals(expectedArgumentExpr, argumentExpr.toArray(new String[0]));
+                break;
+            }
+        }
+    }
+
 }