def __init__(self, source_filenames: list):
self.source_filenames = source_filenames
self.program = get_program(self.source_filenames)
def do_refactor(self):
program = utils2.get_program(self.source_filenames, print_status=True)
superclass: utils_listener_fast.Class = program.packages[
self.package_name].classes[self.superclass_name]
if not self.pre_condition_check(program, superclass):
print("Can't refactor")
return False
# all_derived_classes = [] # Not needed
other_derived_classes = []
classes_to_add_to = []
for pn in program.packages:
p: utils_listener_fast.Package = program.packages[pn]
for cn in p.classes:
c: utils_listener_fast.Class = p.classes[cn]
if ((c.superclass_name == self.superclass_name and c.file_info.has_imported_class(self.package_name,
self.superclass_name)) \
or (self.package_name is not None and c.superclass_name == self.package_name + '.' + self.superclass_name)):
# all_derived_classes.append(c)
if len(self.class_names) == 0 or cn in self.class_names:
if self.field_name in c.fields:
print("some classes have same variable")
return False
else:
classes_to_add_to.append(c)
else:
other_derived_classes.append(c)
# Check if the field is used from the superclass or other derived classes
for pn in program.packages:
p: utils_listener_fast.Package = program.packages[pn]
for cn in p.classes:
c: utils_listener_fast.Class = p.classes[cn]
has_imported_superclass = c.file_info.has_imported_class(
self.package_name, self.superclass_name)
fields_of_superclass_type_or_others = []
for fn in c.fields:
f: utils_listener_fast.Field = c.fields[fn]
if (f.name == self.field_name and has_imported_superclass) \
or (self.package_name is not None and f.name == (
self.package_name + '.' + self.superclass_name)):
fields_of_superclass_type_or_others.append(f.name)
if any((c.file_info.has_imported_class(
o.package_name, o.name) and f.datatype == o.name)
or f.datatype == (o.package_name + '.' + o.name)
for o in other_derived_classes):
fields_of_superclass_type_or_others.append(f.name)
for mk in c.methods:
m: utils_listener_fast.Method = c.methods[mk]
local_vars_of_superclass_type_or_others = []
for item in m.body_local_vars_and_expr_names:
if isinstance(item, utils_listener_fast.LocalVariable):
if (item.datatype == self.superclass_name and has_imported_superclass) \
or item.datatype == (self.package_name + '.' + self.superclass_name):
local_vars_of_superclass_type_or_others.append(
item.identifier)
if any((c.file_info.has_imported_class(
o.package_name, o.name) and item.datatype
== o.name) or item.datatype == (
o.package_name + '.' + o.name)
for o in other_derived_classes):
local_vars_of_superclass_type_or_others.append(
item.identifier)
elif isinstance(item,
utils_listener_fast.ExpressionName):
if item.dot_separated_identifiers[-1] == self.field_name \
and (
(len(item.dot_separated_identifiers) == 2)
or (len(item.dot_separated_identifiers) == 3 and item.dot_separated_identifiers[
0] == "this")
) and (
(item.dot_separated_identifiers[
-2] in local_vars_of_superclass_type_or_others and len(
item.dot_separated_identifiers) == 2)
or item.dot_separated_identifiers[-2] in fields_of_superclass_type_or_others
):
return False
rewriter = utils2.Rewriter(program, self.filename_mapping)
field = superclass.fields[self.field_name]
if len(field.neighbor_names) == 0:
rewriter.replace(field.get_tokens_info(), "")
# Have to remove the modifiers too, because of the new grammar.
for mod_ctx in field.modifiers_parser_contexts:
rewriter.replace(utils_listener_fast.TokensInfo(mod_ctx), "")
else:
i = field.index_in_variable_declarators
var_ctxs = field.all_variable_declarator_contexts
if i == 0:
to_remove = utils_listener_fast.TokensInfo(var_ctxs[i])
to_remove.stop = utils_listener_fast.TokensInfo(
var_ctxs[i + 1]).start - 1 # Include the ',' after it
rewriter.replace(to_remove, "")
else:
to_remove = utils_listener_fast.TokensInfo(var_ctxs[i])
to_remove.start = utils_listener_fast.TokensInfo(
var_ctxs[i - 1]).stop + 1 # Include the ',' before it
rewriter.replace(to_remove, "")
is_public = "public" in field.modifiers
is_protected = "protected" in field.modifiers
modifier = ("public " if is_public else
("protected " if is_protected else ""))
for c in classes_to_add_to:
c_body_start = utils_listener_fast.TokensInfo(
c.parser_context.classBody())
c_body_start.stop = c_body_start.start # Start and stop both point to the '{'
rewriter.insert_after(c_body_start, "\n " + modifier + field.datatype + " " + self.field_name \
+ ((" = " + field.initializer) if field.initializer is not None else "")
+ ";")
rewriter.apply()
return True
def do_refactor(self):
program = utils2.get_program(self.source_filenames, print_status=True)
# print(program.packages)
if self.package_name not in program.packages \
or self.class_name not in program.packages[self.package_name].classes \
or self.field_name not in program.packages[self.package_name].classes[self.class_name].fields:
return False
_class: utils_listener_fast.Class = program.packages[
self.package_name].classes[self.class_name]
if _class.superclass_name is None:
return False
superclass_name = _class.superclass_name
superclass: utils_listener_fast.Class = program.packages[
self.package_name].classes[superclass_name]
superclass_body_start = utils_listener_fast.TokensInfo(
superclass.parser_context.classBody())
superclass_body_start.stop = superclass_body_start.start # Start and stop both point to the '{'
if self.field_name in superclass.fields:
return False
datatype = _class.fields[self.field_name].datatype
fields_to_remove = []
for pn in program.packages:
p: utils_listener_fast.Package = program.packages[pn]
for cn in p.classes:
c: utils_listener_fast.Class = p.classes[cn]
if ((c.superclass_name == superclass_name and c.file_info.has_imported_class(self.package_name,
superclass_name))
or (
self.package_name is not None and c.superclass_name == self.package_name + '.' + superclass_name)) \
and self.field_name in c.fields \
and c.fields[self.field_name].datatype == datatype:
fields_to_remove.append(c.fields[self.field_name])
if len(fields_to_remove) == 0:
return False
is_public = False
is_protected = True
for field in fields_to_remove:
field: utils_listener_fast.Field = field
is_public = is_public or "public" in field.modifiers
is_protected = is_protected and ("protected" in field.modifiers
or "private" in field.modifiers)
rewriter = utils2.Rewriter(program, self.filename_mapping)
rewriter.insert_after(
superclass_body_start,
"\n " + ("public " if is_public else
("protected " if is_protected else "")) + datatype +
" " + self.field_name + ";")
for field in fields_to_remove:
if len(field.neighbor_names) == 0:
rewriter.replace(field.get_tokens_info(), "")
# Have to remove the modifiers too, because of the new grammar.
for mod_ctx in field.modifiers_parser_contexts:
rewriter.replace(utils_listener_fast.TokensInfo(mod_ctx),
"")
else:
i = field.index_in_variable_declarators
var_ctxs = field.all_variable_declarator_contexts
if i == 0:
to_remove = utils_listener_fast.TokensInfo(var_ctxs[i])
to_remove.stop = utils_listener_fast.TokensInfo(
var_ctxs[i + 1]).start - 1 # Include the ',' after it
rewriter.replace(to_remove, "")
else:
to_remove = utils_listener_fast.TokensInfo(var_ctxs[i])
to_remove.start = utils_listener_fast.TokensInfo(
var_ctxs[i - 1]).stop + 1 # Include the ',' before it
rewriter.replace(to_remove, "")
# Add initializer to class constructor if initializer exists in field declaration
if field.initializer is not None:
_class: utils_listener_fast.Class = program.packages[
field.package_name].classes[field.class_name]
initializer_statement = (
field.name + " = " +
("new " + field.datatype +
" " if field.initializer.startswith('{') else "") +
field.initializer + ";")
has_contructor = False
for class_body_decl in _class.parser_context.classBody(
).getChildren():
if class_body_decl.getText() in ['{', '}']:
continue
member_decl = class_body_decl.memberDeclaration()
if member_decl is not None:
constructor = member_decl.constructorDeclaration()
if constructor is not None:
body = constructor.constructorBody # Start token = '{'
body_start = utils_listener_fast.TokensInfo(body)
body_start.stop = body_start.start # Start and stop both point to the '{'
rewriter.insert_after(
body_start,
"\n " + initializer_statement)
has_contructor = True
if not has_contructor:
body = _class.parser_context.classBody()
body_start = utils_listener_fast.TokensInfo(body)
body_start.stop = body_start.start # Start and stop both point to the '{'
rewriter.insert_after(
body_start, "\n " + _class.modifiers[0] + " " +
_class.name + "() { " + initializer_statement + " }")
rewriter.apply()
# check for multilevel inheritance recursively.
if _class.superclass_name is not None:
PullUpFieldRefactoring(self.source_filenames, self.package_name,
_class.superclass_name, "id").do_refactor()
return True
def do_refactor(self):
program = get_program(self.source_filenames)
static = 0
if self.class_name not in program.packages[self.package_name].classes or self.target_class_name not in \
program.packages[
self.target_package_name].classes or self.method_key not in \
program.packages[self.package_name].classes[
self.class_name].methods:
return False
_sourceclass = program.packages[self.package_name].classes[
self.class_name]
_targetclass = program.packages[self.target_package_name].classes[
self.target_class_name]
_method = program.packages[self.package_name].classes[
self.class_name].methods[self.method_key]
if _method.is_constructor:
return False
Rewriter_ = Rewriter(program, lambda x: x)
tokens_info = TokensInfo(
_method.parser_context) # tokens of ctx method
param_tokens_info = TokensInfo(_method.formalparam_context)
method_declaration_info = TokensInfo(
_method.method_declaration_context)
exp = [
] # برای نگه داری متغیرهایی که داخل کلاس تعریف شدند و در بدنه متد استفاده شدند
exps = tokens_info.get_token_index(tokens_info.token_stream.tokens,
tokens_info.start, tokens_info.stop)
# check that method is static or not
for modifier in _method.modifiers:
if modifier == "static":
static = 1
for token in exps:
if token.text in _sourceclass.fields:
exp.append(token.tokenIndex)
# check that where this method is call
for package_names in program.packages:
package = program.packages[package_names]
for class_ in package.classes:
_class = package.classes[class_]
for method_ in _class.methods:
__method = _class.methods[method_]
for inv in __method.body_method_invocations:
invc = __method.body_method_invocations[inv]
method_name = self.method_key[:self.method_key.find('('
)]
if invc[0] == method_name:
inv_tokens_info = TokensInfo(inv)
if static == 0:
class_token_info = TokensInfo(
_class.body_context)
Rewriter_.insert_after_start(
class_token_info,
self.target_class_name + " " +
str.lower(self.target_class_name) + "=" +
"new " + self.target_class_name + "();")
Rewriter_.apply()
Rewriter_.insert_before_start(
class_token_info,
"import " + self.target_package_name + "." +
self.target_class_name + ";")
Rewriter_.replace(inv_tokens_info,
self.target_class_name)
Rewriter_.apply()
class_tokens_info = TokensInfo(_targetclass.parser_context)
package_tokens_info = TokensInfo(
program.packages[self.target_package_name].package_ctx)
singlefileelement = SingleFileElement(_method.parser_context,
_method.filename)
token_stream_rewriter = TokenStreamRewriter(
singlefileelement.get_token_stream())
# insert name of source.java class befor param that define in body of classe (that use in method)
for index in exp:
token_stream_rewriter.insertBeforeIndex(
index=index, text=str.lower(self.class_name) + ".")
for inv in _method.body_method_invocations:
if inv.getText() == self.target_class_name:
inv_tokens_info_target = TokensInfo(inv)
token_stream_rewriter.replaceRange(
from_idx=inv_tokens_info_target.start,
to_idx=inv_tokens_info_target.stop + 1,
text=" ")
# insert source.java class befor methods of sourcr class that used in method
for i in _method.body_method_invocations_without_typename:
if i.getText() == self.class_name:
ii = _method.body_method_invocations_without_typename[i]
i_tokens = TokensInfo(ii[0])
token_stream_rewriter.insertBeforeIndex(
index=i_tokens.start,
text=str.lower(self.class_name) + ".")
# pass object of source.java class to method
if param_tokens_info.start is not None:
token_stream_rewriter.insertBeforeIndex(
param_tokens_info.start,
text=self.class_name + " " + str.lower(self.class_name) + ",")
else:
token_stream_rewriter.insertBeforeIndex(
method_declaration_info.stop,
text=self.class_name + " " + str.lower(self.class_name))
strofmethod = token_stream_rewriter.getText(
program_name=token_stream_rewriter.DEFAULT_PROGRAM_NAME,
start=tokens_info.start,
stop=tokens_info.stop)
Rewriter_.insert_before(tokens_info=class_tokens_info,
text=strofmethod)
Rewriter_.insert_after(
package_tokens_info, "import " + self.target_package_name + "." +
self.target_class_name + ";")
Rewriter_.replace(tokens_info, "")
Rewriter_.apply()
return True
def do_refactor(self):
program = get_program(
self.source_filenames) # getting the program packages
_sourceclass = program.packages[self.package_name].classes[
self.class_name]
target_class_name = _sourceclass.superclass_name
removemethod, removemethod1 = get_cons(
program, self.package_name, target_class_name,
self.class_name) # Similar cons in other classes
_targetclass = program.packages[
self.package_name].classes[target_class_name]
mets = program.packages[self.package_name].classes[
self.class_name].methods
_method_name = []
for methodName, method in mets.items():
if method.is_constructor:
_method_name = method
break
tokens_info = TokensInfo(_method_name.parser_context)
if not _method_name.is_constructor:
return False
param_dict = {}
len_params = {}
Rewriter_ = Rewriter(program, self.filename_mapping)
for remove in removemethod:
flag2 = False
_methodd = removemethod[remove]
len_params[remove] = len(_methodd[0].split(","))
not_present = removemethod1
if _methodd is not None:
_methodds = _methodd[0]
_method = program.packages[
self.package_name].classes[remove].methods[str(_methodds)]
params = ""
params2 = ""
for param in _method.parameters:
flag = False
for x in not_present:
for y in x:
if param[1] in y:
flag = True
flag2 = True
if not flag:
params += param[1] + ","
params2 += param[0] + " " + param[1] + ","
flag = False
param_dict[remove] = params2[:-1]
_method_token_info = TokensInfo(_method.parser_context)
if flag2:
str1 = ""
for x in not_present:
for y in x:
str1 += y + ";" + "\n\t"
Rewriter_.replace(
_method_token_info, "public " + remove + "(" +
params2[:-1] + ")" + "{\n\t" + "super(" + params[:-1] +
");" + "\n\t " + str1 + "}")
else:
Rewriter_.replace(
_method_token_info,
"public " + remove + "(" + params2[:-1] + ")" +
"{\n\t" + "super(" + params[:-1] + ");" + "\n\t}")
class_tokens_info = TokensInfo(_targetclass.parser_context.classBody())
class_tokens_info.stop = class_tokens_info.start
key = min(len_params, key=len_params.get)
_method_name1 = program.packages[
self.package_name].classes[key].methods[removemethod[key][0]]
tokens_info = TokensInfo(_method_name1.parser_context)
singlefileelement = SingleFileElement(_method_name1.parser_context,
_method_name1.filename)
token_stream_rewriter = TokenStreamRewriter(
singlefileelement.get_token_stream())
strofmethod = token_stream_rewriter.getText(
program_name=token_stream_rewriter.DEFAULT_PROGRAM_NAME,
start=tokens_info.start,
stop=tokens_info.stop)
strofmethod = strofmethod.replace(_method_name1.class_name,
target_class_name)
Rewriter_.insert_after(tokens_info=class_tokens_info, text=strofmethod)
Rewriter_.apply()
return True
def do_refactor(self):
program = get_program(
self.source_filenames) # getting the program packages
_sourceclass = program.packages[self.package_name].classes[
self.class_name]
target_class_name = _sourceclass.superclass_name
static = 0
removemethod = get_removemethods(
program, self.package_name, target_class_name, self.method_key,
self.class_name) # Similar methods in other classes
_targetclass = program.packages[
self.package_name].classes[target_class_name]
_method_name = program.packages[self.package_name].classes[
self.class_name].methods[self.method_key]
tokens_info = TokensInfo(_method_name.parser_context)
exps = tokens_info.get_token_index(
tokens_info.token_stream.tokens, tokens_info.start, tokens_info.
stop) # list of class variables that are used in the method
if _method_name.is_constructor:
return False
# if method use param of class body return false
for token in exps:
if token.text in _sourceclass.fields:
return False
if bool(_method_name.body_method_invocations_without_typename):
return False
Rewriter_ = Rewriter(program, self.filename_mapping)
for remove in removemethod:
_methodd = removemethod[remove]
if _methodd is not None:
_methodds = _methodd[0]
_method = program.packages[
self.package_name].classes[remove].methods[str(_methodds)]
_method_token_info = TokensInfo(_method.parser_context)
Rewriter_.replace(_method_token_info, " ")
class_tokens_info = TokensInfo(_targetclass.parser_context)
singlefileelement = SingleFileElement(_method_name.parser_context,
_method_name.filename)
token_stream_rewriter = TokenStreamRewriter(
singlefileelement.get_token_stream())
strofmethod = token_stream_rewriter.getText(
program_name=token_stream_rewriter.DEFAULT_PROGRAM_NAME,
start=tokens_info.start,
stop=tokens_info.stop)
Rewriter_.insert_before(tokens_info=class_tokens_info,
text=strofmethod)
Rewriter_.apply()
# The Method has to be updated anywhere else that it's used
for package_names in program.packages:
package = program.packages[package_names]
for class_ in package.classes:
_class = package.classes[class_]
for method_ in _class.methods:
__method = _class.methods[method_]
for inv in __method.body_method_invocations:
invc = __method.body_method_invocations[inv]
method_name = self.method_key[:self.method_key.find('('
)]
if invc[0] == method_name & package_names == self.package_name:
inv_tokens_info = TokensInfo(inv)
if static == 0:
class_token_info = TokensInfo(
_class.body_context)
Rewriter_.insert_after_start(
class_token_info, target_class_name + " " +
str.lower(target_class_name) + "=" +
"new " + target_class_name + "();")
Rewriter_.apply()
Rewriter_.replace(inv_tokens_info,
target_class_name)
Rewriter_.apply()
return True
def do_refactor(self):
program = utils2.get_program(self.source_filenames, print_status=True)
if self.package_name not in program.packages \
or any(
class_name not in program.packages[self.package_name].classes
for class_name in self.class_names
) \
or any(
method_key not in program.packages[self.package_name].classes[class_name].methods
for class_name in self.class_names for method_key in self.method_keys
):
return False
method_returntypes = {}
method_parameters = {}
method_names = []
for method_key in self.method_keys:
method_names.append(method_key[:method_key.find('(')])
rewriter = utils2.Rewriter(program, self.filename_mapping)
for class_name in self.class_names:
c: utils_listener_fast.Class = program.packages[
self.package_name].classes[class_name]
# Add implements to the class
has_superinterface = False
if c.parser_context.IMPLEMENTS(
) is not None: # old: c.parser_context.superinterfaces()
t = utils_listener_fast.TokensInfo(c.parser_context.typeList(
)) # old: c.parser_context.superinterfaces()
has_superinterface = True
elif c.parser_context.EXTENDS(
) is not None: # old: c.parser_context.superclass()
t = utils_listener_fast.TokensInfo(c.parser_context.typeType(
)) # old: c.parser_context.superclass()
elif c.parser_context.typeParameters() is not None:
t = utils_listener_fast.TokensInfo(
c.parser_context.typeParameters())
else:
# old: TokensInfo(c.parser_context.identifier())
t = utils_listener_fast.TokensInfo(c.parser_context)
t.stop = c.parser_context.IDENTIFIER().getSymbol().tokenIndex
rewriter.insert_after(
t, (", " if has_superinterface else " implements ") +
self.interface_name)
for method_key in self.method_keys:
m: utils_listener_fast.Method = c.methods[method_key]
# Check if the return types / parameter types are the same
# Or add to dictionary
if method_key in method_returntypes:
if method_returntypes[method_key] != m.returntype:
return False
if len(method_parameters[method_key]) != len(m.parameters):
return False
for i in range(len(m.parameters)):
if method_parameters[method_key][i][0] != m.parameters[
i][0]:
return False
else:
method_returntypes[method_key] = m.returntype
method_parameters[method_key] = m.parameters
# Manage method modifiers
if len(m.modifiers_parser_contexts) > 0:
t = utils_listener_fast.TokensInfo(
m.modifiers_parser_contexts[0])
else:
t = m.get_tokens_info()
rewriter.insert_before_start(
t, # old: m.get_tokens_info() # without requiring t
("" if "@Override" in m.modifiers else "@Override\n ") +
("" if "public" in m.modifiers else "public "))
for i in range(len(m.modifiers)):
mm = m.modifiers[i]
if mm == "private" or mm == "protected":
t = utils_listener_fast.TokensInfo(
m.modifiers_parser_contexts[i]
) # old: m.parser_context.methodModifier(i)
rewriter.replace(t, "")
# Change variable types to the interface if only interface methods are used.
for package_name in program.packages:
p: utils_listener_fast.Package = program.packages[package_name]
for class_name in p.classes:
c: utils_listener_fast.Class = p.classes[class_name]
fields_of_interest = {}
for fn in c.fields:
f: utils_listener_fast.Field = c.fields[fn]
d = False
for cn in self.class_names:
if (f.datatype == cn and f.file_info.has_imported_class(package_name, cn)) \
or (package_name is not None and f.datatype == package_name + '.' + cn):
d = True
break
if d and "private" in f.modifiers:
fields_of_interest[f.name] = f
for method_key in c.methods:
m: utils_listener_fast.Method = c.methods[method_key]
vars_of_interest = {}
for item in m.body_local_vars_and_expr_names:
if isinstance(item, utils_listener_fast.LocalVariable):
for cn in self.class_names:
if (item.datatype == cn and c.file_info.has_imported_class(package_name, cn)) \
or (package_name is not None and item.datatype == package_name + '.' + cn):
vars_of_interest[item.identifier] = item
break
if isinstance(item,
utils_listener_fast.MethodInvocation):
if len(item.dot_separated_identifiers) == 2 or \
(len(item.dot_separated_identifiers) == 3 and item.dot_separated_identifiers[
0] == "this"):
if item.dot_separated_identifiers[
-2] in vars_of_interest:
if item.dot_separated_identifiers[
-1] not in method_names:
vars_of_interest.pop(
item.dot_separated_identifiers[-2])
elif item.dot_separated_identifiers[-2] in fields_of_interest \
and item.dot_separated_identifiers[-1] not in method_names:
fields_of_interest.pop(
item.dot_separated_identifiers[-2])
for var_name in vars_of_interest:
var = vars_of_interest[var_name]
if m.file_info.has_imported_package(package_name):
# old: var.parser_context.unannType()
rewriter.replace(
utils_listener_fast.TokensInfo(
var.parser_context.typeType()),
self.interface_name)
else:
if package_name is None:
break
# old: var.parser_context.unannType()
rewriter.replace(
utils_listener_fast.TokensInfo(
var.parser_context.typeType()),
package_name + '.' + self.interface_name)
for field_name in fields_of_interest:
f = fields_of_interest[field_name]
if c.file_info.has_imported_package(package_name):
typename = self.interface_name
else:
if package_name is None:
break
typename = package_name + '.' + self.interface_name
if len(f.neighbor_names) == 0:
rewriter.replace(
utils_listener_fast.TokensInfo(
f.parser_context.typeType()),
typename) # old: f.parser_context.unannType()
else:
if not any(nn in fields_of_interest
for nn in f.neighbor_names):
t = utils_listener_fast.TokensInfo(
f.all_variable_declarator_contexts[
f.index_in_variable_declarators])
if f.index_in_variable_declarators == 0:
t.stop = utils_listener_fast.TokensInfo(
f.all_variable_declarator_contexts[
f.index_in_variable_declarators +
1]).start - 1
else:
t.start = utils_listener_fast.TokensInfo(
f.all_variable_declarator_contexts[
f.index_in_variable_declarators -
1]).start + 1
rewriter.replace(t, "")
rewriter.insert_after(
f.get_tokens_info(),
"\n private " + typename + " " + f.name +
(" = " + f.initializer +
";" if f.initializer is not None else ";"))
# Create the interface
interface_file_content = ("package " + package_name + ";\n\n" +
"public interface " + self.interface_name +
"\n" + "{\n")
for method_key in self.method_keys:
method_name = method_key[:method_key.find('(')]
interface_file_content += " " + method_returntypes[
method_key] + " " + method_name + "("
if len(method_parameters[method_key]) > 0:
interface_file_content += method_parameters[method_key][0][
0] + " " + method_parameters[method_key][0][1]
for i in range(1, len(method_parameters[method_key])):
param = method_parameters[method_key][i]
interface_file_content += ", " + param[0] + " " + param[1]
interface_file_content += ");\n"
interface_file_content += "}\n"
if not os.path.exists(
self.interface_filename[:self.interface_filename.rfind('/')]):
os.makedirs(
self.interface_filename[:self.interface_filename.rfind('/')])
file = open(self.interface_filename, "w+")
file.write(interface_file_content)
file.close()
rewriter.apply()
return True
def do_refactor(self):
program = get_program(
self.source_filenames,
print_status=True) # getting the program packages
superclass: utils_listener_fast.Class = program.packages[
self.package_name].classes[self.superclass_name]
if not self.pre_propagation_check(program, superclass):
return False
other_derived_classes = []
classes_to_add_to = []
for p in program.packages:
package: utils_listener_fast.Package = program.packages[p]
for cn in package.classes:
c: utils_listener_fast.Class = package.classes[cn]
if ((c.superclass_name == self.superclass_name
and c.file_info.has_imported_class(
self.package_name, self.superclass_name)) or
(self.package_name is not None and c.superclass_name
== self.package_name + '.' + self.superclass_name)):
# enable functionality of class name
if len(self.class_names) == 0 or cn in self.class_names:
# check for methods with same name (post-condition 1)
if self.method_key in c.methods:
print("some classes have same method")
return False
else:
for m in c.methods:
method: utils_listener_fast.Method = c.methods[
m]
is_used = False
for item in method.body_local_vars_and_expr_names:
if isinstance(item, utils_listener_fast.MethodInvocation) and \
item.dot_separated_identifiers[0] + '()' == self.method_key:
is_used = True
if is_used:
classes_to_add_to.append(c)
else:
other_derived_classes.append(c)
rewriter = utils2.Rewriter(program, self.filename_mapping)
method = superclass.methods[self.method_key]
is_public = "public" in method.modifiers
is_protected = "protected" in method.modifiers
is_private = "private" in method.modifiers
for c in classes_to_add_to:
c_body_start = utils_listener_fast.TokensInfo(
c.parser_context.classBody())
c_body_start.stop = c_body_start.start
rewriter.insert_after(
c_body_start, "\n\n %s %s %s() {\n %s\n }\n" %
(" ".join(method.modifiers), method.returntype, method.name,
method.body_text[1:-1]))
method_token_info = utils_listener_fast.TokensInfo(
method.parser_context)
rewriter.replace(method_token_info, "")
rewriter.apply()
return True
