Merge branch 'main' into docstring

Author: pavuluri

README.md

@@ -269,3 +269,7 @@ if __name__ == "__main__":
                 print(f"Instruction:\n{instruction}")
                 print(f"LLM Output:\n{llm_output}")
 ```
+
+### Publication (papers and blogs related to CLDK)
+1. Pan, Rangeet, Myeongsoo Kim, Rahul Krishna, Raju Pavuluri, and Saurabh Sinha. "[Multi-language Unit Test Generation using LLMs.](https://arxiv.org/abs/2409.03093)" arXiv preprint arXiv:2409.03093 (2024).
+2. Pan, Rangeet, Rahul Krishna, Raju Pavuluri, Saurabh Sinha, and Maja Vukovic., "[Simplify your Code LLM solutions using CodeLLM Dev Kit (CLDK).](https://www.linkedin.com/pulse/simplify-your-code-llm-solutions-using-codellm-dev-kit-rangeet-pan-vnnpe/?trackingId=kZ3U6d8GSDCs8S1oApXZgg%3D%3D)", Blog.

cldk/analysis/java/codeanalyzer/codeanalyzer.py

@@ -84,6 +84,7 @@ def __init__(
             analysis_level: str,
             use_graalvm_binary: bool,
             eager_analysis: bool,
+            target_files: List[str] | None
     ) -> None:
         self.project_dir = project_dir
         self.source_code = source_code
@@ -92,6 +93,7 @@ def __init__(
         self.use_graalvm_binary = use_graalvm_binary
         self.eager_analysis = eager_analysis
         self.analysis_level = analysis_level
+        self.target_files = target_files
         self.application = self._init_codeanalyzer(
             analysis_level=1 if analysis_level == AnalysisLevel.symbol_table else 2)
         # Attributes related the Java code analysis...
@@ -183,15 +185,11 @@ def _get_codeanalyzer_exec(self) -> List[str]:
                     resources.files("cldk.analysis.java.codeanalyzer.bin") / "codeanalyzer") as codeanalyzer_bin_path:
                 codeanalyzer_exec = shlex.split(codeanalyzer_bin_path.__str__())
         else:
-            print(f'analysis path: {self.analysis_json_path}')
-            analysis_json_path_file = Path(self.analysis_json_path).joinpath("analysis.json")
+
             if self.analysis_backend_path:
                 analysis_backend_path = Path(self.analysis_backend_path)
                 logger.info(f"Using codeanalyzer.jar from {analysis_backend_path}")
                 codeanalyzer_exec = shlex.split(f"java -jar {analysis_backend_path / 'codeanalyzer.jar'}")
-            elif analysis_json_path_file.exists():
-                logger.info(f"Using existing analysis from {self.analysis_json_path}")
-                codeanalyzer_exec = shlex.split(f"java -jar codeanalyzer.jar")
             else:
                 # Since the path to codeanalyzer.jar was not provided, we'll download the latest version from GitHub.
                 with resources.as_file(resources.files("cldk.analysis.java.codeanalyzer.jar")) as codeanalyzer_jar_path:
@@ -200,7 +198,16 @@ def _get_codeanalyzer_exec(self) -> List[str]:
                     codeanalyzer_jar_file = self._download_or_update_code_analyzer(codeanalyzer_jar_path)
                     codeanalyzer_exec = shlex.split(f"java -jar {codeanalyzer_jar_file}")
         return codeanalyzer_exec
-
+    
+    def init_japplication(self, data: str) -> JApplication:
+        """Return JApplication giving the stringified JSON as input.
+        Returns
+        -------
+        JApplication
+            The application view of the Java code with the analysis results.
+        """
+        return JApplication(**json.loads(data))
+        
     def _init_codeanalyzer(self, analysis_level=1) -> JApplication:
         """ Initializes the Codeanalyzer.
 
@@ -214,11 +221,19 @@ def _init_codeanalyzer(self, analysis_level=1) -> JApplication:
             CodeanalyzerExecutionException: If there is an error running Codeanalyzer.
         """
         codeanalyzer_exec = self._get_codeanalyzer_exec()
-
+        codeanalyzer_args = ''
         if self.analysis_json_path is None:
             logger.info("Reading analysis from the pipe.")
-            codeanalyzer_args = codeanalyzer_exec + shlex.split(
-                f"-i {Path(self.project_dir)} --analysis-level={analysis_level}")
+            # If target file is provided, the input is merged into a single string and passed to codeanalyzer
+            if self.target_files:
+                target_file_options = ' -t '.join([s.strip() for s in self.target_files])
+                codeanalyzer_args = codeanalyzer_exec + shlex.split(
+                    f"-i {Path(self.project_dir)} --analysis-level={analysis_level} -t {target_file_options}"
+                )
+            else:
+                codeanalyzer_args = codeanalyzer_exec + shlex.split(
+                    f"-i {Path(self.project_dir)} --analysis-level={analysis_level}"
+                )
             try:
                 logger.info(f"Running codeanalyzer: {' '.join(codeanalyzer_args)}")
                 console_out: CompletedProcess[str] = subprocess.run(
@@ -232,15 +247,29 @@ def _init_codeanalyzer(self, analysis_level=1) -> JApplication:
                 raise CodeanalyzerExecutionException(str(e)) from e
 
         else:
+            # Check if the code analyzer needs to be run
+            is_run_code_analyzer = False
             analysis_json_path_file = Path(self.analysis_json_path).joinpath("analysis.json")
-            if not analysis_json_path_file.exists() or self.eager_analysis:
-                # If the analysis file does not exist, we'll run the analysis. Alternately, if the eager_analysis
-                # flag is set, we'll run the analysis every time the object is created. This will happen regradless
-                # of the existence of the analysis file.
-                # Create the executable command for codeanalyzer.
+            # If target file is provided, the input is merged into a single string and passed to codeanalyzer
+            if self.target_files:
+                target_file_options = ' -t '.join([s.strip() for s in self.target_files])
                 codeanalyzer_args = codeanalyzer_exec + shlex.split(
-                    f"-i {Path(self.project_dir)} --analysis-level={analysis_level} -o {self.analysis_json_path}")
+                    f"-i {Path(self.project_dir)} --analysis-level={analysis_level}"
+                    f" -o {self.analysis_json_path} -t {target_file_options}"
+                )
+                is_run_code_analyzer = True
+            else:
+                if not analysis_json_path_file.exists() or self.eager_analysis:
+                    # If the analysis file does not exist, we'll run the analysis. Alternately, if the eager_analysis
+                    # flag is set, we'll run the analysis every time the object is created. This will happen regradless
+                    # of the existence of the analysis file.
+                    # Create the executable command for codeanalyzer.
+                    codeanalyzer_args = codeanalyzer_exec + shlex.split(
+                        f"-i {Path(self.project_dir)} --analysis-level={analysis_level} -o {self.analysis_json_path}"
+                    )
+                    is_run_code_analyzer = True
 
+            if is_run_code_analyzer:
                 try:
                     logger.info(f"Running codeanalyzer subprocess with args {codeanalyzer_args}")
                     subprocess.run(
@@ -254,7 +283,6 @@ def _init_codeanalyzer(self, analysis_level=1) -> JApplication:
 
                 except Exception as e:
                     raise CodeanalyzerExecutionException(str(e)) from e
-
             with open(analysis_json_path_file) as f:
                 data = json.load(f)
                 return JApplication(**data)
@@ -265,7 +293,6 @@ def _codeanalyzer_single_file(self):
         Returns:
             JApplication: The application view of the Java code with the analysis results.
         """
-        # self.source_code: str = re.sub(r"[\r\n\t\f\v]+", lambda x: " " if x.group() in "\t\f\v" else " ", self.source_code)
         codeanalyzer_exec = self._get_codeanalyzer_exec()
         codeanalyzer_args = ["--source-analysis", self.source_code]
         codeanalyzer_cmd = codeanalyzer_exec + codeanalyzer_args
@@ -410,8 +437,9 @@ def get_all_callers(self, target_class_name: str, target_method_signature: str,
         caller_detail_dict = {}
         call_graph = None
         if using_symbol_table:
-            call_graph = self.__raw_call_graph_using_symbol_table_target_method(target_class_name=target_class_name,
-                                                              target_method_signature=target_method_signature)
+            call_graph = self.__call_graph_using_symbol_table(qualified_class_name=target_class_name,
+                                                              method_signature=target_method_signature,
+                                                              is_target_method=True)
         else:
             call_graph = self.call_graph
         if (target_method_signature, target_class_name) not in call_graph.nodes():
@@ -703,10 +731,11 @@ def __call_graph_using_symbol_table(self,
         cg = nx.DiGraph()
         sdg = None
         if is_target_method:
-            sdg = None
+            sdg = self.__raw_call_graph_using_symbol_table_target_method(target_class_name=qualified_class_name,
+                                                                         target_method_signature=method_signature)
         else:
             sdg = self.__raw_call_graph_using_symbol_table(qualified_class_name=qualified_class_name,
-                                                       method_signature=method_signature)
+                                                           method_signature=method_signature)
         tsu = JavaSitter()
         edge_list = [
             (
@@ -733,8 +762,8 @@ def __call_graph_using_symbol_table(self,
         return cg
 
     def __raw_call_graph_using_symbol_table_target_method(self,
-                                            target_class_name: str,
-                                            target_method_signature: str,
+                                                          target_class_name: str,
+                                                          target_method_signature: str,
                                                           cg=None) -> list[JGraphEdgesST]:
         """ Generates call graph using symbol table information given the target method and target class
         Args:
@@ -752,7 +781,7 @@ def __raw_call_graph_using_symbol_table_target_method(self,
         for class_name in self.get_all_classes():
             for method in self.get_all_methods_in_class(qualified_class_name=class_name):
                 method_details = self.get_method(qualified_class_name=class_name,
-                                                method_signature=method)
+                                                 method_signature=method)
                 for call_site in method_details.call_sites:
                     source_method_details = None
                     source_class = ''
@@ -776,9 +805,9 @@ def __raw_call_graph_using_symbol_table_target_method(self,
                     if call_site.receiver_type != "":
                         # call to any class
                         if self.get_class(qualified_class_name=call_site.receiver_type):
-                            if callee_signature==target_method_signature and call_site.receiver_type == target_class_name:
+                            if callee_signature == target_method_signature and call_site.receiver_type == target_class_name:
                                 source_method_details = self.get_method(method_signature=method,
-                                                  qualified_class_name=class_name)
+                                                                        qualified_class_name=class_name)
                                 source_class = class_name
                     else:
                         # check if any method exists with the signature in the class even if the receiver type is blank

cldk/analysis/java/java.py

@@ -15,16 +15,18 @@
 class JavaAnalysis(SymbolTable, CallGraph):
 
     def __init__(
-        self,
-        project_dir: str | Path | None,
-        source_code: str | None,
-        analysis_backend: str,
-        analysis_backend_path: str | None,
-        analysis_json_path: str | Path | None,
-        analysis_level: str,
-        use_graalvm_binary: bool,
-        eager_analysis: bool,
+            self,
+            project_dir: str | Path | None,
+            source_code: str | None,
+            analysis_backend: str,
+            analysis_backend_path: str | None,
+            analysis_json_path: str | Path | None,
+            analysis_level: str,
+            target_files: List[str] | None,
+            use_graalvm_binary: bool,
+            eager_analysis: bool,
     ) -> None:
+
         """ Initialization method for Java Analysis backend.
 
         Args:
@@ -39,16 +41,21 @@ def __init__(
 
         Raises:
             NotImplementedError: Raised when anaysis backend is not supported.
+            
+        Attributes:
+            application (JApplication): The application view of the Java code.
 
         """        
+
         self.project_dir = project_dir
         self.source_code = source_code
         self.analysis_level = analysis_level
         self.analysis_json_path = analysis_json_path
         self.analysis_backend_path = analysis_backend_path
         self.eager_analysis = eager_analysis
         self.use_graalvm_binary = use_graalvm_binary
-        self.analysis_backend =  analysis_backend
+        self.analysis_backend = analysis_backend
+        self.target_files = target_files
         # Initialize the analysis analysis_backend
         if analysis_backend.lower() == "codeql":
             self.analysis_backend: JCodeQL = JCodeQL(self.project_dir, self.analysis_json_path)
@@ -61,6 +68,7 @@ def __init__(
                 analysis_json_path=self.analysis_json_path,
                 use_graalvm_binary=self.use_graalvm_binary,
                 analysis_backend_path=self.analysis_backend_path,
+                target_files=self.target_files
             )
         else:
             raise NotImplementedError(f"Support for {analysis_backend} has not been implemented yet.")
@@ -189,12 +197,14 @@ def get_callers(self, target_class_name: str, target_method_declaration: str,
             raise NotImplementedError("Generating all callers over a single file is not implemented yet.")
         return self.backend.get_all_callers(target_class_name, target_method_declaration, using_symbol_table)
 
-    def get_callees(self, source_class_name: str, source_method_declaration: str) ->Dict:
+
+    def get_callees(self, source_class_name: str, source_method_declaration: str, using_symbol_table: bool = False) ->Dict:
         """ Returns a dictionary of callees by the given method in the given class.
 
         Args:
             source_class_name (str): Qualified class name where the given method is.
             source_method_declaration (str): Given method 
+            using_symbol_table (bool): Whether to use symbol table.  Defaults to false.
 
         Raises:
             NotImplementedError: Raised when this functionality is not suported.
@@ -204,7 +214,7 @@ def get_callees(self, source_class_name: str, source_method_declaration: str) ->
         """        
         if self.source_code:
             raise NotImplementedError("Generating all callees over a single file is not implemented yet.")
-        return self.backend.get_all_callees(source_class_name, source_method_declaration)
+        return self.backend.get_all_callees(source_class_name, source_method_declaration, using_symbol_table)
 
     def get_methods(self) -> Dict[str, Dict[str, JCallable]]:
         """ Returns all methods in the Java code.
@@ -442,6 +452,7 @@ def get_implemented_interfaces(self, qualified_class_name: str) -> List[str]:
 
     def __get_class_call_graph_using_symbol_table(self, qualified_class_name: str, method_signature: str | None = None) -> (List)[Tuple[JMethodDetail, JMethodDetail]]:
         """A call graph using symbol table for a given class and a given method.
+
         Args:
             qualified_class_name (str): The qualified name of the class.
             method_signature (str | None, optional): The signature of the method in the class.. Defaults to None.
@@ -473,7 +484,7 @@ def get_class_call_graph(self, qualified_class_name: str, method_signature: str
         """        
         if using_symbol_table:
             return self.__get_class_call_graph_using_symbol_table(qualified_class_name=qualified_class_name,
-                                                                method_signature=method_signature)
+                                                                  method_signature=method_signature)
         if self.analysis_backend in [AnalysisEngine.CODEQL, AnalysisEngine.TREESITTER]:
             raise NotImplementedError(f"Support for this functionality has not been implemented yet.")
         return self.backend.get_class_call_graph(qualified_class_name, method_signature)