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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
package com.github.javaparser.symbolsolver.javaparsermodel.contexts;
import com.github.javaparser.ast.NodeList;
import com.github.javaparser.ast.expr.ObjectCreationExpr;
import com.github.javaparser.ast.nodeTypes.NodeWithTypeArguments;
import com.github.javaparser.ast.type.TypeParameter;
import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration;
import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
import com.github.javaparser.resolution.types.ResolvedReferenceType;
import com.github.javaparser.resolution.types.ResolvedType;
import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFactory;
import com.github.javaparser.symbolsolver.javaparsermodel.declarations
.JavaParserAnonymousClassDeclaration;
import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserTypeParameter;
import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
import com.github.javaparser.symbolsolver.resolution.MethodResolutionLogic;
import com.google.common.base.Preconditions;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* A symbol resolution context for an object creation node.
*/
public class AnonymousClassDeclarationContext extends AbstractJavaParserContext<ObjectCreationExpr> {
private final JavaParserAnonymousClassDeclaration myDeclaration =
new JavaParserAnonymousClassDeclaration(wrappedNode, typeSolver);
public AnonymousClassDeclarationContext(ObjectCreationExpr node, TypeSolver typeSolver) {
super(node, typeSolver);
Preconditions.checkArgument(node.getAnonymousClassBody().isPresent(),
"An anonymous class must have a body");
}
@Override
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name,
List<ResolvedType> argumentsTypes,
boolean staticOnly,
TypeSolver typeSolver) {
List<ResolvedMethodDeclaration> candidateMethods =
myDeclaration
.getDeclaredMethods()
.stream()
.filter(m -> m.getName().equals(name) && (!staticOnly || m.isStatic()))
.collect(Collectors.toList());
if (!Object.class.getCanonicalName().equals(myDeclaration.getQualifiedName())) {
for (ResolvedReferenceType ancestor : myDeclaration.getAncestors()) {
SymbolReference<ResolvedMethodDeclaration> res =
MethodResolutionLogic.solveMethodInType(ancestor.getTypeDeclaration(),
name,
argumentsTypes,
staticOnly,
typeSolver);
// consider methods from superclasses and only default methods from interfaces :
// not true, we should keep abstract as a valid candidate
// abstract are removed in MethodResolutionLogic.isApplicable is necessary
if (res.isSolved()) {
candidateMethods.add(res.getCorrespondingDeclaration());
}
}
}
// We want to avoid infinite recursion when a class is using its own method
// see issue #75
if (candidateMethods.isEmpty()) {
SymbolReference<ResolvedMethodDeclaration> parentSolution =
getParent().solveMethod(name, argumentsTypes, staticOnly, typeSolver);
if (parentSolution.isSolved()) {
candidateMethods.add(parentSolution.getCorrespondingDeclaration());
}
}
// if is interface and candidate method list is empty, we should check the Object Methods
if (candidateMethods.isEmpty() && myDeclaration.getSuperTypeDeclaration().isInterface()) {
SymbolReference<ResolvedMethodDeclaration> res =
MethodResolutionLogic.solveMethodInType(new ReflectionClassDeclaration(Object.class,
typeSolver),
name,
argumentsTypes,
false,
typeSolver);
if (res.isSolved()) {
candidateMethods.add(res.getCorrespondingDeclaration());
}
}
return MethodResolutionLogic.findMostApplicable(candidateMethods,
name,
argumentsTypes,
typeSolver);
}
@Override
public SymbolReference<ResolvedTypeDeclaration> solveType(String name, TypeSolver typeSolver) {
List<com.github.javaparser.ast.body.TypeDeclaration> typeDeclarations =
myDeclaration
.findMembersOfKind(com.github.javaparser.ast.body.TypeDeclaration.class);
Optional<SymbolReference<ResolvedTypeDeclaration>> exactMatch =
typeDeclarations
.stream()
.filter(internalType -> internalType.getName().getId().equals(name))
.findFirst()
.map(internalType ->
SymbolReference.solved(
JavaParserFacade.get(typeSolver).getTypeDeclaration(internalType)));
if(exactMatch.isPresent()){
return exactMatch.get();
}
Optional<SymbolReference<ResolvedTypeDeclaration>> recursiveMatch =
typeDeclarations
.stream()
.filter(internalType -> name.startsWith(String.format("%s.", internalType.getName())))
.findFirst()
.map(internalType ->
JavaParserFactory
.getContext(internalType, typeSolver)
.solveType(name.substring(internalType.getName().getId().length() + 1),
typeSolver));
if (recursiveMatch.isPresent()) {
return recursiveMatch.get();
}
Optional<SymbolReference<ResolvedTypeDeclaration>> typeArgumentsMatch =
wrappedNode
.getTypeArguments()
.map(nodes ->
((NodeWithTypeArguments<?>) nodes).getTypeArguments()
.orElse(new NodeList<>()))
.orElse(new NodeList<>())
.stream()
.filter(type -> type.toString().equals(name))
.findFirst()
.map(matchingType ->
SymbolReference.solved(
new JavaParserTypeParameter(new TypeParameter(matchingType.toString()),
typeSolver)));
if (typeArgumentsMatch.isPresent()) {
return typeArgumentsMatch.get();
}
// Look into extended classes and implemented interfaces
for (ResolvedReferenceType ancestor : myDeclaration.getAncestors()) {
// look at names of extended classes and implemented interfaces (this may not be important because they are checked in CompilationUnitContext)
if (ancestor.getTypeDeclaration().getName().equals(name)) {
return SymbolReference.solved(ancestor.getTypeDeclaration());
}
// look into internal types of extended classes and implemented interfaces
try {
for (ResolvedTypeDeclaration internalTypeDeclaration : ancestor.getTypeDeclaration().internalTypes()) {
if (internalTypeDeclaration.getName().equals(name)) {
return SymbolReference.solved(internalTypeDeclaration);
}
}
} catch (UnsupportedOperationException e) {
// just continue using the next ancestor
}
}
return getParent().solveType(name, typeSolver);
}
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name,
TypeSolver typeSolver) {
Preconditions.checkArgument(typeSolver != null);
if (myDeclaration.hasVisibleField(name)) {
return SymbolReference.solved(myDeclaration.getVisibleField(name));
}
return getParent().solveSymbol(name, typeSolver);
}
}
|
