-
Notifications
You must be signed in to change notification settings - Fork 1.1k
/
MethodCallExprContext.java
95 lines (85 loc) · 4.33 KB
/
MethodCallExprContext.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
package me.tomassetti.symbolsolver.resolution.javaparser.contexts;
import com.github.javaparser.ast.expr.MethodCallExpr;
import com.github.javaparser.ast.expr.NameExpr;
import me.tomassetti.symbolsolver.JavaParserFacade;
import me.tomassetti.symbolsolver.resolution.*;
import me.tomassetti.symbolsolver.model.declarations.MethodDeclaration;
import me.tomassetti.symbolsolver.model.declarations.TypeDeclaration;
import me.tomassetti.symbolsolver.model.declarations.ValueDeclaration;
import me.tomassetti.symbolsolver.resolution.javaparser.UnsolvedSymbolException;
import me.tomassetti.symbolsolver.model.typesystem.MethodUsage;
import me.tomassetti.symbolsolver.model.typesystem.TypeUsage;
import java.util.List;
import java.util.Optional;
/**
* Created by federico on 31/07/15.
*/
public class MethodCallExprContext extends AbstractJavaParserContext<MethodCallExpr> {
public MethodCallExprContext(MethodCallExpr wrappedNode) {
super(wrappedNode);
}
@Override
public Optional<TypeUsage> solveGenericType(String name, TypeSolver typeSolver) {
if (wrappedNode.getTypeArgs() != null) {
throw new UnsupportedOperationException(name);
}
TypeUsage typeOfScope = JavaParserFacade.get(typeSolver).getType(wrappedNode.getScope());
return typeOfScope.asReferenceTypeUsage().solveGenericType(name);
}
@Override
public Optional<MethodUsage> solveMethodAsUsage(String name, List<TypeUsage> parameterTypes, TypeSolver typeSolver) {
// TODO consider call of static methods
if (wrappedNode.getScope() != null) {
try {
TypeUsage typeOfScope = JavaParserFacade.get(typeSolver).getType(wrappedNode.getScope());
return typeOfScope.solveMethodAsUsage(name, parameterTypes, typeSolver, this);
} catch (UnsolvedSymbolException e){
// ok, maybe it was instead a static access, so let's look for a type
if (wrappedNode.getScope() instanceof NameExpr){
String className = ((NameExpr)wrappedNode.getScope()).getName();
SymbolReference<TypeDeclaration> ref = solveType(className, typeSolver);
if (ref.isSolved()) {
SymbolReference<MethodDeclaration> m = ref.getCorrespondingDeclaration().solveMethod(name, parameterTypes, typeSolver);
if (m.isSolved()) {
return Optional.of(new MethodUsage(m.getCorrespondingDeclaration(), typeSolver));
} else {
throw new UnsolvedSymbolException(ref.getCorrespondingDeclaration().toString(), "Method '"+name+"' with parameterTypes "+parameterTypes);
}
} else {
throw e;
}
} else {
throw e;
}
}
} else {
if (wrappedNode.getParentNode() instanceof MethodCallExpr) {
MethodCallExpr parent = (MethodCallExpr)wrappedNode.getParentNode();
if (parent.getScope() == wrappedNode) {
return getParent().getParent().solveMethodAsUsage(name, parameterTypes, typeSolver);
}
}
Context parentContext = getParent();
return parentContext.solveMethodAsUsage(name, parameterTypes, typeSolver);
}
}
@Override
public SymbolReference<? extends ValueDeclaration> solveSymbol(String name, TypeSolver typeSolver) {
return getParent().solveSymbol(name, typeSolver);
}
@Override
public Optional<Value> solveSymbolAsValue(String name, TypeSolver typeSolver) {
Context parentContext = getParent();
return parentContext.solveSymbolAsValue(name, typeSolver);
}
@Override
public SymbolReference<MethodDeclaration> solveMethod(String name, List<TypeUsage> parameterTypes, TypeSolver typeSolver) {
if (wrappedNode.getScope() != null) {
TypeUsage typeOfScope = JavaParserFacade.get(typeSolver).getType(wrappedNode.getScope());
return typeOfScope.solveMethod(name, parameterTypes, typeSolver);
} else {
TypeUsage typeOfScope = JavaParserFacade.get(typeSolver).getTypeOfThisIn(wrappedNode);
return typeOfScope.solveMethod(name, parameterTypes, typeSolver);
}
}
}