Issue 103: Add implementation for Initialization Blocks modeled on Callable.

Signed-off-by: Rahul Krishna <[email protected]>

Author: rahlk

settings.gradle

@@ -9,12 +9,4 @@ distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
-*/
-pluginManagement {
-    plugins {
-        id 'org.jetbrains.kotlin.jvm' version '2.1.10'
-    }
-}
-plugins {
-    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.8.0'
-}
+*/

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

@@ -15,11 +15,13 @@
 import com.github.javaparser.ast.type.ClassOrInterfaceType;
 import com.github.javaparser.ast.type.ReferenceType;
 import com.github.javaparser.ast.type.Type;
+import com.github.javaparser.resolution.TypeSolver;
 import com.github.javaparser.resolution.UnsolvedSymbolException;
 import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
 import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
 import com.github.javaparser.resolution.types.ResolvedType;
 import com.github.javaparser.symbolsolver.JavaSymbolSolver;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
 import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
 import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
 import com.github.javaparser.symbolsolver.utils.SymbolSolverCollectionStrategy;
@@ -172,9 +174,16 @@ else if (typeDecl instanceof RecordDeclaration) {
                 typeNode = new com.ibm.cldk.entities.Type();
             }
 
-                    /* set common attributes of types that available in type declarations:
-                is nested type, is class or interface declaration, is enum declaration,
-                comments, parent class, callable declarations, field declarations */
+            /* set common attributes of types that available in type declarations:
+            is nested type, is class or interface declaration, is enum declaration,
+            comments, parent class, callable declarations, field declarations
+            */
+            // Discover initialization blocks
+            typeNode.setInitializationBlocks(typeDecl.findAll(InitializerDeclaration.class).stream()
+                    .map(initializerDeclaration -> {
+                        return createInitializationBlock(initializerDeclaration, parseResult.getStorage().map(s -> s.getPath().toString()).orElse("<in-memory>"));
+                    })
+                    .collect(Collectors.toList()));
             // Set fields indicating nested, class/interface, enum, annotation, and record types
             typeNode.setNestedType(typeDecl.isNestedType());
             typeNode.setClassOrInterfaceDeclaration(typeDecl.isClassOrInterfaceDeclaration());
@@ -213,7 +222,38 @@ else if (typeDecl instanceof RecordDeclaration) {
         return cUnit;
     }
 
-
+    private static InitializationBlock createInitializationBlock(InitializerDeclaration initializerDeclaration, String filePath) {
+        InitializationBlock initializationBlock = new InitializationBlock();
+        initializationBlock.setFilePath(filePath);
+        initializationBlock.setComment(initializerDeclaration.getComment().isPresent() ? initializerDeclaration.getComment().get().asString() : "");
+        initializationBlock.setAnnotations(initializerDeclaration.getAnnotations().stream().map(a -> a.toString().strip()).collect(Collectors.toList()));
+        // add exceptions declared in "throws" clause
+        initializationBlock.setThrownExceptions(initializerDeclaration.getBody().getStatements().stream().filter(Statement::isThrowStmt).map(throwStmt -> {
+            try {
+                return javaSymbolSolver.calculateType(throwStmt.asThrowStmt().getExpression()).describe();
+            } catch (Exception e) {
+                return throwStmt.asThrowStmt().getExpression().toString();
+            }
+        }).collect(Collectors.toList()));
+        initializationBlock.setCode(initializerDeclaration.getBody().toString());
+        initializationBlock.setStartLine(initializerDeclaration.getRange().isPresent() ? initializerDeclaration.getRange().get().begin.line : -1);
+        initializationBlock.setEndLine(initializerDeclaration.getRange().isPresent() ? initializerDeclaration.getRange().get().end.line : -1);
+        initializationBlock.setStatic(initializerDeclaration.isStatic());
+        initializationBlock.setReferencedTypes(getReferencedTypes(Optional.ofNullable(initializerDeclaration.getBody())));
+        initializationBlock.setAccessedFields(getAccessedFields(Optional.ofNullable(initializerDeclaration.getBody()), Collections.emptyList(), ""));
+        initializationBlock.setCallSites(getCallSites(Optional.ofNullable(initializerDeclaration.getBody())));
+        initializationBlock.setVariableDeclarations(getVariableDeclarations(Optional.ofNullable(initializerDeclaration.getBody())));
+        initializationBlock.setCyclomaticComplexity(getCyclomaticComplexity(initializerDeclaration));
+        return initializationBlock;
+    }
+    /**
+     * Processes the given record to extract information about the
+     * declared field and returns a JSON object containing the extracted
+     * information.
+     *
+     * @param recordDecl field declaration to be processed
+     * @return Field object containing extracted information
+     */
     private static List<RecordComponent> processRecordComponents(RecordDeclaration recordDecl) {
         return recordDecl.getParameters().stream().map(
                 parameter -> {
@@ -568,6 +608,14 @@ private static int getCyclomaticComplexity(CallableDeclaration callableDeclarati
         int catchClauseCount = callableDeclaration.findAll(CatchClause.class).size();
         return ifStmtCount + loopStmtCount + switchCaseCount + conditionalExprCount + catchClauseCount + 1;
     }
+    private static int getCyclomaticComplexity(InitializerDeclaration initializerDeclaration) {
+        int ifStmtCount = initializerDeclaration.findAll(IfStmt.class).size();
+        int loopStmtCount = initializerDeclaration.findAll(DoStmt.class).size() + initializerDeclaration.findAll(ForStmt.class).size() + initializerDeclaration.findAll(ForEachStmt.class).size() + initializerDeclaration.findAll(WhileStmt.class).size();
+        int switchCaseCount = initializerDeclaration.findAll(SwitchStmt.class).stream().map(stmt -> stmt.getEntries().size()).reduce(0, Integer::sum);
+        int conditionalExprCount = initializerDeclaration.findAll(ConditionalExpr.class).size();
+        int catchClauseCount = initializerDeclaration.findAll(CatchClause.class).size();
+        return ifStmtCount + loopStmtCount + switchCaseCount + conditionalExprCount + catchClauseCount + 1;
+    }
 
     /**
      * Processes the given field declaration to extract information about the

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

@@ -3,6 +3,7 @@
 import lombok.Data;
 
 import java.util.List;
+import java.util.stream.Collector;
 
 @Data
 public class InitializationBlock {
@@ -19,4 +20,5 @@ public class InitializationBlock {
     private List<CallSite> callSites;
     private List<VariableDeclaration> variableDeclarations;
     private int cyclomaticComplexity;
+
 }

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

@@ -28,5 +28,6 @@ public class Type {
     private List<Field> fieldDeclarations = new ArrayList<>();
     private List<EnumConstant> enumConstants = new ArrayList<>();
     private List<RecordComponent> recordComponents = new ArrayList<>();
+    private List<InitializationBlock> initializationBlocks = new ArrayList<>();
     private boolean isEntrypointClass = false;
 }

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

@@ -55,6 +55,7 @@ public class CodeAnalyzerIntegrationTest {
             .withCopyFileToContainer(MountableFile.forHostPath(Paths.get(System.getProperty("user.dir")).resolve("src/test/resources/test-applications/plantsbywebsphere")), "/test-applications/plantsbywebsphere")
             .withCopyFileToContainer(MountableFile.forHostPath(Paths.get(System.getProperty("user.dir")).resolve("src/test/resources/test-applications/call-graph-test")), "/test-applications/call-graph-test")
             .withCopyFileToContainer(MountableFile.forHostPath(Paths.get(System.getProperty("user.dir")).resolve("src/test/resources/test-applications/record-class-test")), "/test-applications/record-class-test")
+            .withCopyFileToContainer(MountableFile.forHostPath(Paths.get(System.getProperty("user.dir")).resolve("src/test/resources/test-applications/init-blocks-test")), "/test-applications/init-blocks-test")
             .withCopyFileToContainer(MountableFile.forHostPath(Paths.get(System.getProperty("user.dir")).resolve("src/test/resources/test-applications/mvnw-working-test")), "/test-applications/mvnw-working-test");
 
     @Container
@@ -332,4 +333,35 @@ void parametersInCallableMustHaveStartAndEndLineAndColumns() throws IOException,
             }
         }
     }
+
+    @Test
+    void mustBeAbleToResolveInitializationBlocks() throws IOException, InterruptedException {
+        var runCodeAnalyzerOnCallGraphTest = container.execInContainer(
+                "bash", "-c",
+                String.format(
+                        "export JAVA_HOME=%s && java -jar /opt/jars/codeanalyzer-%s.jar --input=/test-applications/init-blocks-test --analysis-level=1",
+                        javaHomePath, codeanalyzerVersion
+                )
+        );
+
+        // Read the output JSON
+        Gson gson = new Gson();
+        JsonObject jsonObject = gson.fromJson(runCodeAnalyzerOnCallGraphTest.getStdout(), JsonObject.class);
+        JsonObject symbolTable = jsonObject.getAsJsonObject("symbol_table");
+        for (Map.Entry<String, JsonElement> element : symbolTable.entrySet()) {
+            String key = element.getKey();
+            if (!key.endsWith("App.java")) {
+                continue;
+            }
+            JsonObject type = element.getValue().getAsJsonObject();
+            if (type.has("type_declarations")) {
+                JsonObject typeDeclarations = type.getAsJsonObject("type_declarations");
+                JsonArray initializationBlocks = typeDeclarations.getAsJsonObject("org.example.App").getAsJsonArray("initialization_blocks");
+                // There should be 2 blocks
+                Assertions.assertEquals(2, initializationBlocks.size(), "Callable should have 1 parameter");
+                Assertions.assertTrue(initializationBlocks.get(0).getAsJsonObject().get("is_static").getAsBoolean(), "Static block should be marked as static");
+                Assertions.assertFalse(initializationBlocks.get(1).getAsJsonObject().get("is_static").getAsBoolean(), "Instance block should be marked as not static");
+            }
+        }
+    }
 }

src/test/resources/test-applications/init-blocks-test/app/src/main/java/org/example/App.java

@@ -12,6 +12,7 @@ public class App {
             initializeStaticFields();
         } catch (Exception e) {
             System.err.println("Error in static block: " + e.getMessage());
+            throw new RuntimeException(e);
         }
     }