-
-
Notifications
You must be signed in to change notification settings - Fork 347
/
TypeReferenceScanner.java
149 lines (130 loc) · 3.85 KB
/
TypeReferenceScanner.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
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
/**
* SPDX-License-Identifier: (MIT OR CECILL-C)
*
* Copyright (C) 2006-2019 INRIA and contributors
*
* Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) of the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
*/
package spoon.support.visitor;
import spoon.reflect.code.CtFieldRead;
import spoon.reflect.code.CtFieldWrite;
import spoon.reflect.declaration.CtAnnotationType;
import spoon.reflect.declaration.CtClass;
import spoon.reflect.declaration.CtEnum;
import spoon.reflect.declaration.CtInterface;
import spoon.reflect.declaration.CtType;
import spoon.reflect.declaration.CtTypeMember;
import spoon.reflect.reference.CtArrayTypeReference;
import spoon.reflect.reference.CtExecutableReference;
import spoon.reflect.reference.CtFieldReference;
import spoon.reflect.reference.CtTypeReference;
import spoon.reflect.visitor.CtScanner;
import java.lang.annotation.Annotation;
import java.util.HashSet;
import java.util.Set;
/**
* A scanner that calculates the imports for a given model.
*/
public class TypeReferenceScanner extends CtScanner {
Set<CtTypeReference<?>> references;
/**
* Constructor.
*/
public TypeReferenceScanner() {
references = new HashSet<>();
}
/**
* Constructor.
*
* @param references
* a set to fill with the references
*/
public TypeReferenceScanner(HashSet<CtTypeReference<?>> references) {
this.references = references;
}
/**
* Returns the set of calculated references.
*/
public Set<CtTypeReference<?>> getReferences() {
return references;
}
/**
* Adds a reference.
*/
private <T> boolean addReference(CtTypeReference<T> ref) {
return references.add(ref);
}
@Override
public <T> void visitCtFieldRead(CtFieldRead<T> fieldRead) {
super.visitCtFieldRead(fieldRead);
enter(fieldRead);
scan(fieldRead.getVariable());
scan(fieldRead.getAnnotations());
scan(fieldRead.getTypeCasts());
scan(fieldRead.getVariable());
scan(fieldRead.getTarget());
exit(fieldRead);
}
@Override
public <T> void visitCtFieldWrite(CtFieldWrite<T> fieldWrite) {
enter(fieldWrite);
scan(fieldWrite.getVariable());
scan(fieldWrite.getAnnotations());
scan(fieldWrite.getTypeCasts());
scan(fieldWrite.getVariable());
scan(fieldWrite.getTarget());
exit(fieldWrite);
}
@Override
public <T> void visitCtFieldReference(CtFieldReference<T> reference) {
enter(reference);
scan(reference.getDeclaringType());
exit(reference);
}
@Override
public <T> void visitCtExecutableReference(
CtExecutableReference<T> reference) {
enter(reference);
scan(reference.getDeclaringType());
scan(reference.getActualTypeArguments());
exit(reference);
}
@Override
public <T> void visitCtTypeReference(CtTypeReference<T> reference) {
if (!(reference instanceof CtArrayTypeReference)) {
addReference(reference);
}
super.visitCtTypeReference(reference);
}
@Override
public <A extends Annotation> void visitCtAnnotationType(
CtAnnotationType<A> annotationType) {
addReference(annotationType.getReference());
super.visitCtAnnotationType(annotationType);
}
@Override
public <T extends Enum<?>> void visitCtEnum(CtEnum<T> ctEnum) {
addReference(ctEnum.getReference());
super.visitCtEnum(ctEnum);
}
@Override
public <T> void visitCtInterface(CtInterface<T> intrface) {
addReference(intrface.getReference());
for (CtTypeMember typeMember : intrface.getTypeMembers()) {
if (typeMember instanceof CtType) {
addReference(((CtType) typeMember).getReference());
}
}
super.visitCtInterface(intrface);
}
@Override
public <T> void visitCtClass(CtClass<T> ctClass) {
addReference(ctClass.getReference());
for (CtTypeMember typeMember : ctClass.getTypeMembers()) {
if (typeMember instanceof CtType) {
addReference(((CtType) typeMember).getReference());
}
}
super.visitCtClass(ctClass);
}
}