Java Code Examples for spoon.reflect.declaration.CtMethod#getParameters()
The following examples show how to use
spoon.reflect.declaration.CtMethod#getParameters() .
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
| Source File: AbstractCodeAnalyzer.java From coming with MIT License | 6 votes |
|
/**
* Check if a method declaration has a parameter compatible and return with the
* cttype as argument
*
* @param allMethods
* @param typeToMatch
* @return
*/
public CtMethod checkMethodDeclarationWithParameterReturnCompatibleType(List allMethods,
CtTypeReference typeToMatch) {
for (Object omethod : allMethods) {
if (!(omethod instanceof CtMethod))
continue;
CtMethod anotherMethodInBuggyClass = (CtMethod) omethod;
// Check the parameters
for (Object oparameter : anotherMethodInBuggyClass.getParameters()) {
CtParameter parameter = (CtParameter) oparameter;
if (compareTypes(typeToMatch, parameter.getType())
&& compareTypes(typeToMatch, anotherMethodInBuggyClass.getType())) {
return anotherMethodInBuggyClass;
}
}
}
return null;
}
Example 2
| Source File: LogicalExpressionAnalyzer.java From coming with MIT License | 6 votes |
|
/**
* Check if a method declaration has a parameter compatible with that one from
* the var affected
*
* @param allMethods
* @param varAffected
* @return
*/
public CtMethod checkBooleanMethodDeclarationWithTypeInParameter(List allMethods, CtVariableAccess varAffected) {
for (Object omethod : allMethods) {
if (!(omethod instanceof CtMethod))
continue;
CtMethod anotherMethodInBuggyClass = (CtMethod) omethod;
for (Object oparameter : anotherMethodInBuggyClass.getParameters()) {
CtParameter parameter = (CtParameter) oparameter;
if (compareTypes(varAffected.getType(), parameter.getType())) {
if (anotherMethodInBuggyClass.getType().unbox().toString().equals("boolean")) {
return anotherMethodInBuggyClass;
}
}
}
}
return null;
}
Example 3
| Source File: SupportOperators.java From astor with GNU General Public License v2.0 | 6 votes |
|
public static List<CtExpression> checkOcurrenceOfOtherParameters(CtMethod anotherMethod, CtMethod affectedMethod,
List realParameters) {
List newRealParameters = new ArrayList();
for (Object parameterFromAnotherM : anotherMethod.getParameters()) {
CtParameter parAnother = (CtParameter) parameterFromAnotherM;
int indexOfParameter = affectedMethod.getParameters().indexOf(parAnother);
// The parameter does not exist in the previous version
if (indexOfParameter < 0) {
return null;
} else {
CtExpression parameterAtI = (CtExpression) realParameters.get(indexOfParameter);
newRealParameters.add(parameterAtI);
}
}
// all parameters exist
return newRealParameters;
}
Example 4
| Source File: OverloadMethodTransform.java From astor with GNU General Public License v2.0 | 6 votes |
|
@SuppressWarnings({ "rawtypes", "unchecked" })
private void fetchLibOverload(CtInvocation call) {
List<String> origTypes = resolveTypes(call.getArguments());
CtExpression exp = call.getTarget();
String typename=exp.getType().getQualifiedName();
if(typename==null||typename.isEmpty())
return;
CtClass classname = parser.getClassMap().get(typename);
if(classname!=null) {
Set<CtMethod> overloadmethods=classname.getMethods();
for(CtMethod methodoverloaded : overloadmethods) {
if(call.getExecutable().getSimpleName().equals(methodoverloaded.getSimpleName())) {
List<CtParameter> paramlist=methodoverloaded.getParameters();
List<String> target=resolveParams(paramlist);
transformOneMethod(origTypes,target, call);
}
}
} else {
List<Class[]> params = parser.fetchMethods(typename, call.getExecutable().getSimpleName());
for (Class[] p : params)
transformOneConstructor(origTypes, call, p);
}
}
Example 5
| Source File: MethodAnalyzer.java From coming with MIT License | 5 votes |
|
private boolean checkTypeInParameter(CtMethod anotherMethod, CtExecutableReference minvokedInAffected) {
for (Object oparameter : anotherMethod.getParameters()) {
CtParameter parameter = (CtParameter) oparameter;
if (compareTypes(minvokedInAffected.getType(), parameter.getType())) {
return true;
}
}
return false;
}
Example 6
| Source File: SupportOperators.java From astor with GNU General Public License v2.0 | 5 votes |
|
public static List<List<CtExpression<?>>> computeParameters(CtMethod anotherMethod, ModificationPoint point) {
List<CtVariable> variablesInScope = point.getContextOfModificationPoint();
List<CtParameter> parameterTypes = anotherMethod.getParameters();
MapList<CtTypeReference, CtElement> candidateMappings = new MapList<>();
// Groups vars according to types
for (CtParameter ctTypeParameter : parameterTypes) {
CtTypeReference parType = ctTypeParameter.getType();
if (!candidateMappings.containsKey(parType)) {
List compatible = variablesInScope.stream().filter(e -> e.getType().isSubtypeOf(parType))
.collect(Collectors.toList());
// A par without a var
if (compatible.isEmpty())
return null;
candidateMappings.put(parType, compatible);
}
}
List<List<CtExpression<?>>> candidateArguments = createAllParametersCombinations(parameterTypes,
candidateMappings);
return candidateArguments;
}
Example 7
| Source File: SupportOperators.java From astor with GNU General Public License v2.0 | 5 votes |
|
public static boolean checkOcurrenceOfOtherParameters(CtMethod anotherMethod, CtMethod affectedMethod) {
// anotherMethod.getParameters().stream().map(CtParameter.class::cast)
// .collect(Collectors.toList()
for (Object parameterFromAnotherM : anotherMethod.getParameters()) {
CtParameter parAnother = (CtParameter) parameterFromAnotherM;
// The parameter does not exist in the previous version
if (!affectedMethod.getParameters().contains(parAnother)) {
return false;
}
}
// all parameters exist
return true;
}
Example 8
| Source File: StaSynthBuilder.java From astor with GNU General Public License v2.0 | 5 votes |
|
@SuppressWarnings({ "rawtypes", "unused" })
private List<List<CtExpression>> createAllPossibleArgsListForMethod(CtMethod method, List<CtExpression> variables) {
try {
List<CtParameter> argumentTypes = method.getParameters();
List<List<CtExpression>> argumentCandidates = new ArrayList<>();
for (int j = 0; j < argumentTypes.size(); j++) {
CtParameter par = argumentTypes.get(j);
List<CtExpression> compatiblePar = new ArrayList<>();
for (CtExpression ctVariableRead : variables) {
if (ctVariableRead.getType().isSubtypeOf(par.getType())) {
compatiblePar.add(ctVariableRead);
}
}
argumentCandidates.add(compatiblePar);
}
return argumentCandidates;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
Example 9
| Source File: AbstractCodeAnalyzer.java From coming with MIT License | 4 votes |
|
public CtMethod checkMethodDeclarationWithParemetrCompatibleType(List allMethods, CtTypeReference typeToMatch) {
for (Object omethod : allMethods) {
if (!(omethod instanceof CtMethod))
continue;
CtMethod anotherMethodInBuggyClass = (CtMethod) omethod;
for (Object oparameter : anotherMethodInBuggyClass.getParameters()) {
CtParameter parameter = (CtParameter) oparameter;
if (compareTypes(typeToMatch, parameter.getType())) {
return anotherMethodInBuggyClass;
}
}
}
return null;
}
Example 10
| Source File: VariableResolver.java From coming with MIT License | 4 votes |
|
/**
* Returns all variables in scope, reachable from the ctelement passes as
* argument
*
* @param element
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public static List<CtVariable> searchVariablesInScope(CtElement element) {
List<CtVariable> variables = new ArrayList();
if (element == null) {
return variables;
}
if (element instanceof CtField) {
return variables;
}
// We find the CtClass and returns the fields
CtClass ctclass = element.getParent(CtClass.class);
if (ctclass != null) {
Collection<CtFieldReference<?>> vars = ctclass.getAllFields();
for (CtFieldReference<?> ctFieldReference : vars) {
// We dont add private fields from parent classes
if ((!ctFieldReference.getModifiers().contains(ModifierKind.PRIVATE)
|| ctclass.getFields().contains(ctFieldReference.getDeclaration()))) {
// We ignore "serialVersionUID'
if ((ctFieldReference.getDeclaration() != null)
&& !"serialVersionUID".equals(ctFieldReference.getDeclaration().getSimpleName()))
variables.add(ctFieldReference.getDeclaration());
}
}
}
// We find the parent method and we extract the parameters
CtMethod method = element.getParent(CtMethod.class);
if (method != null) {
List<CtParameter> pars = method.getParameters();
for (CtParameter ctParameter : pars) {
variables.add(ctParameter);
}
}
// We find the parent block and we extract the local variables before
// the element under analysis
CtBlock parentblock = element.getParent(CtBlock.class);
if (parentblock != null) {
int positionEl = parentblock.getStatements().indexOf(element);
variables.addAll(VariableResolver.retrieveLocalVariables(positionEl, parentblock));
}
return variables;
}
Example 11
| Source File: OriginalFeatureExtractor.java From coming with MIT License | 4 votes |
|
private EnumSet<ValueFeature> getValueFeature(final String valueStr, final Repair repair, Map<String, CtElement> valueExprInfo) {
EnumSet<ValueFeature> valueFeatures = EnumSet.noneOf(ValueFeature.class);
if (repair.oldRExpr != null && repair.newRExpr != null) {
String oldStr = repair.oldRExpr.toString();
String newStr = repair.newRExpr.toString();
if (valueStr.equals(newStr))
valueFeatures.add(ValueFeature.MODIFIED_VF);
// I can not figure out the meaning of MODIFIED_SIMILAR_VF
if (oldStr.length() > 0 && newStr.length() > 0) {
double ratio = ((double)oldStr.length()) / newStr.length();
if (ratio > 0.5 && ratio < 2 && oldStr.length() > 3 && newStr.length() > 3)
if (oldStr.contains(newStr) || newStr.contains(oldStr))
valueFeatures.add(ValueFeature.MODIFIED_SIMILAR_VF);
}
}
CtElement element = repair.dstElem;
if (element != null) {
CtMethod FD = element.getParent(new TypeFilter<>(CtMethod.class));
if (FD != null) {
for (Object parameter: FD.getParameters()) {
if (parameter instanceof CtParameter) {
CtParameter VD = (CtParameter) parameter;
if (VD.getSimpleName().equals(valueStr))
valueFeatures.add(ValueFeature.FUNC_ARGUMENT_VF);
}
}
}
}
assert(valueExprInfo.containsKey(valueStr));
CtElement E = valueExprInfo.get(valueStr);
if (E instanceof CtVariableAccess || E instanceof CtArrayAccess || E instanceof CtLocalVariable) {
if (E instanceof CtLocalVariable) {
valueFeatures.add(ValueFeature.LOCAL_VARIABLE_VF);
} else {
valueFeatures.add(ValueFeature.GLOBAL_VARIABLE_VF);
}
} else if (E instanceof CtExecutableReference){
// just make CALLEE_AF be meaningful
if (((CtExecutableReference) E).getParameters().size() > 0){
valueFeatures.add(ValueFeature.LOCAL_VARIABLE_VF);
}
} else if (E instanceof CtIf){
// just make R_STMT_COND_AF be meaningful
valueFeatures.add(ValueFeature.LOCAL_VARIABLE_VF);
}
// if (E instanceof CtVariable) {
// if (E instanceof CtLocalVariable)
// valueFeatures.add(SchemaFeature.LOCAL_VARIABLE_VF);
// else
// valueFeatures.add(SchemaFeature.GLOBAL_VARIABLE_VF);
// } else if (E instanceof CtVariableReference) {
// if (E instanceof CtLocalVariableReference)
// valueFeatures.add(SchemaFeature.LOCAL_VARIABLE_VF);
// else
// valueFeatures.add(SchemaFeature.GLOBAL_VARIABLE_VF);
// }
if (valueStr.contains("length") || valueStr.contains("size"))
valueFeatures.add(ValueFeature.SIZE_LITERAL_VF);
if (E.getElements(new TypeFilter<>(CtField.class)).size() > 0)
valueFeatures.add(ValueFeature.MEMBER_VF);
if (E instanceof CtLiteral) {
Object value = ((CtLiteral)E).getValue();
if (value instanceof String) {
valueFeatures.add(ValueFeature.STRING_LITERAL_VF);
} else if (value instanceof Integer) { // ?
if ((Integer) value == 0) {
valueFeatures.add(ValueFeature.ZERO_CONST_VF);
} else {
valueFeatures.add(ValueFeature.NONZERO_CONST_VF);
}
}
}
return valueFeatures;
}
Example 12
| Source File: S4ROFeatureExtractor.java From coming with MIT License | 4 votes |
|
private EnumSet<ValueFeature> getValueFeature(final String valueStr, final Repair repair, Map<String, CtElement> valueExprInfo) {
EnumSet<ValueFeature> valueFeatures = EnumSet.noneOf(ValueFeature.class);
if (repair.oldRExpr != null && repair.newRExpr != null) {
String oldStr = repair.oldRExpr.toString();
String newStr = repair.newRExpr.toString();
if (valueStr.equals(newStr))
valueFeatures.add(ValueFeature.MODIFIED_VF);
// I can not figure out the meaning of MODIFIED_SIMILAR_VF
if (oldStr.length() > 0 && newStr.length() > 0) {
double ratio = ((double)oldStr.length()) / newStr.length();
if (ratio > 0.5 && ratio < 2 && oldStr.length() > 3 && newStr.length() > 3)
if (oldStr.contains(newStr) || newStr.contains(oldStr))
valueFeatures.add(ValueFeature.MODIFIED_SIMILAR_VF);
}
}
CtElement element = repair.dstElem;
if (element != null) {
CtMethod FD = element.getParent(new TypeFilter<>(CtMethod.class));
if (FD != null) {
for (Object parameter: FD.getParameters()) {
if (parameter instanceof CtParameter) {
CtParameter VD = (CtParameter) parameter;
if (VD.getSimpleName().equals(valueStr))
valueFeatures.add(ValueFeature.FUNC_ARGUMENT_VF);
}
}
}
}
assert(valueExprInfo.containsKey(valueStr));
CtElement E = valueExprInfo.get(valueStr);
if (E instanceof CtVariableAccess || E instanceof CtArrayAccess || E instanceof CtLocalVariable) {
if (E instanceof CtLocalVariable) {
valueFeatures.add(ValueFeature.LOCAL_VARIABLE_VF);
} else {
valueFeatures.add(ValueFeature.GLOBAL_VARIABLE_VF);
}
} else if (E instanceof CtExecutableReference){
// just make CALLEE_AF be meaningful
if (((CtExecutableReference) E).getParameters().size() > 0){
valueFeatures.add(ValueFeature.LOCAL_VARIABLE_VF);
}
} else if (E instanceof CtIf){
// just make R_STMT_COND_AF be meaningful
valueFeatures.add(ValueFeature.LOCAL_VARIABLE_VF);
}
// if (E instanceof CtVariable) {
// if (E instanceof CtLocalVariable)
// valueFeatures.add(SchemaFeature.LOCAL_VARIABLE_VF);
// else
// valueFeatures.add(SchemaFeature.GLOBAL_VARIABLE_VF);
// } else if (E instanceof CtVariableReference) {
// if (E instanceof CtLocalVariableReference)
// valueFeatures.add(SchemaFeature.LOCAL_VARIABLE_VF);
// else
// valueFeatures.add(SchemaFeature.GLOBAL_VARIABLE_VF);
// }
if (valueStr.contains("length") || valueStr.contains("size"))
valueFeatures.add(ValueFeature.SIZE_LITERAL_VF);
if (E.getElements(new TypeFilter<>(CtField.class)).size() > 0)
valueFeatures.add(ValueFeature.MEMBER_VF);
if (E instanceof CtLiteral) {
Object value = ((CtLiteral)E).getValue();
if (value instanceof String) {
valueFeatures.add(ValueFeature.STRING_LITERAL_VF);
} else if (value instanceof Integer) { // ?
if ((Integer) value == 0) {
valueFeatures.add(ValueFeature.ZERO_CONST_VF);
} else {
valueFeatures.add(ValueFeature.NONZERO_CONST_VF);
}
}
}
return valueFeatures;
}
Example 13
| Source File: SupportOperators.java From astor with GNU General Public License v2.0 | 4 votes |
|
public static List<CtInvocation> createRealInvocationsReusingVars(ModificationPoint point, CtMethod anotherMethod,
CtInvocation invocationToReplace) {
List<CtParameter> parameterTypes = anotherMethod.getParameters();
CtExpression target = invocationToReplace.getTarget();
MapList<CtTypeReference, CtElement> candidateMappings = new MapList<>();
List<CtVariable> variablesInScope = point.getContextOfModificationPoint();
for (CtParameter aParameterAnotherMethod : parameterTypes) {
CtTypeReference aTypePar = aParameterAnotherMethod.getType();
List similarExpression = (List<CtExpression>) invocationToReplace.getArguments().stream()
// .filter(e -> e.equals(aTypePar)).collect(Collectors.toList());
.filter(e -> ((CtExpression) e).getType().equals(aTypePar)).collect(Collectors.toList());
// TODO: put a configuration point here.
if (similarExpression.size() > 0) {
if (!candidateMappings.containsKey(aTypePar)) {
candidateMappings.put(aTypePar, similarExpression);
}
} else {
if (!candidateMappings.containsKey(aTypePar)) {
List compatible = variablesInScope.stream().filter(e -> e.getType().isSubtypeOf(aTypePar))
.collect(Collectors.toList());
// A par without a var
if (compatible.isEmpty())
return null;
candidateMappings.put(aTypePar, compatible);
}
}
}
List<List<CtExpression<?>>> candidateArguments = createAllParametersCombinations(parameterTypes,
candidateMappings);
if (candidateArguments == null || candidateArguments.isEmpty())
return Collections.EMPTY_LIST;
List<CtInvocation> newInvocations = realInvocationsFromCombination(anotherMethod, target, candidateArguments);
return newInvocations;
}
Example 14
| Source File: VariableResolver.java From astor with GNU General Public License v2.0 | 4 votes |
|
/**
* Returns all variables in scope, reachable from the ctelement passes as
* argument
*
* @param element
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public static List<CtVariable> searchVariablesInScope(CtElement element) {
List<CtVariable> variables = new ArrayList();
if (element == null) {
return variables;
}
if (element instanceof CtField) {
return variables;
}
// We find the CtClass and returns the fields
CtClass ctclass = element.getParent(CtClass.class);
if (ctclass != null) {
Collection<CtFieldReference<?>> vars = ctclass.getAllFields();
for (CtFieldReference<?> ctFieldReference : vars) {
// We dont add private fields from parent classes
if ((!ctFieldReference.getModifiers().contains(ModifierKind.PRIVATE)
|| ctclass.getFields().contains(ctFieldReference.getDeclaration()))) {
// We ignore "serialVersionUID'
if ((ctFieldReference.getDeclaration() != null)
&& !"serialVersionUID".equals(ctFieldReference.getDeclaration().getSimpleName()))
variables.add(ctFieldReference.getDeclaration());
}
}
}
// We find the parent method and we extract the parameters
CtMethod method = element.getParent(CtMethod.class);
if (method != null) {
List<CtParameter> pars = method.getParameters();
for (CtParameter ctParameter : pars) {
variables.add(ctParameter);
}
}
// We find the parent block and we extract the local variables before
// the element under analysis
CtBlock parentblock = element.getParent(CtBlock.class);
CtElement currentElement = element;
if (parentblock != null) {
int positionEl = parentblock.getStatements().indexOf(currentElement);
variables.addAll(VariableResolver.retrieveLocalVariables(positionEl, parentblock));
if (ConfigurationProperties.getPropertyBool("consideryvarloops")) {
variables.addAll(getVarsInFor(currentElement));
variables.addAll(getVarsInForEach(currentElement));
}
}
return variables;
}
