def main(): Path = "../tests/rename_tests/benchmark" package_identifier = "json" new_package_name = "test" FolderPath = os.listdir(Path) testsPath = os.listdir(Path + "/refactoredFiles/") for File in FolderPath: # We have all of the java files in this folder now if File.endswith('.java'): EachFilePath = Path + "\\" + File EachFile = FileStream(str(EachFilePath)) Lexer = JavaLexer(EachFile) TokenStream = CommonTokenStream(Lexer) Parser = JavaParserLabeled(TokenStream) Tree = Parser.compilationUnit() find_packages = FindPackages(TokenStream) Walker = ParseTreeWalker() Walker.walk(find_packages, Tree) # 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 = \ RenamePackageRefactoringListener(TokenStream, package_identifier, new_package_name, packages) Walker = ParseTreeWalker() Walker.walk(ListenerForReRenameClass, Tree) Refactored.write(ListenerForReRenameClass.token_stream_rewriter.getDefaultText()) print(" %%%%%%%%%%%%%" + " all files finished " + "****************")
def is_equal(file1, file2): input_stream1 = FileStream(file1) lexer1 = JavaLexer(input_stream1) input_stream2 = FileStream(file2) lexer2 = JavaLexer(input_stream2) token1 = lexer1.nextToken() token2 = lexer2.nextToken() params1 = set([]) params2 = set([]) add_to_params = False while token1.type != Token.EOF and token2.type != Token.EOF: if token1.type == lexer1.LINE_COMMENT or token1.type == lexer1.COMMENT or token1.type == lexer1.WS: token1 = lexer1.nextToken() continue if token2.type == lexer2.LINE_COMMENT or token2.type == lexer2.COMMENT or token2.type == lexer2.WS: token2 = lexer2.nextToken() continue if token1.text != token2.text: if token1.type == lexer1.THROWS: while token1.type != lexer1.LBRACE: token1 = lexer1.nextToken() elif add_to_params: params1.add(token1.text) params2.add(token2.text) else: print(token1.line) print(token2.line) print(token1.text, '!=', token2.text, ' = ', token1.text != token2.text) return False elif token1.type == lexer1.LPAREN: add_to_params = True elif token1.type == lexer1.RPAREN: add_to_params = False if len(params1) != len(params2): return False for param in params1: if not params2.__contains__(param): return False token1 = lexer1.nextToken() token2 = lexer2.nextToken() return True
def main(): Path = "../tests/rename_tests/" FolderPath = os.listdir(Path) for File in FolderPath: # We have all of the java files in this folder now if File.endswith('.java'): EachFilePath = Path + "\\" + File EachFile = FileStream(str(EachFilePath)) Lexer = JavaLexer(EachFile) TokenStream = CommonTokenStream(Lexer) Parser = JavaParserLabeled(TokenStream) Tree = Parser.compilationUnit() find_packages = FindPackages(TokenStream) Walker = ParseTreeWalker() Walker.walk(find_packages, Tree) rename_method_test_file = FileStream(str(Path + "rename_package_test.java")) print("file opened") Refactored = open(os.path.join(Path, "rename_package_test_Refactored.java"), 'w', newline='') Lexer = JavaLexer(rename_method_test_file) TokenStream = CommonTokenStream(Lexer) Parser = JavaParserLabeled(TokenStream) Tree = Parser.compilationUnit() ListenerForReRename = RenamePackageRefactoringListener( TokenStream, "jsoniter", "jsoniter_new", find_packages.packages) Walker = ParseTreeWalker() Walker.walk(ListenerForReRename, Tree) Refactored.write( ListenerForReRename.token_stream_rewriter.getDefaultText()) print("tamam shod")
def extract_subclass(self): # 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" source_class = "CDL" moved_methods = [ 'getValue', 'rowToJSONArray', 'getVal', ] moved_fields = [ 'number', 'number_2', 'number_1', ] # initialize with understand father_path_file = "" file_list_to_be_propagate = set() propagate_classes = set() db = und.open(udb_path) # db=open(udb_path) for cls in db.ents("class"): if (cls.simplename() == source_class): father_path_file = cls.parent().longname() for ref in cls.refs("Coupleby"): # print(ref.ent().longname()) propagate_classes.add(ref.ent().longname()) # print(ref.ent().parent().relname()) # file_list_to_be_propagate.add(ref.ent().parent().relname()) # if(cls.longname()==fatherclass): # print(cls.parent().relname()) # father_path_file=cls.parent().relname() father_path_file = "C:\\Users\\asus\\Desktop\\test_project\\CDL.java" father_path_directory = "C:\\Users\\asus\\Desktop\\test_project" stream = FileStream(father_path_file, encoding='utf8') 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())
def main(args, i): # Step 1: Load input source into stream stream = FileStream(args.file, encoding='utf8') # 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, 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(): Path = "../tests/rename_tests/" rename_method_test_file = FileStream(str(Path + "rename_method_test.java")) print("file opened") Refactored = open(os.path.join(Path, "rename_method_test_Refactored.java"), 'w', newline='') Lexer = JavaLexer(rename_method_test_file) TokenStream = CommonTokenStream(Lexer) Parser = JavaParserLabeled(TokenStream) Tree = Parser.compilationUnit() ListenerForReRename = RenameMethodRefactoringListener( TokenStream, "SuggestedRoomsByFollowingsListViewAdapter", "RoomModel", "RoomModel_changed") Walker = ParseTreeWalker() Walker.walk(ListenerForReRename, Tree) Refactored.write( ListenerForReRename.token_stream_rewriter.getDefaultText()) print("tamam shod")
def main(): udb_path = "/home/ali/Desktop/code/TestProject/TestProject.udb" source_class = "App" method_name = "testMethod" # 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() stream = FileStream(main_file, encoding='utf8') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = IncreaseMethodVisibilityRefactoringListener( common_token_stream=token_stream, source_class=source_class, method_name=method_name) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) with open(main_file, mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText())
def main(udb_path, source_class, field_name): udb_path = "/home/ali/Desktop/code/TestProject/TestProject.udb" source_class = "Website" field_name = "HELLO_FROM_STUDENT_WEBSITE" print("Make Field Static") main_file = "" db = und.open(udb_path) for cls in db.ents("class"): if cls.simplename() == source_class: main_file = cls.parent().longname(True) if not os.path.isfile(main_file): continue if main_file is None: return stream = FileStream(main_file, encoding='utf8') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = MakeFieldStaticRefactoringListener(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', 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 = 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(): print("Decrease Field Visibility") udb_path = "/home/ali/Documents/compiler/Research/xerces2-j/xerces2-j.udb" class_name = "AttributesImpl" field_name = "length" mainfile = "" db = und.open(udb_path) for cls in db.ents("class"): if (cls.simplename() == class_name): if cls.kindname() != "Unknown Class": mainfile = cls.parent().longname() stream = FileStream(mainfile, encoding='utf8') # 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 = JavaParser(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = DecreaseFieldVisibilityRefactoringListener( common_token_stream=token_stream, source_class=class_name, field_name=field_name) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) with open(mainfile, 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') # 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() print("=====Enter Create ParseTree=====") # Step 5: Create parse tree parse_tree = parser.compilationUnit() print("=====Create ParseTree Finished=====") # Step 6: Create an instance of AssignmentStListener my_listener = RemoveFieldRefactoringListener(common_token_stream=token_stream, class_identifier='User', fieldname='test_var', filename=args.file) # return walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) with open(args.file, mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText())
def main(udb_path, source_class, field_name, *args, **kwargs): main_file = None db = und.open(udb_path) for cls in db.ents("class"): if cls.simplename() == source_class: main_file = cls.parent().longname(True) if not os.path.isfile(main_file): continue if main_file is None: db.close() return stream = FileStream(main_file, encoding='utf8') 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', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) db.close()
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 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 = "/data/Dev/JavaSample/" path = get_filenames_in_dir(folder_path) print(path) # target_class = "CDL" target_class = "ReplaceConstructorWithFactoryMethod" for file in path: if file.endswith('.java') and not file.endswith('_refactored.java'): stream = FileStream(file) lexer = JavaLexer(stream) tokens = CommonTokenStream(lexer) parser = JavaParserLabeled(tokens) tree = parser.compilationUnit() new_file = open(file, 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 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="utf8") 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 do_refactor(self): db = und.open(self.udb_path) self.get_source_class_map(db=db) 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 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) # 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, 'w') as f: f.write(listener.token_stream_rewriter.getDefaultText()) with open(self.new_file_path, 'w') 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) db.close()
def extract_method(conf): stream = FileStream(conf['target_file'], encoding="utf-8") lexer = JavaLexer(stream) tokens = CommonTokenStream(lexer) parser = JavaParserLabeled(tokens) tree = parser.compilationUnit() # TODO : too many params for ExtractMethodRefactoring constructor listener = ExtractMethodRefactoring(conf['target_package'], conf['target_class'], conf['target_method'], conf['lines']) walker = ParseTreeWalker() walker.walk(listener=listener, t=tree) # print(parser.getTokenStream()) # print(listener.variable_info) output = [] file1 = open(conf['target_file'], 'r', encoding="utf-8") 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 == min(listener.lines): output.append('\t\t' + conf['new_method_name'] + get_args(listener.used_variables)) if listener.remain_lines.__contains__(line_num): output.append(line) func.append(line) elif line_num == listener.method_stop_line: output.append(line) output.append( '\tpublic void ' + conf['new_method_name'] + get_args_with_type(listener.used_variables, listener.variable_info['variables']) + '\n') output.append('\t{\n') output = output + func output.append('\t}\n') else: output.append(line) line_num += 1 file1.close() print('--------------------') file2 = open(conf['output_file'], 'w', encoding="utf-8") for item in output: file2.write(item) file2.close()
def main(): udb_path = "/home/ali/Desktop/code/TestProject/TestProject.udb" source_class = "GodClass" moved_methods = [ 'method1', 'method3', ] moved_fields = [ 'field1', 'field2', ] # initialize with understand father_path_file = "" file_list_to_be_propagate = set() propagate_classes = set() db = und.open(udb_path) for cls in db.ents("class"): if (cls.simplename() == source_class): father_path_file = cls.parent().longname() for ref in cls.refs("Coupleby"): # print(ref.ent().longname()) propagate_classes.add(ref.ent().longname()) # print(ref.ent().parent().relname()) # file_list_to_be_propagate.add(ref.ent().parent().relname()) # if(cls.longname()==fatherclass): # print(cls.parent().relname()) # father_path_file=cls.parent().relname() stream = FileStream(father_path_file, encoding='utf8') 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) 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())
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(udb_path, source_class, method_name, *args, **kwargs): """ """ 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 = MakeMethodStaticRefactoringListener( common_token_stream=token_stream, source_class=source_class, method_name=method_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 get_parse_tree_token_stream(args): """ returns parse tree and token stream base on the file stream :param args: file arguments """ # Step 1: Load input source into stream stream = FileStream(args.file, encoding='utf8') # 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() return parse_tree, token_stream
def find_usages(self, new_code): stream = InputStream(new_code) lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) tree = parser.compilationUnit() find_listener = FindClassUsagesListener( source_class=self.source_class, new_class=self.new_class, ) self.walker.walk(listener=find_listener, t=tree) change_listener = ChangeClassUsagesListener( common_token_stream=token_stream, source_class=self.source_class, new_class=self.new_class, moved_fields=self.moved_fields, moved_methods=self.moved_methods, usages=find_listener.usages) self.walker.walk(listener=change_listener, t=tree)
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 get_objects(source_files: str) -> FileInfo: objects = {} for filename in source_files: stream = FileStream(filename, encoding='utf8') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParser(token_stream) tree = parser.compilationUnit() listener = UtilsListener(filename) walker = ParseTreeWalker() walker.walk(listener, tree) if not listener.package.name in objects: objects[listener.package.name] = listener.objects_declaration else: for class_name in listener.objects_declaration: objects[listener.package.name][ class_name] = listener.objects_declaration[class_name] return objects
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 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(udb_path, target_class, target_methods): main_file = "" db = understand.open(udb_path) for cls in db.ents("class"): if cls.simplename() == target_class: main_file = cls.parent().longname() stream = FileStream(main_file, encoding='utf8') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = MakeMethodNonStaticRefactoringListener( common_token_stream=token_stream, target_class=target_class, target_methods=target_methods) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) with open(main_file, mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText())