def __init__(self, source_class="Playground", source_method="DeliveryDate", argument_name="b", main_file="playground.java"): """create a removeflagargument refactor Args: source_class (str): class name contaminated by code smell. source_mathod (str): method name contaminated. argument_name (str): boolean argument in method. main_file (str): path of main file containing source class. """ self.source_class = source_class self.source_method = source_method self.arguemnt_name = argument_name self.main_file = main_file self.stream = FileStream(self.main_file, encoding='utf8', errors='ignore') self.lexer = JavaLexer(self.stream) self.token_stream = CommonTokenStream(self.lexer) self.parser = JavaParserLabeled(self.token_stream) self.parser.getTokenStream() self.parse_tree = self.parser.compilationUnit() self.my_listener = RemoveFlagArgumentListener( common_token_stream=self.token_stream, source_class=self.source_class, source_method=self.source_method, argument_name=self.arguemnt_name)
def main(directory_path, package_name, source_class, field_name): for root, dirs, files in os.walk(directory_path): for file in files: if file.endswith('.java'): stream = FileStream(os.path.join(root, file), encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) ef_listener = EncapsulateFiledRefactoringListener( token_stream, package_name, source_class, field_name) tree = parser.compilationUnit() walker = ParseTreeWalker() walker.walk(t=tree, listener=ef_listener) ip_listener = InstancePropagationEncapsulateFieldListener( ef_listener.token_stream_rewriter, package_name, source_class, field_name) walker.walk(t=tree, listener=ip_listener) refactored = open(os.path.join(root, file), 'w', newline='') refactored.write( ip_listener.token_stream_rewriter.getDefaultText()) refactored.close() return True
def main(): # folder_path = "..\\benchmark_projects\\JSON\\src\\main\\java\\org\\json" folder_path = "../../tests/replace_constructor_with_factory_function_tests" path = os.listdir(folder_path) # target_class = "CDL" target_class = "Employee" for file in path: if file.endswith('.java') and not file.endswith('_refactored.java'): each = folder_path + "\\" + file stream = FileStream(str(each)) lexer = JavaLexer(stream) tokens = CommonTokenStream(lexer) parser = JavaParserLabeled(tokens) tree = parser.compilationUnit() new_file = open(os.path.join(folder_path, file + "_refactored.java"), mode='w', newline='') listener = ReplaceConstructorWithFactoryFunctionRefactoringListener( common_token_stream=tokens, target_class=target_class) walker = ParseTreeWalker() walker.walk(listener=listener, t=tree) new_code = str(listener.codeRewrite.getDefaultText()) new_file.write(new_code)
def __init__(self, udb_path, file_path, source_class, new_class, moved_fields, moved_methods, new_file_path=None): self.file_path = file_path self.udb_path = udb_path self.new_file_path = new_file_path self.source_class = source_class self.new_class = new_class self.moved_fields = moved_fields self.moved_methods = moved_methods self.stream = FileStream(self.file_path, encoding="utf-8", errors='ignore') self.lexer = JavaLexer(self.stream) self.token_stream = CommonTokenStream(self.lexer) self.parser = JavaParserLabeled(self.token_stream) self.tree = self.parser.compilationUnit() self.walker = ParseTreeWalker() self.method_usage_map = {} self.pass_this = False self.TAB = "\t" self.object_name = ""
def main(args): # Step 1: Load input source into stream stream = FileStream(args.file, encoding='utf8', errors='ignore') # Step 2: Create an instance of AssignmentStLexer lexer = JavaLexer(stream) # Step 3: Convert the input source into a list of tokens token_stream = CommonTokenStream(lexer) # Step 4: Create an instance of the AssignmentStParser parser = JavaParserLabeled(token_stream) parser.getTokenStream() # Step 5: Create parse tree parse_tree = parser.compilationUnit() # Step 6: Create an instance of the refactoringListener, and send as a parameter the list of tokens to the class # my_listener = EncapsulateFiledRefactoringListener(common_token_stream=token_stream, class_identifier='A') my_listener = SingletonRefactoringListener( common_token_stream=token_stream, class_identifier='GeneralPurposeBit') walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) newpath = "Refactored" + args.file if not os.path.exists(os.path.dirname(newpath)): try: os.makedirs(os.path.dirname(newpath)) except OSError as exc: # Guard against race condition pass with open(newpath, mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText())
def __init__(self, file_path, target_class, target_method, target_parameters): self.file_path = file_path self.new_file_path = file_path self.target_class = target_class self.target_method = target_method self.target_parameters = target_parameters self.stream = FileStream(self.file_path, encoding="utf8", errors='ignore') self.lexer = JavaLexer(self.stream) self.token_stream = CommonTokenStream(self.lexer) self.parser = JavaParserLabeled(self.token_stream) self.tree = self.parser.compilationUnit() self.walker = ParseTreeWalker()
class RemoveFlagArgument: """Refactoring API that can be used to to do remove flag argument """ def __init__(self, source_class="Playground", source_method="DeliveryDate", argument_name="b", main_file="playground.java"): """create a removeflagargument refactor Args: source_class (str): class name contaminated by code smell. source_mathod (str): method name contaminated. argument_name (str): boolean argument in method. main_file (str): path of main file containing source class. """ self.source_class = source_class self.source_method = source_method self.arguemnt_name = argument_name self.main_file = main_file self.stream = FileStream(self.main_file, encoding='utf8', errors='ignore') self.lexer = JavaLexer(self.stream) self.token_stream = CommonTokenStream(self.lexer) self.parser = JavaParserLabeled(self.token_stream) self.parser.getTokenStream() self.parse_tree = self.parser.compilationUnit() self.my_listener = RemoveFlagArgumentListener( common_token_stream=self.token_stream, source_class=self.source_class, source_method=self.source_method, argument_name=self.arguemnt_name) def do_refactor(self): """removes flag argument logic and replace it by two method call of the new method generated from extracted login in if else block """ walker = ParseTreeWalker() walker.walk(t=self.parse_tree, listener=self.my_listener) # self.my_listener.body_1 with open(self.main_file, 'w') as f: f.write(self.my_listener.token_stream_rewriter.getDefaultText())
class ReplaceParameterWithQueryAPI: def __init__(self, file_path, target_class, target_method, target_parameters): self.file_path = file_path self.new_file_path = file_path self.target_class = target_class self.target_method = target_method self.target_parameters = target_parameters self.stream = FileStream(self.file_path, encoding="utf8", errors='ignore') self.lexer = JavaLexer(self.stream) self.token_stream = CommonTokenStream(self.lexer) self.parser = JavaParserLabeled(self.token_stream) self.tree = self.parser.compilationUnit() self.walker = ParseTreeWalker() def do_refactor(self): listener = ReplaceParameterWithQueryRefactoringListener( common_token_stream=self.token_stream, target_class=self.target_class, target_method=self.target_method, target_parameters=self.target_parameters) self.walker.walk(listener=listener, t=self.tree) print(listener.add_to_top_of_target_method) print(listener.token_stream_rewriter.getDefaultText()) print(type(self.new_file_path)) with open(self.new_file_path, mode="w", newline="") as f: f.write(listener.token_stream_rewriter.getDefaultText())
def main(): Path = "../../tests/rename_tests/benchmark" Package_name = "org.json" class_identifier = "CDL" new_class_name = "test" FolderPath = os.listdir(Path) testsPath = os.listdir(Path + "/refactoredFiles/") # delete last refactored files for t in testsPath: os.remove(os.path.join(Path + "/refactoredFiles/", t)) for File in FolderPath: # We have all of the java files in this folder now if File.endswith('.java'): EachFilePath = Path + "/" + File print(" ****************" + " in file : " + File + " ****************") EachFile = FileStream(str(EachFilePath)) FileName = File.split(".")[0] Refactored = open(Path + "/refactoredFiles/" + FileName + "_Refactored.java", 'w', newline='') Lexer = JavaLexer(EachFile) TokenStream = CommonTokenStream(Lexer) Parser = JavaParserLabeled(TokenStream) Tree = Parser.compilationUnit() ListenerForReRenameClass =\ RenameClassRefactoringListener(TokenStream, Package_name, class_identifier, new_class_name) Walker = ParseTreeWalker() Walker.walk(ListenerForReRenameClass, Tree) Refactored.write(ListenerForReRenameClass.token_stream_rewriter.getDefaultText()) print("changing public class files name... ") for i in range(len(old_names)): os.rename(Path + "/refactoredFiles/" + old_names[i] + "_Refactored.java", Path + "/refactoredFiles/" + new_names[i] + "_Refactored.java") print(" %%%%%%%%%%%%%" + " all files finished " + "****************")
def add_implement_statement_to_class(self, ): stream = FileStream(self.class_path, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() listener = AddingImplementStatementToClass( common_token_stream=token_stream, class_name=os.path.splitext(os.path.basename(self.class_path))[0], interface_package=self.interface_info['package'], interface_name=self.interface_info['name'] ) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=listener) with open(self.class_path, encoding='utf8', errors='ignore', mode='w', newline='') as f: f.write(listener.token_stream_rewriter.getDefaultText())
def main(udb_path, source_class, field_name, *args, **kwargs): """ Main API for make field non-static """ main_file = None db = und.open(udb_path) classes = db.ents("Class") for cls in classes: if cls.simplename() == source_class: if cls.parent() is not None: temp_file = str(cls.parent().longname(True)) if os.path.isfile(temp_file): main_file = temp_file break if main_file is None: db.close() return False db.close() stream = FileStream(main_file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = MakeFieldNonStaticRefactoringListener( common_token_stream=token_stream, source_class=source_class, field_name=field_name) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) with open(main_file, mode='w', encoding='utf8', errors='ignore', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) return True
def propagate_fields(self, usages): for usage in usages: file_path = usage.pop('file_path') stream = FileStream(file_path, encoding='utf-8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parse_tree = parser.compilationUnit() my_listener = PropagateFieldUsageListener( common_token_stream=token_stream, object_name=self.object_name, **usage) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) # print(my_listener.token_stream_rewriter.getDefaultText()) with open(file_path, mode='w', encoding='utf-8', errors='ignore') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) self.reformat(file_path)
def main(args): # Step 1: Load input source into stream begin_time = time() stream = FileStream(args.file, encoding='utf8', errors='ignore') # input_stream = StdinStream() print('Input stream:') print(stream) # Step 2: Create an instance of AssignmentStLexer lexer = JavaLexer(stream) # Step 3: Convert the input source into a list of tokens token_stream = CommonTokenStream(lexer) # Step 4: Create an instance of the AssignmentStParser parser = JavaParserLabeled(token_stream) parser.getTokenStream() # Step 5: Create parse tree parse_tree = parser.compilationUnit() # Step 6: Create an instance of the refactoringListener, and send as a parameter the list of tokens to the class my_listener = VisitorPatternRefactoringListener( common_token_stream=token_stream, SuperClass_identifier='SC', SubClass_identifier=['CC1', 'CC2', 'CC3'] ) # SuperClass_identifier='ComputerPart', # SubClass_identifier=['Keyboard', 'Monitor', 'Mouse', 'Computer']) # SuperClass_identifier='Shape', # SubClass_identifier=['Polygon', 'Rectangle','Arrow']) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) print('Compiler result:') print(my_listener.token_stream_rewriter.getDefaultText()) with open('../../tests/visitor1/VisitorExample0.refactored.java', mode='w', newline='') as f: # with open('VisitorExample1.refactored.java', mode='w', newline='') as f: # with open('VisitorExample2.refactored.java', mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) end_time = time() print("time execution : ", end_time - begin_time)
def main(): path_ = "../../tests/rename_tests/benchmark" package_name_ = "org.json" class_identifier_ = "HTTP" field_identifier_ = "CRLF" field_new_name_ = "test" folder_path = os.listdir(path_) tests_path = os.listdir(path_ + "/refactoredFiles/") # delete last refactored files for t in tests_path: os.remove(os.path.join(path_ + "/refactoredFiles/", t)) for file_ in folder_path: # We have all java files in this folder now if file_.endswith('.java'): file_path = path_ + "/" + file_ file_stream = FileStream(str(file_path)) file_name = file_.split(".")[0] refactored = open(path_ + "/refactoredFiles/" + file_name + "_Refactored.java", 'w', newline='') lexer = JavaLexer(file_stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) tree = parser.compilationUnit() rename_field_refactoring_listener = RenameFieldRefactoringListener( token_stream, package_name_, class_identifier_, field_identifier_, field_new_name_) walker = ParseTreeWalker() walker.walk(rename_field_refactoring_listener, tree) refactored.write(rename_field_refactoring_listener. token_stream_rewriter.getDefaultText()) print(" %%%%%%%%%%%%%" + " all files finished " + "****************")
def rename_method(java_file_path, scope_class_name, target_method_name, new_name, reference=None): """Main Entry Point to the Listener and Tree Walker Args: java_file_path(str): Address path to the test/source file scope_class_name(str): Name of the class in which the refactoring has to be done target_method_name(str): Name of the method in which the refactoring has to be done new_name(str): The new name of the refactored method reference(str): Keeping track for all of the method references in the project scope Returns: No Returns """ stream = FileStream(java_file_path) lexer = JavaLexer(stream) tokens = CommonTokenStream(lexer) parser = JavaParserLabeled(tokens) tree = parser.compilationUnit() listener = RenameMethodListener(java_file_path=java_file_path, common_token_stream=tokens, scope_class_name=scope_class_name, target_method_name=target_method_name, new_name=new_name, reference=reference) walker = ParseTreeWalker() walker.walk(listener, tree) if listener.changed: # print(java_file_path) new_file = open(file=java_file_path, mode='w') new_file.write(listener.token_stream_rewriter.getDefaultText().replace( '\r', ''))
def main(args): # Step 1: Load input source into stream begin_time = time() stream = FileStream(args.file, encoding='utf8', errors='ignore') # input_stream = StdinStream() print('Input stream:') print(stream) # Step 2: Create an instance of AssignmentStLexer lexer = JavaLexer(stream) # Step 3: Convert the input source into a list of tokens token_stream = CommonTokenStream(lexer) # Step 4: Create an instance of the AssignmentStParser parser = JavaParserLabeled(token_stream) parser.getTokenStream() # Step 5: Create parse tree parse_tree = parser.compilationUnit() # Step 6: Create an instance of the refactoringListener, and send as a parameter the list of tokens to the class my_listener = StrategyPatternRefactoringListener( common_token_stream=token_stream, method_identifier='execute') # method_identifier='read') # method_identifier='write') walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) print('Compiler result:') print(my_listener.token_stream_rewriter.getDefaultText()) with open('../../tests/strategy1/StrategyExample0.refactored.java', mode='w', newline='') as f: # with open('StrategyExample1.refactored.java', mode='w', newline='') as f: # with open('StrategyExample2.refactored.java', mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) end_time = time() print("execute time : ", end_time - begin_time)
def main(args): # Step 1: Load input source into stream stream = FileStream(args.file, encoding='utf8', errors='ignore') # input_stream = StdinStream() # Step 2: Create an instance of AssignmentStLexer lexer = JavaLexer(stream) # Step 3: Convert the input source into a list of tokens token_stream = CommonTokenStream(lexer) # Step 4: Create an instance of the AssignmentStParser parser = JavaParserLabeled(token_stream) parser.getTokenStream() # Step 5: Create parse tree parse_tree = parser.compilationUnit() # Step 6: Create an instance of the refactoringListener, and send as a parameter the list of tokens to the class my_listener = FactoryMethodRefactoringListener(common_token_stream=token_stream, creator_identifier='FactoryMethod', products_identifier=['JpegReader', 'GifReader']) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) with open('../../tests/factory1/FactoryExample.refactored.java', mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText())
def main(args): # Step 1: Load input source into stream stream = FileStream(args.file, encoding='utf8', errors='ignore') # input_stream = StdinStream() # Step 2: Create an instance of AssignmentStLexer # lexer = Java9_v2Lexer(stream) # Deprecated lexer = JavaLexer(stream) # Current lexer # Step 3: Convert the input source into a list of tokens common_token_stream = CommonTokenStream(lexer) # Step 4: Create an instance of the AssignmentStParser # parser = Java9_v2Parser(common_token_stream) # Deprecated parser = JavaParserLabeled(common_token_stream) # Current parser # parser.getTokenStream() # Step 5: Create parse tree # 5.1. Python backend --> Low speed parse_tree = parser.compilationUnit() # 5.2. C++ backend --> high speed # parse_tree = sa_java9_v2.parse(stream, 'compilationUnit', None) # Deprecated # Step 6: Create an instance of AssignmentStListener my_listener = EncapsulateFiledRefactoringListener( common_token_stream=common_token_stream, field_identifier='f') # my_listener = ExtractClassRefactoringListener(common_token_stream=token_stream, class_identifier='Worker') # return walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) with open('../tests/encapsulate_field_tests/input.refactored.java', mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText())
def main(class_path): """ Args: class_path (str): The java file path containing the public class """ # Precondition 1: The interface should not be already exist. interface_path = os.path.join( os.path.dirname(class_path), f'I{os.path.splitext(os.path.basename(class_path))[0]}.java' ) if os.path.exists(interface_path): return False stream = FileStream(class_path, encoding='utf-8', errors='ignore') lexer = JavaLexer(stream) tokens = CommonTokenStream(lexer) parser = JavaParserLabeled(tokens) tree = parser.compilationUnit() listener = InterfaceInfoListener() walker = ParseTreeWalker() walker.walk(listener=listener, t=tree) interface_info_ = listener.get_interface_info() interface_info_['name'] = 'I' + interface_info_['name'] interface_info_['path'] = os.path.dirname(class_path) ic = InterfaceCreator(interface_info_, class_path) ic.add_implement_statement_to_class() ic.save() return True
def extract_method(conf): stream = FileStream(conf['target_file'], encoding="utf-8", errors='ignore') lexer = JavaLexer(stream) tokens = CommonTokenStream(lexer) parser = JavaParserLabeled(tokens) tree = parser.compilationUnit() listener = ExtractMethodRefactoring( list(map(int, list(conf['lines'].keys())))) walker = ParseTreeWalker() walker.walk(listener=listener, t=tree) if not listener.is_result_valid: raise Exception('Some problem happened!') if listener.methods_name.__contains__(conf['new_method_name']): raise Exception('New method name already exists.') output = [] file1 = open(conf['target_file'], 'r', encoding="utf-8", errors='ignore') lines = file1.readlines() line_num = 1 # func_added = False func = [] print('extracting following lines:') for line in lines: if listener.lines.__contains__(line_num): print(line, end='') if line_num == listener.last_line: output.append( get_tabs(line) + listener.get_write_variable() + conf['new_method_name'] + listener.get_args(False) + '\n') func.append(line) if conf['lines'][line_num]: output.append(line) elif line_num == listener.method_stop_line: output.append(line) output.append( get_tabs(line) + 'private ' + ('static ' if listener.is_target_method_static else '') + (listener.return_variable_type if listener. return_variable_type else 'void') + ' ' + conf['new_method_name'] + listener.get_args(True) + ((' throws ' + listener.exception_thrown_in_target_method) if listener. exception_thrown_in_target_method is not None else '') + '\n') output.append(get_tabs(line) + '{\n') for item in listener.pre_variables.keys(): var = listener.pre_variables[item] if var.keys().__contains__('write') and not var['write']: output.append( get_tabs(line) + '\t' + var['type'] + ' ' + item + ';\n') output = output + func if listener.return_variable is not None: output.append( get_tabs(line) + '\treturn ' + listener.return_variable + ';\n') output.append(get_tabs(line) + '}\n') else: output.append(line) line_num += 1 file1.close() file2 = open(conf['output_file'], 'w', encoding="utf-8", errors='ignore') for item in output: file2.write(item) file2.close()
def main(args): input_directory = args.directory input_java_files = [file for file in os.listdir(input_directory) if '.java' in file] refactoring_id = args.refactor source_class_data = None target_class = None target_class_data = None is_complete = False print("Process started") for i in range(2): for file in input_java_files: # Step 1: Load input source into stream if i == 0: stream = FileStream(input_directory + '/' + file, encoding='utf8', errors='ignore') else: stream = FileStream('benchmark_projects/refactored/' + '/' + file, encoding='utf8', errors='ignore') # input_stream = StdinStream() # Step 2: Create an instance of AssignmentStLexer lexer = JavaLexer(stream) # Step 3: Convert the input source into a list of tokens token_stream = CommonTokenStream(lexer) # Step 4: Create an instance of the AssignmentStParser parser = JavaParserLabeled(token_stream) tree = parser.compilationUnit() # Step 6: Create an instance of AssignmentStListener if refactoring_id == 'c': my_listener = CollapseHierarchyRefactoringListener( common_token_stream=token_stream, source_class='JSONStringer', target_class=target_class, source_class_data=source_class_data, target_class_data=target_class_data, is_complete=is_complete ) walker = ParseTreeWalker() walker.walk(t=tree, listener=my_listener) target_class = my_listener.target_class source_class_data = my_listener.source_class_data target_class_data = my_listener.target_class_data is_complete = my_listener.is_complete elif refactoring_id == 'i': my_listener = InlineClassRefactoringListener( common_token_stream=token_stream, source_class='HTTPTokener', target_class='JSONTokener', source_class_data=source_class_data, target_class_data=target_class_data, is_complete=is_complete ) walker = ParseTreeWalker() walker.walk(t=tree, listener=my_listener) target_class = my_listener.target_class source_class_data = my_listener.source_class_data target_class_data = my_listener.target_class_data is_complete = my_listener.is_complete elif refactoring_id == 'ms': my_listener = MakeMethodStaticRefactoringListener( common_token_stream=token_stream, target_class='JSONPointer', target_methods=['toURIFragment'] ) walker = ParseTreeWalker() walker.walk(t=tree, listener=my_listener) else: my_listener = MakeMethodNonStaticRefactoringListener( common_token_stream=token_stream, target_class='JSONPointer', target_methods=['builder'] ) with open('benchmark_projects/refactored/' + file, mode='w+', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) print("/\\", end='')
def main(udb, child, parent): # initialize with understand udb_path = "/home/ali/Desktop/code/TestProject/TestProject.udb" child_path_file = "" father_path_file = "" file_list_to_be_propagate = set() propagate_classes = set() # db = und.open(udb) # for cls in db.ents("class"): # if cls.simplename() == child: # child_path_file = cls.parent().longname() # for ref in cls.refs("Coupleby"): # propagate_classes.add(ref.ent().longname()) # file_list_to_be_propagate.add(ref.ent().parent().longname()) # if cls.simplename() == parent: # father_path_file = cls.parent().longname() file_list_to_be_propagate = list(file_list_to_be_propagate) propagate_classes = list(propagate_classes) stream = FileStream(child_path_file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener_field_text = CollapseHierarchyRefactoringGetFieldTextListener( common_token_stream=token_stream, child_class=child) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_field_text) field_code = my_listener_field_text.fieldcode my_listener_method_text = CollapseHierarchyRefactoringGetMethodTextListener( common_token_stream=token_stream, child_class=child) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_method_text) methods_code = my_listener_method_text.methodcode # Remove child class my_listener_remove_child_class = RemoveClassRefactoringListener( common_token_stream=token_stream, class_name=child) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_remove_child_class) with open(child_path_file, mode='w', newline='') as f: f.write(my_listener_remove_child_class.token_stream_rewriter. getDefaultText()) # Refactor stream = FileStream(father_path_file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener_refactor_action = CollapseHierarchyRefactoringListener( common_token_stream=token_stream, parent_class=parent, child_class=child, field_text=field_code, method_text=methods_code) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_refactor_action) with open(father_path_file, mode='w', newline='') as f: f.write( my_listener_refactor_action.token_stream_rewriter.getDefaultText()) # Propagate for file in file_list_to_be_propagate: stream = FileStream(file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener_propagate = PropagationCollapseHierarchyListener( token_stream_rewriter=token_stream, old_class_name=child, new_class_name=parent, propagated_class_name=propagate_classes) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_propagate) with open(file, mode='w', newline='') as f: f.write( my_listener_propagate.token_stream_rewriter.getDefaultText())
def main(): """ it builds the parse tree and walk its corresponding walker so that our overridden methods run. """ # udb_path = "/home/ali/Desktop/code/TestProject/TestProject.udb" # udb_path=create_understand_database("C:\\Users\\asus\\Desktop\\test_project") # source_class = "GodClass" # moved_methods = ['method1', 'method3', ] # moved_fields = ['field1', 'field2', ] udb_path = "C:\\Users\\asus\\Desktop\\test_project\\test_project.udb" # moved_methods = ['getValue', 'rowToJSONArray', 'getVal', ] # moved_fields = ['number_2', 'number_1', ] source_class = "GodClass" moved_methods = ['method1', 'method3'] moved_fields = ['field1', 'field2'] father_path_file = "/data/Dev/JavaSample/src/GodClass.java" father_path_directory = "/data/Dev/JavaSample/src" path_to_refactor = "/data/Dev/JavaSample/src" new_class_file = "/data/Dev/JavaSample/src/GodSubClass.java" # source_class = "TaskNode" # moved_methods = ['getUserObject'] # moved_fields = [] # father_path_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\ganttproject\\ganttproject\\src\\main\\java\\net\\sourceforge\\ganttproject\\task\\TaskNode.java" # father_path_directory = "C:\\Users\\asus\\Desktop\\benchmark_projects\\ganttproject\\ganttproject\\src\\main\\java\\net\\sourceforge\\ganttproject\\task" # path_to_refactor = "C:\\Users\\asus\\Desktop\\benchmark_projects\\ganttproject" # new_class_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\ganttproject\\ganttproject\\src\\main\\java\\net\\sourceforge\\ganttproject\\task\\TaskNodeextracted.java" # source_class = "SecuritySupport" # moved_methods = ['getSystemProperty'] # moved_fields = [] # father_path_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j\\src\\org\\apache\\html\\dom\\SecuritySupport.java" # father_path_directory = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j\\src\\org\\apache\\html\\dom" # path_to_refactor = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j" # new_class_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j\\src\\org\\apache\\html\\dom\\SecuritySupportextracted.java" # source_class = "BaseMarkupSerializer" # moved_methods = ['setOutputCharStream'] # moved_fields = [] # father_path_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j\\src\\org\\apache\\xml\\serialize\\BaseMarkupSerializer.java" # father_path_directory = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j\\src\\org\\apache\\xml\\serialize" # path_to_refactor = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j" # new_class_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j\\src\\org\\apache\\xml\\serialize\\BaseMarkupSerializerextracted.java" # source_class = "Piece" # moved_methods = ['setX'] # moved_fields = [] # father_path_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\Chess_master\\src\\game\\Piece.java" # father_path_directory = "C:\\Users\\asus\\Desktop\\benchmark_projects\\Chess_master\\src\\game" # path_to_refactor = "C:\\Users\\asus\\Desktop\\benchmark_projects\\Chess_master" # new_class_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\Chess_master\\src\\game\\Pieceextracted.java" stream = FileStream(father_path_file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = ExtractSubClassRefactoringListener( common_token_stream=token_stream, source_class=source_class, new_class=source_class + "extracted", moved_fields=moved_fields, moved_methods=moved_methods, output_path=father_path_directory) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) with open(father_path_file, mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) extractJavaFilesAndProcess(path_to_refactor, father_path_file, new_class_file) for file in files_to_refactor: stream = FileStream(file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = FindUsagesListener(common_token_stream=token_stream, source_class=source_class, new_class=source_class + "extracted", moved_fields=moved_fields, moved_methods=moved_methods, output_path=father_path_directory) # output_path=father_path_directory) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) tmp_aul = my_listener.aul with open(file, mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) # after find usages try: stream = FileStream(file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = PropagationListener( common_token_stream=token_stream, source_class=source_class, new_class=source_class + "extracted", moved_fields=moved_fields, moved_methods=moved_methods, output_path=father_path_directory, aul=tmp_aul) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) with open(file, mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) except: print("not utf8")
def main(udb_path: str, children_classes: list, method_name: str, *args, **kwargs): """ """ if len(children_classes) <= 1: logger.error("len(children_classes) should be gte 2") return False # Initialize with understand destination_class = "" fileslist_to_be_rafeactored = set() fileslist_to_be_propagate = set() propagation_classes = set() db = und.open(udb_path) try: method_ents = [ db.lookup(i + "." + method_name, "method")[0] for i in children_classes ] except IndexError: # print([db.lookup(i + "." + method_name, "method") for i in children_classes]) logger.error( f"Method {method_name} does not exists in all children_classes.") db.close() return False # Get method text method_text = method_ents[0].contents().strip() for method_ent in method_ents: if method_ent.contents().strip() != method_text: logger.error("Method content is different.") db.close() return False for ref in method_ent.refs("Use,Call"): if ref.ent().parent() is not None: if ref.ent().parent().simplename() in children_classes: logger.error("Method has internal dependencies.") db.close() return False for mth in db.ents("Java Method"): for child in children_classes: if mth.longname().endswith(child + "." + method_name): fileslist_to_be_rafeactored.add( mth.parent().parent().longname()) for fth in mth.parent().refs("Extend"): destination_class = fth.ent().longname() fileslist_to_be_rafeactored.add( fth.ent().parent().longname()) for ref in mth.refs("Java Callby"): propagation_classes.add(ref.ent().parent().longname()) fileslist_to_be_propagate.add( ref.ent().parent().parent().longname()) db.close() # print("=========================================") # print("fileslist_to_be_propagate :", fileslist_to_be_propagate) # print("propagation_classes : ", propagation_classes) # print("fileslist_to_be_rafeactored :", fileslist_to_be_rafeactored) # print("father class :", destination_class) fileslist_to_be_rafeactored = list(fileslist_to_be_rafeactored) fileslist_to_be_propagate = list(fileslist_to_be_propagate) propagation_class = list(propagation_classes) # refactored start for file in fileslist_to_be_rafeactored: try: stream = FileStream(file, encoding='utf-8', errors='ignore') except: continue lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener_refactor = PullUpMethodRefactoringListener( common_token_stream=token_stream, destination_class=destination_class, children_class=children_classes, moved_methods=method_name, method_text=method_text) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_refactor) with open(file, mode='w', encoding='utf-8', newline='') as f: f.write( my_listener_refactor.token_stream_rewriter.getDefaultText()) # end refactoring # beginning of propagate for file in fileslist_to_be_propagate: if not os.path.exists(file): continue stream = FileStream(file, encoding='utf-8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener_propagate = PropagationPullUpMethodRefactoringListener( token_stream_rewriter=token_stream, old_class_name=children_classes, new_class_name=destination_class, propagated_class_name=propagation_class) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_propagate) with open(file, mode='w', encoding='utf8', errors='ignore', newline='') as f: f.write( my_listener_propagate.token_stream_rewriter.getDefaultText()) # end of propagate return True
if __name__ == '__main__': listener = ReplaceConditionalWithPolymorphism( "../../tests/replace_conditional_with_polymorphism/sample.java", "SwitchDemo", "myMethod") try: stream = FileStream(listener.file) except: print("Path not found") pass classname = listener.class_name func = listener.method_name lexer = JavaLexer(stream) tokens = CommonTokenStream(lexer) parser = JavaParserLabeled(tokens) tree = parser.compilationUnit() walker = ParseTreeWalker() walker.walk(listener=listener, t=tree) token = lexer.reset() if len(found_class) > 0 and len(found_func) > 0: token = lexer.nextToken() not_switch = True opening = "" while token.type != Token.EOF: if not_switch: if token.type != lexer.SWITCH: opening += token.text if token.type == lexer.SWITCH: not_switch = False token = lexer.nextToken()
def main(args): files = get_file_dirs(args.dir) create_new_project_dir('JavaProjectRefactored', files) ref = input(" choose your refactoring :") for file in files: # Step 1: Load input source into stream m = re.search(r'^.*\.java$', file) if m is None: continue print(file) stream = FileStream(file, encoding='utf8', errors='ignore') # input_stream = StdinStream() # Step 2: Create an instance of AssignmentStLexer lexer = JavaLexer(stream) # Step 3: Convert the input source into a list of tokens token_stream = CommonTokenStream(lexer) # Step 4: Create an instance of the AssignmentStParser parser = JavaParserLabeled(token_stream) parser.getTokenStream() # Step 5: Create parse tree parse_tree = parser.compilationUnit() # Step 6: Create an instance of AssignmentStListener # my_listener = RenameClassRefactoringListener(common_token_stream=token_stream, class_new_name='Z', # class_identifier='A', package_identifier="Dummy") if ref == "Rename": print("Rename class =>") my_listener = RenameClassRefactoringListener( common_token_stream=token_stream, class_new_name='Z', class_identifier='ReflectiveXmlRpcMetaDataHandler', package_identifier="org.apache.xmlrpc.metadata") elif ref == "Static": print("Make field static =>") my_listener = MakeFieldStaticRefactoringListener( common_token_stream=token_stream, field_identifier='methodHelp', class_identifier='ReflectiveXmlRpcMetaDataHandler', package_identifier="org.apache.xmlrpc.metadata") elif ref == "Non-Static": print("Make field Non static =>") my_listener = MakeFieldNonStaticRefactoringListener( common_token_stream=token_stream, field_identifier='log', class_identifier='XmlRpcErrorLogger', package_identifier="org.apache.xmlrpc.server") else: print("Not Valid") break walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) if ref == "Non Static" and my_listener.canceled: rewrite_project(files, 'JavaProjectRefactored') break if ref == "Rename" and my_listener.in_selected_class: splited_dir = file.split('/') splited_dir[0] = 'JavaProjectRefactored' if os.path.exists("/".join(splited_dir)): os.remove("/".join(splited_dir)) splited_dir[-1] = my_listener.class_new_name + ".java" with open("/".join(splited_dir), mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) else: splited_dir = file.split('/') splited_dir[0] = 'JavaProjectRefactored' with open("/".join(splited_dir), mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText())
# self.token_stream_rewriter.replaceRange( # from_idx=ctx.start.tokenIndex+1, # to_idx=ctx.start.tokenIndex+1, # text="\n"+self.field_text+"\n" # ) if __name__ == '__main__': udb_path = "/home/ali/Desktop/code/TestProject/TestProject.udb" source_class = "Triangle" # initialize with understand main_file = "" db = und.open(udb_path) for cls in db.ents("class"): if cls.simplename() == source_class: main_file = cls.parent().longname() db.close() stream = FileStream(main_file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = MakeNonFinalClassRefactoringListener(common_token_stream=token_stream, class_name=source_class) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) with open(main_file, mode='w', encoding='utf8', errors='ignore', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText())
class ExtractClassAPI: def __init__(self, udb_path, file_path, source_class, new_class, moved_fields, moved_methods, new_file_path=None): self.file_path = file_path self.udb_path = udb_path self.new_file_path = new_file_path self.source_class = source_class self.new_class = new_class self.moved_fields = moved_fields self.moved_methods = moved_methods self.stream = FileStream(self.file_path, encoding="utf-8", errors='ignore') self.lexer = JavaLexer(self.stream) self.token_stream = CommonTokenStream(self.lexer) self.parser = JavaParserLabeled(self.token_stream) self.tree = self.parser.compilationUnit() self.walker = ParseTreeWalker() self.method_usage_map = {} self.pass_this = False self.TAB = "\t" self.object_name = "" def check_dependency_graph(self): listener = DependencyPreConditionListener( common_token_stream=self.token_stream, class_identifier=self.source_class) self.walker.walk(listener=listener, t=self.tree) component = sorted(self.moved_methods + self.moved_fields) if component in sorted(listener.connected_components): self.checked = True if len(listener.connected_components) == 0: self.checked = True def get_source_class_map(self): _db = und.open(self.udb_path) class_ents = _db.lookup(self.source_class, "Class") class_ent = None for ent in class_ents: if ent.parent() is not None: if Path(ent.parent().longname()) == Path(self.file_path): class_ent = ent break if class_ent is None: _db.close() return for ref in class_ent.refs("Define", "Method"): method_ent = ref.ent() self.method_usage_map[method_ent.simplename()] = set() for use in method_ent.refs("Setby Useby Modifyby, Call", "Variable ~Unknown, Method ~Unknown"): self.method_usage_map[method_ent.simplename()].add( use.ent().simplename()) _db.close() def propagate_fields(self, usages): for usage in usages: file_path = usage.pop('file_path') stream = FileStream(file_path, encoding='utf-8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parse_tree = parser.compilationUnit() my_listener = PropagateFieldUsageListener( common_token_stream=token_stream, object_name=self.object_name, **usage) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) # print(my_listener.token_stream_rewriter.getDefaultText()) with open(file_path, mode='w', encoding='utf-8', errors='ignore') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) self.reformat(file_path) @staticmethod def reformat(file_path: str): # formatter = os.path.abspath("../assets/formatter/google-java-format-1.10.0-all-deps.jar") # subprocess.call(["java", "-jar", formatter, "--replace", file_path]) pass def do_refactor(self): listener = ExtractClassRefactoringListener( common_token_stream=self.token_stream, new_class=self.new_class, source_class=self.source_class, moved_fields=self.moved_fields, moved_methods=self.moved_methods, method_map=self.method_usage_map) self.object_name = listener.object_name self.walker.walk(listener=listener, t=self.tree) # Find Field and Method Usages _db = und.open(self.udb_path) field_usages = [] for field in self.moved_fields: for ent in _db.lookup(f"{self.source_class}.{field}"): # print(ent.name(), " [", ent.kindname(), "]", sep="", end="\n") for ref in ent.refs("Useby, Setby, Modifyby"): if Path(ref.file().longname()) == Path(self.file_path): continue field_usage = { 'field_name': field, 'file_path': ref.file().longname() } if field_usage not in field_usages: field_usages.append(field_usage) _db.close() # print(listener.token_stream_rewriter.getDefaultText()) # print("=" * 25) # print(listener.code) stream = InputStream(listener.code) lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = NewClassPropagation(common_token_stream=token_stream, method_map=self.method_usage_map, source_class=self.source_class, moved_fields=self.moved_fields) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) # print(my_listener.token_stream_rewriter.getDefaultText()) # Write Changes with open(self.file_path, mode='w', encoding='utf-8', errors='ignore', newline='') as f: f.write(listener.token_stream_rewriter.getDefaultText()) # Write new class with open(self.new_file_path, mode='w', encoding='utf-8', errors='ignore', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) # Propagate and reformat self.propagate_fields(field_usages) self.reformat(self.file_path) self.reformat(self.new_file_path) return True
def do_refactor(self): listener = ExtractClassRefactoringListener( common_token_stream=self.token_stream, new_class=self.new_class, source_class=self.source_class, moved_fields=self.moved_fields, moved_methods=self.moved_methods, method_map=self.method_usage_map) self.object_name = listener.object_name self.walker.walk(listener=listener, t=self.tree) # Find Field and Method Usages _db = und.open(self.udb_path) field_usages = [] for field in self.moved_fields: for ent in _db.lookup(f"{self.source_class}.{field}"): # print(ent.name(), " [", ent.kindname(), "]", sep="", end="\n") for ref in ent.refs("Useby, Setby, Modifyby"): if Path(ref.file().longname()) == Path(self.file_path): continue field_usage = { 'field_name': field, 'file_path': ref.file().longname() } if field_usage not in field_usages: field_usages.append(field_usage) _db.close() # print(listener.token_stream_rewriter.getDefaultText()) # print("=" * 25) # print(listener.code) stream = InputStream(listener.code) lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = NewClassPropagation(common_token_stream=token_stream, method_map=self.method_usage_map, source_class=self.source_class, moved_fields=self.moved_fields) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) # print(my_listener.token_stream_rewriter.getDefaultText()) # Write Changes with open(self.file_path, mode='w', encoding='utf-8', errors='ignore', newline='') as f: f.write(listener.token_stream_rewriter.getDefaultText()) # Write new class with open(self.new_file_path, mode='w', encoding='utf-8', errors='ignore', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) # Propagate and reformat self.propagate_fields(field_usages) self.reformat(self.file_path) self.reformat(self.new_file_path) return True
def main(udb_path, source_package, source_class, method_name, target_classes: list, *args, **kwargs): """ The main API for the push-down method refactoring operation """ target_package = source_package source_method = method_name main_file = None source_method_entity = None is_static = False propagation_files = [] propagation_classes = [] propagation_lines = [] children_classes = [] children_files = [] # Initialize with understand db = und.open(udb_path) methods = db.ents("Java Method") for mth in methods: if mth.longname( ) == source_package + "." + source_class + "." + source_method: source_method_entity = mth for child_ref in mth.parent().refs("Extendby"): child_ref = child_ref.ent() if child_ref.simplename() in target_classes: children_classes.append(child_ref.simplename()) children_files.append(child_ref.parent().longname()) # print("mainfile : ", mth.parent().parent().longname()) is_static = mth.kind().check("static") main_file = mth.parent().parent().longname() for ref in mth.refs("Callby"): propagation_files.append( ref.ent().parent().parent().longname()) propagation_classes.append(ref.ent().parent().simplename()) propagation_lines.append(ref.line()) # Check pre-condition if not len(target_classes) == 1: logger.error(f"len(target_classes) is not 1.") db.close() return False if not len(children_classes) == 1: logger.error(f"len(children_classes) is not 1.") db.close() return False if not len(children_files) == 1: logger.error(f"len(children_files) is not 1.") db.close() return False for mth in methods: if mth.simplename() == source_method: if mth.parent().simplename() in target_classes: if mth.type() == source_method_entity.type(): if mth.kind() == source_method_entity.kind(): if mth.parameters() == source_method_entity.parameters( ): logger.error("Duplicated method") db.close() return False for ref in source_method_entity.refs("use, call"): ref_ent = ref.ent() is_public = ref_ent.kind().check("public") if not is_public: logger.error("Has internal dependencies.") db.close() return False # get text method_text = source_method_entity.contents() db.close() # Delete source method stream = FileStream(main_file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = DeleteSourceListener(common_token_stream=token_stream, source_method=source_method) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) # print(my_listener.token_stream_rewriter.getDefaultText()) with open(main_file, mode='w', encoding='utf-8', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) # Do the push down for child_file, child_class in zip(children_files, children_classes): stream = FileStream(child_file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = PushDownMethodRefactoringListener( common_token_stream=token_stream, source_class=child_class, source_method_text=method_text) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) # print(my_listener.token_stream_rewriter.getDefaultText()) with open(child_file, mode='w', encoding='utf8', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) # Propagation for file, _class, line in zip(propagation_files, propagation_classes, propagation_lines): stream = FileStream(file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() if is_static: my_listener = PropagationStaticListener( common_token_stream=token_stream, source_class=source_class, child_class=children_classes[0], class_name=_class, method_name=source_method, ref_line=line, target_package=target_package) else: my_listener = PropagationNonStaticListener( common_token_stream=token_stream, source_class=source_class, child_class=children_classes[0], class_name=_class, method_name=source_method, ref_line=line, target_package=target_package) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) # print(my_listener.token_stream_rewriter.getDefaultText()) with open(file, mode='w', encoding='utf8', errors='ignore', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) return True