blob: 5e6a1606dec3474257c68f9159ddaa48731d3d66 (
plain)
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
|
package org.checkerframework.dataflow.cfg.node;
import com.sun.source.tree.ExpressionTree;
import com.sun.source.tree.MethodTree;
import com.sun.source.tree.Tree;
import com.sun.source.tree.VariableTree;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import org.checkerframework.javacutil.TreeUtils;
/**
* An assignment context for a node, which represents the place to which the node with this context
* is 'assigned' to. An 'assignment' (as we use the term here) can occur for Java assignments,
* method calls (for all the actual parameters which get assigned to their formal parameters) or
* method return statements.
*
* <p>The main use of {@link AssignmentContext} is to be able to get the declared type of the
* left-hand side of the assignment for proper type-refinement.
*
* @author Stefan Heule
*/
public abstract class AssignmentContext {
/** An assignment context for an assignment 'lhs = rhs'. */
public static class AssignmentLhsContext extends AssignmentContext {
protected final Node node;
public AssignmentLhsContext(Node node) {
this.node = node;
}
@Override
public Element getElementForType() {
Tree tree = node.getTree();
if (tree == null) {
return null;
} else if (tree instanceof ExpressionTree) {
return TreeUtils.elementFromUse((ExpressionTree) tree);
} else if (tree instanceof VariableTree) {
return TreeUtils.elementFromDeclaration((VariableTree) tree);
} else {
assert false : "unexpected tree";
return null;
}
}
@Override
public Tree getContextTree() {
return node.getTree();
}
}
/** An assignment context for a method parameter. */
public static class MethodParameterContext extends AssignmentContext {
protected final ExecutableElement method;
protected final int paramNum;
public MethodParameterContext(ExecutableElement method, int paramNum) {
this.method = method;
this.paramNum = paramNum;
}
@Override
public Element getElementForType() {
return method.getParameters().get(paramNum);
}
@Override
public Tree getContextTree() {
// TODO: what is the right assignment context? We might not have
// a tree for the invoked method.
return null;
}
}
/** An assignment context for method return statements. */
public static class MethodReturnContext extends AssignmentContext {
protected final ExecutableElement method;
protected final Tree ret;
public MethodReturnContext(MethodTree method) {
this.method = TreeUtils.elementFromDeclaration(method);
this.ret = method.getReturnType();
}
@Override
public Element getElementForType() {
return method;
}
@Override
public Tree getContextTree() {
return ret;
}
}
/** An assignment context for lambda return statements. */
public static class LambdaReturnContext extends AssignmentContext {
protected final ExecutableElement method;
public LambdaReturnContext(ExecutableElement method) {
this.method = method;
}
@Override
public Element getElementForType() {
return method;
}
@Override
public Tree getContextTree() {
// TODO: what is the right assignment context? We might not have
// a tree for the invoked method.
return null;
}
}
/** Returns an {@link Element} that has the type of this assignment context. */
public abstract Element getElementForType();
public abstract Tree getContextTree();
}
|
