// Metodo para tratamento de declarações de métodos
private void methodDeclarationHandler(MethodDeclaration methodDeclaration, ApiClass apiClass) {
IMethodBinding mb = methodDeclaration.resolveBinding();
if (mb == null) {
return;
}
LinkedList<String> paramsType = new LinkedList<String>();
for (ITypeBinding pt : mb.getParameterTypes()) {
paramsType.add(pt.getQualifiedName().toString());
}
ApiMethod apiMethod = new ApiMethod(apiClass, mb.getName(), paramsType);
this.setModifiers(apiMethod, methodDeclaration);
if (mb.isConstructor()) {
apiMethod.setConstructor(true);
apiMethod.setVoid(false);
apiMethod.setFunction(false);
apiMethod.setReturnType(null);
} else if (mb.getReturnType().getQualifiedName().equalsIgnoreCase("void")) {
apiMethod.setVoid(true);
apiMethod.setFunction(false);
apiMethod.setReturnType(null);
} else {
apiMethod.setVoid(false);
apiMethod.setFunction(true);
apiMethod.setReturnType(mb.getReturnType().getQualifiedName());
}
apiClass.getApiMethods().add(apiMethod);
this.methodMap.put(mb, apiMethod);
}
@Override
public boolean visit(TypeDeclaration node) {
if (node.isPackageMemberTypeDeclaration() || node.isMemberTypeDeclaration()) {
ITypeBinding typeBinding = node.resolveBinding();
if (typeBinding != null) {
// Criando classe
ApiClass apiClass = new ApiClass(typeBinding.getQualifiedName());
apiClass.setInterface(typeBinding.isInterface());
this.setModifiers(apiClass, node);
this.classMap.put(typeBinding, apiClass);
if (!this.attachmentMap.containsKey(node.getRoot())) {
Attachment attachment =
new Attachment(
typeBinding.getQualifiedName().concat(".java"),
node.getRoot().toString().getBytes());
this.attachmentMap.put(node.getRoot(), attachment);
}
List<MethodDeclaration> declarations = new LinkedList<MethodDeclaration>();
for (Object o : node.bodyDeclarations()) {
if (o instanceof MethodDeclaration) {
declarations.add((MethodDeclaration) o);
}
}
for (final MethodDeclaration declaration : declarations) {
final List<Expression> invocations = new LinkedList<Expression>();
this.methodDeclarationHandler(declaration, apiClass);
InvocationVisitor visitor = new InvocationVisitor();
declaration.accept(visitor);
invocations.addAll(visitor.invocations);
// Parte de extracao de exemplos, se não houver invocações eu pulo esta parte
if (invocations.isEmpty()) {
continue;
} else {
// Faço a extração de exemplos para cada invocação em separado
Set<ApiMethod> methodsInvocations = new HashSet<ApiMethod>();
for (Expression mi : invocations) {
methodsInvocations.add(this.mapInvocations.get(mi));
Example newExample =
makeExample(
declaration,
Collections.singleton(mi),
Collections.singletonList(this.mapInvocations.get(mi)));
if (newExample != null) {
this.examples.add(newExample);
}
}
// Se houver mais de uma invocacao faço o slicing com sementes multiplas
if (invocations.size() > 1) {
// Itero sobre os conjuntos das regras
Iterator<Set<ApiMethod>> it = this.methodSets.iterator();
while (it.hasNext()) {
// Podando conjuntos
Set<ApiMethod> s = it.next();
if (s.size() > methodsInvocations.size()) {
break;
} else {
// Se as invocacoes identificadas envolvem metodos desejados eu processo
if (methodsInvocations.containsAll(s)) {
List<ApiMethod> methods = new ArrayList<ApiMethod>();
Set<Expression> invocationsTemp = new HashSet<Expression>();
for (Expression mi : invocations) {
ApiMethod relatedMethod = this.mapInvocations.get(mi);
if (s.contains(relatedMethod)) {
methods.add(relatedMethod);
invocationsTemp.add(mi);
}
}
Example newExample = makeExample(declaration, invocationsTemp, methods);
if (newExample != null) {
this.examples.add(newExample);
}
}
}
}
}
}
}
}
}
return super.visit(node);
}