| package annotations.io; |
| |
| import java.io.IOException; |
| import java.io.StreamTokenizer; |
| import java.io.StringReader; |
| import java.text.Collator; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Comparator; |
| import java.util.Deque; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.NoSuchElementException; |
| |
| import plume.ArraysMDE; |
| import annotations.util.PersistentStack; |
| |
| import com.sun.source.tree.AnnotatedTypeTree; |
| import com.sun.source.tree.AnnotationTree; |
| import com.sun.source.tree.ArrayAccessTree; |
| import com.sun.source.tree.ArrayTypeTree; |
| import com.sun.source.tree.AssertTree; |
| import com.sun.source.tree.AssignmentTree; |
| import com.sun.source.tree.BinaryTree; |
| import com.sun.source.tree.BlockTree; |
| import com.sun.source.tree.CaseTree; |
| import com.sun.source.tree.CatchTree; |
| import com.sun.source.tree.ClassTree; |
| import com.sun.source.tree.CompilationUnitTree; |
| import com.sun.source.tree.CompoundAssignmentTree; |
| import com.sun.source.tree.ConditionalExpressionTree; |
| import com.sun.source.tree.DoWhileLoopTree; |
| import com.sun.source.tree.EnhancedForLoopTree; |
| import com.sun.source.tree.ExpressionStatementTree; |
| import com.sun.source.tree.ExpressionTree; |
| import com.sun.source.tree.ForLoopTree; |
| import com.sun.source.tree.IfTree; |
| import com.sun.source.tree.InstanceOfTree; |
| import com.sun.source.tree.LabeledStatementTree; |
| import com.sun.source.tree.LambdaExpressionTree; |
| import com.sun.source.tree.MemberReferenceTree; |
| import com.sun.source.tree.MemberSelectTree; |
| import com.sun.source.tree.MethodInvocationTree; |
| import com.sun.source.tree.MethodTree; |
| import com.sun.source.tree.NewArrayTree; |
| import com.sun.source.tree.NewClassTree; |
| import com.sun.source.tree.ParameterizedTypeTree; |
| import com.sun.source.tree.ParenthesizedTree; |
| import com.sun.source.tree.ReturnTree; |
| import com.sun.source.tree.StatementTree; |
| import com.sun.source.tree.SwitchTree; |
| import com.sun.source.tree.SynchronizedTree; |
| import com.sun.source.tree.ThrowTree; |
| import com.sun.source.tree.Tree; |
| import com.sun.source.tree.TryTree; |
| import com.sun.source.tree.TypeCastTree; |
| import com.sun.source.tree.UnaryTree; |
| import com.sun.source.tree.UnionTypeTree; |
| import com.sun.source.tree.VariableTree; |
| import com.sun.source.tree.WhileLoopTree; |
| import com.sun.source.tree.WildcardTree; |
| import com.sun.source.util.TreePath; |
| |
| /** |
| * A path through the AST. |
| */ |
| public class ASTPath extends ConsStack<ASTPath.ASTEntry> |
| implements Comparable<ASTPath>, Iterable<ASTPath.ASTEntry> { |
| private static final ASTPath EMPTY = new ASTPath(); |
| private static final String[] typeSelectors = |
| { "bound", "identifier", "type", "typeAlternative", "typeArgument", |
| "typeParameter", "underlyingType" }; |
| |
| // Constants for the various child selectors. |
| public static final String ANNOTATION = "annotation"; |
| public static final String ARGUMENT = "argument"; |
| public static final String BLOCK = "block"; |
| public static final String BODY = "body"; |
| public static final String BOUND = "bound"; |
| public static final String CASE = "case"; |
| public static final String CATCH = "catch"; |
| public static final String CLASS_BODY = "classBody"; |
| public static final String CONDITION = "condition"; |
| public static final String DETAIL = "detail"; |
| public static final String DIMENSION = "dimension"; |
| public static final String ELSE_STATEMENT = "elseStatement"; |
| public static final String ENCLOSING_EXPRESSION = "enclosingExpression"; |
| public static final String EXPRESSION = "expression"; |
| public static final String FALSE_EXPRESSION = "falseExpression"; |
| public static final String FINALLY_BLOCK = "finallyBlock"; |
| public static final String IDENTIFIER = "identifier"; |
| public static final String INDEX = "index"; |
| public static final String INITIALIZER = "initializer"; |
| public static final String LEFT_OPERAND = "leftOperand"; |
| public static final String METHOD_SELECT = "methodSelect"; |
| public static final String MODIFIERS = "modifiers"; |
| public static final String PARAMETER = "parameter"; |
| public static final String QUALIFIER_EXPRESSION = "qualifierExpression"; |
| public static final String RESOURCE = "resource"; |
| public static final String RIGHT_OPERAND = "rightOperand"; |
| public static final String STATEMENT = "statement"; |
| public static final String THEN_STATEMENT = "thenStatement"; |
| public static final String THROWS = "throws"; |
| public static final String TRUE_EXPRESSION = "trueExpression"; |
| public static final String TYPE = "type"; |
| public static final String TYPE_ALTERNATIVE = "typeAlternative"; |
| public static final String TYPE_ARGUMENT = "typeArgument"; |
| public static final String TYPE_PARAMETER = "typeParameter"; |
| public static final String UNDERLYING_TYPE = "underlyingType"; |
| public static final String UPDATE = "update"; |
| public static final String VARIABLE = "variable"; |
| |
| /** |
| * A single entry in an AST path. |
| */ |
| public static class ASTEntry implements Comparable<ASTEntry> { |
| private Tree.Kind treeKind; |
| private String childSelector; |
| private Integer argument; |
| |
| /** |
| * Constructs a new AST entry. For example, in the entry: |
| * <pre> |
| * {@code |
| * Block.statement 3 |
| * }</pre> |
| * the tree kind is "Block", the child selector is "statement", and the |
| * argument is "3". |
| * |
| * @param treeKind the kind of this AST entry |
| * @param childSelector the child selector to this AST entry |
| * @param argument the argument |
| */ |
| public ASTEntry(Tree.Kind treeKind, String childSelector, Integer argument) { |
| this.treeKind = treeKind; |
| this.childSelector = childSelector; |
| this.argument = argument; |
| } |
| |
| /** |
| * Constructs a new AST entry, without an argument. |
| * |
| * See {@link #ASTEntry(Tree.Kind, String, Integer)} for an example of the parameters. |
| * |
| * @param treeKind the kind of this AST entry |
| * @param childSelector the child selector to this AST entry |
| */ |
| public ASTEntry(Tree.Kind treeKind, String childSelector) { |
| this(treeKind, childSelector, null); |
| } |
| |
| /** |
| * Gets the tree node equivalent kind of this AST entry. For example, in |
| * <pre> |
| * {@code |
| * Block.statement 3 |
| * }</pre> |
| * "Block" is the tree kind. |
| * @return the tree kind |
| */ |
| public Tree.Kind getTreeKind() { |
| return treeKind; |
| } |
| |
| /** |
| * Gets the child selector of this AST entry. For example, in |
| * <pre> |
| * {@code |
| * Block.statement 3 |
| * }</pre> |
| * "statement" is the child selector. |
| * @return the child selector |
| */ |
| public String getChildSelector() { |
| return childSelector; |
| } |
| |
| /** |
| * Determines if the given string is equal to this AST path entry's |
| * child selector. |
| * |
| * @param s the string to compare to |
| * @return {@code true} if the string matches the child selector, |
| * {@code false} otherwise. |
| */ |
| public boolean childSelectorIs(String s) { |
| return childSelector.equals(s); |
| } |
| |
| /** |
| * Gets the argument of this AST entry. For example, in |
| * <pre> |
| * {@code |
| * Block.statement 3 |
| * }</pre> |
| * "3" is the argument. |
| * @return the argument |
| * @throws IllegalStateException if this AST entry does not have an argument |
| */ |
| public int getArgument() { |
| if (argument >= (negativeAllowed() ? -1 : 0)) { |
| return argument; |
| } |
| throw new IllegalStateException("Value not set."); |
| } |
| |
| /** |
| * Checks that this Entry has an argument. |
| * |
| * @return if this entry has an argument |
| */ |
| public boolean hasArgument() { |
| return argument == null ? false |
| : argument >= 0 ? true |
| : negativeAllowed(); |
| } |
| |
| // argument < 0 valid for two cases |
| private boolean negativeAllowed() { |
| switch (treeKind) { |
| case CLASS: |
| return childSelectorIs(ASTPath.BOUND); |
| case METHOD: |
| return childSelectorIs(ASTPath.PARAMETER); |
| default: |
| return false; |
| } |
| } |
| |
| @Override |
| public int compareTo(ASTEntry o) { |
| if (o == null) { |
| return 1; |
| } else if (o.childSelector == null) { |
| if (childSelector != null) { return 1; } |
| } else if (childSelector == null) { |
| return -1; |
| } |
| int c = treeKind.compareTo(o.treeKind); |
| if (c != 0) { return c; } |
| c = childSelector.compareTo(o.childSelector); |
| if (c != 0) { return c; } |
| return o.argument == null |
| ? argument == null ? 0 : 1 |
| : argument == null ? -1 : argument.compareTo(o.argument); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| return o instanceof ASTEntry && compareTo((ASTEntry) o) == 0; |
| } |
| |
| @Override |
| public int hashCode() { |
| int base = treeKind.hashCode() ^ childSelector.hashCode(); |
| int shift = argument == null ? 0 : 2 + argument; |
| return Integer.rotateRight(base, shift); |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder b = new StringBuilder(); |
| switch (treeKind) { |
| case CLASS: |
| case ENUM: |
| case INTERFACE: |
| b.append("Class"); |
| break; |
| case AND: |
| case CONDITIONAL_AND: |
| case CONDITIONAL_OR: |
| case DIVIDE: |
| case EQUAL_TO: |
| case GREATER_THAN: |
| case GREATER_THAN_EQUAL: |
| case LEFT_SHIFT: |
| case LESS_THAN: |
| case LESS_THAN_EQUAL: |
| case MINUS: |
| case MULTIPLY: |
| case NOT_EQUAL_TO: |
| case OR: |
| case PLUS: |
| case REMAINDER: |
| case RIGHT_SHIFT: |
| case XOR: |
| b.append("Binary"); |
| break; |
| case LOGICAL_COMPLEMENT: |
| case POSTFIX_DECREMENT: |
| case POSTFIX_INCREMENT: |
| case PREFIX_DECREMENT: |
| case PREFIX_INCREMENT: |
| case UNARY_MINUS: |
| case UNARY_PLUS: |
| case UNSIGNED_RIGHT_SHIFT: |
| b.append("Unary"); |
| break; |
| case AND_ASSIGNMENT: |
| case DIVIDE_ASSIGNMENT: |
| case LEFT_SHIFT_ASSIGNMENT: |
| case MINUS_ASSIGNMENT: |
| case MULTIPLY_ASSIGNMENT: |
| case OR_ASSIGNMENT: |
| case PLUS_ASSIGNMENT: |
| case REMAINDER_ASSIGNMENT: |
| case RIGHT_SHIFT_ASSIGNMENT: |
| case UNSIGNED_RIGHT_SHIFT_ASSIGNMENT: |
| case XOR_ASSIGNMENT: |
| b.append("CompoundAssignment"); |
| break; |
| case EXTENDS_WILDCARD: |
| case SUPER_WILDCARD: |
| case UNBOUNDED_WILDCARD: |
| b.append("Wildcard"); |
| break; |
| case ANNOTATION: |
| case TYPE_ANNOTATION: |
| b.append("Annotation"); |
| break; |
| default: |
| String s = treeKind.toString(); |
| int n = s.length(); |
| boolean cap = true; // capitalize next character |
| for (int i = 0; i < n; i++) { |
| char c = s.charAt(i); |
| if (c == '_') { |
| cap = true; |
| } else { |
| b.append(cap ? Character.toUpperCase(c) |
| : Character.toLowerCase(c)); |
| cap = false; |
| } |
| } |
| } |
| b.append(".").append(childSelector); |
| if (argument != null) { b.append(" ").append(argument); } |
| return b.toString(); |
| } |
| } |
| |
| private static Comparator<ASTPath> comparator = new Comparator<ASTPath>() { |
| @Override |
| public int compare(ASTPath p1, ASTPath p2) { |
| return p1 == null ? (p2 == null ? 0 : -1) : p1.compareTo(p2); |
| } |
| }; |
| |
| ASTPath() {} |
| |
| public static ASTPath empty() { return EMPTY; } |
| |
| public static Comparator<ASTPath> getComparator() { |
| return comparator; |
| } |
| |
| // TODO: replace w/ skip list? |
| @Override |
| public Iterator<ASTEntry> iterator() { |
| PersistentStack<ASTEntry> s = this; |
| int n = size(); |
| ASTEntry[] a = new ASTEntry[n]; |
| while (--n >= 0) { |
| a[n] = s.peek(); |
| s = s.pop(); |
| } |
| return Arrays.asList(a).iterator(); |
| } |
| |
| public ASTPath extendNewArray(int depth) { |
| return extend(new ASTEntry(Tree.Kind.NEW_ARRAY, ASTPath.TYPE, depth)); |
| } |
| |
| public ASTPath newArrayLevel(int depth) { |
| return add(new ASTEntry(Tree.Kind.NEW_ARRAY, ASTPath.TYPE, depth)); |
| } |
| |
| public ASTPath add(ASTEntry entry) { |
| ASTPath path = EMPTY; |
| for (ASTEntry e : this) { path = path.extend(e); } |
| return path.extend(entry); |
| } |
| |
| public ASTPath extend(ASTEntry entry) { |
| return (ASTPath) push(entry); |
| } |
| |
| public ASTPath getParentPath() { |
| return (ASTPath) pop(); |
| } |
| |
| public ASTEntry get(int index) { |
| PersistentStack<ASTEntry> s = this; |
| int n = size(); |
| if (index >= n) { |
| throw new NoSuchElementException(Integer.toString(index)); |
| } |
| if (index < 0) { |
| index += n; |
| if (index < 0) { |
| throw new IllegalArgumentException("negative index " + index); |
| } |
| } |
| while (--n > index) { s = s.pop(); } |
| return s.peek(); |
| } |
| |
| @Override |
| public int hashCode() { |
| // hacky fix: remove {Method,Class}.body for comparison |
| PersistentStack<ASTEntry> s = canonical(this); |
| int hash = 0; |
| while (!s.isEmpty()) { |
| hash = Integer.rotateRight(hash ^ s.peek().hashCode(), 1); |
| s = s.pop(); |
| } |
| return hash; |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| return o instanceof ASTPath && equals((ASTPath) o); |
| } |
| |
| public boolean equals(ASTPath astPath) { |
| return compareTo(astPath) == 0; |
| } |
| |
| @Override |
| public int compareTo(ASTPath o) { |
| // hacky fix: remove {Method,Class}.body for comparison |
| PersistentStack<ASTEntry> s0 = canonical(this); |
| PersistentStack<ASTEntry> s1 = canonical(o); |
| Deque<ASTEntry> d0 = new LinkedList<ASTEntry>(); |
| Deque<ASTEntry> d1 = new LinkedList<ASTEntry>(); |
| int c = 0; |
| while (!s0.isEmpty()) { |
| d0.push(s0.peek()); |
| s0 = s0.pop(); |
| } |
| while (!s1.isEmpty()) { |
| d1.push(s1.peek()); |
| s1 = s1.pop(); |
| } |
| int n0 = d0.size(); |
| int n1 = d1.size(); |
| c = Integer.compare(n0, n1); |
| if (c == 0) { |
| Iterator<ASTEntry> i0 = d0.iterator(); |
| Iterator<ASTEntry> i1 = d1.iterator(); |
| while (i0.hasNext()) { |
| c = i0.next().compareTo(i1.next()); |
| if (c != 0) { return c; } |
| } |
| } |
| return c; |
| } |
| |
| private static ASTPath canonical(ASTPath astPath) { |
| // TODO |
| return astPath; |
| } |
| |
| @Override |
| public String toString() { |
| if (isEmpty()) { return ""; } |
| Iterator<ASTEntry> iter = iterator(); |
| StringBuilder sb = new StringBuilder().append(iter.next()); |
| while (iter.hasNext()) { |
| sb = sb.append(", ").append(iter.next()); |
| } |
| return sb.toString(); |
| } |
| |
| /** |
| * Create a new {@code ASTPath} from a formatted string description. |
| * |
| * @param s formatted string as in JAIF {@code insert-\{cast,annotation\}} |
| * @return the corresponding {@code ASTPath} |
| * @throws ParseException |
| */ |
| public static ASTPath parse(final String s) throws ParseException { |
| return new Parser(s).parseASTPath(); |
| } |
| |
| /** |
| * Determine whether this {@code ASTPath} matches a given {@code TreePath}. |
| */ |
| public boolean matches(TreePath treePath) { |
| CompilationUnitTree cut = treePath.getCompilationUnit(); |
| Tree leaf = treePath.getLeaf(); |
| ASTPath astPath = ASTIndex.indexOf(cut).get(leaf).astPath; // FIXME |
| return this.equals(astPath); |
| } |
| |
| static class Parser { |
| // adapted from annotations.io.IndexFileParser |
| // TODO: refactor IndexFileParser to use this class |
| |
| StreamTokenizer st; |
| |
| Parser(String s) { |
| st = new StreamTokenizer(new StringReader(s)); |
| } |
| |
| private void getTok() { |
| try { |
| st.nextToken(); |
| } catch (IOException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| private boolean gotType(int t) { |
| return st.ttype == t; |
| } |
| |
| private int intVal() throws ParseException { |
| if (gotType(StreamTokenizer.TT_NUMBER)) { |
| int n = (int) st.nval; |
| if (n == st.nval) { |
| return n; |
| } |
| } |
| throw new ParseException("expected integer, got " + st); |
| } |
| |
| private String strVal() throws ParseException { |
| if (gotType(StreamTokenizer.TT_WORD)) { |
| return st.sval; |
| } |
| throw new ParseException("expected string, got " + st); |
| } |
| |
| /** |
| * Parses an AST path. |
| * @return the AST path |
| */ |
| ASTPath parseASTPath() throws ParseException { |
| ASTPath astPath = new ASTPath().extend(parseASTEntry()); |
| while (gotType(',')) { |
| getTok(); |
| astPath = astPath.extend(parseASTEntry()); |
| } |
| return astPath; |
| } |
| |
| /** |
| * Parses and returns the next AST entry. |
| * @return a new AST entry |
| * @throws ParseException if the next entry type is invalid |
| */ |
| ASTEntry parseASTEntry() throws ParseException { |
| String s = strVal(); |
| |
| if (s.equals("AnnotatedType")) { |
| return newASTEntry(Tree.Kind.ANNOTATED_TYPE, |
| new String[] {ASTPath.ANNOTATION, ASTPath.UNDERLYING_TYPE}, |
| new String[] {ASTPath.ANNOTATION}); |
| } else if (s.equals("ArrayAccess")) { |
| return newASTEntry(Tree.Kind.ARRAY_ACCESS, |
| new String[] {ASTPath.EXPRESSION, ASTPath.INDEX}); |
| } else if (s.equals("ArrayType")) { |
| return newASTEntry(Tree.Kind.ARRAY_TYPE, |
| new String[] {ASTPath.TYPE}); |
| } else if (s.equals("Assert")) { |
| return newASTEntry(Tree.Kind.ASSERT, |
| new String[] {ASTPath.CONDITION, ASTPath.DETAIL}); |
| } else if (s.equals("Assignment")) { |
| return newASTEntry(Tree.Kind.ASSIGNMENT, |
| new String[] {ASTPath.VARIABLE, ASTPath.EXPRESSION}); |
| } else if (s.equals("Binary")) { |
| // Always use Tree.Kind.PLUS for Binary |
| return newASTEntry(Tree.Kind.PLUS, |
| new String[] {ASTPath.LEFT_OPERAND, ASTPath.RIGHT_OPERAND}); |
| } else if (s.equals("Block")) { |
| return newASTEntry(Tree.Kind.BLOCK, |
| new String[] {ASTPath.STATEMENT}, |
| new String[] {ASTPath.STATEMENT}); |
| } else if (s.equals("Case")) { |
| return newASTEntry(Tree.Kind.CASE, |
| new String[] {ASTPath.EXPRESSION, ASTPath.STATEMENT}, |
| new String[] {ASTPath.STATEMENT}); |
| } else if (s.equals("Catch")) { |
| return newASTEntry(Tree.Kind.CATCH, |
| new String[] {ASTPath.PARAMETER, ASTPath.BLOCK}); |
| } else if (s.equals("Class")) { |
| return newASTEntry(Tree.Kind.CLASS, |
| new String[] {ASTPath.BOUND, ASTPath.INITIALIZER, |
| ASTPath.TYPE_PARAMETER}, |
| new String[] {ASTPath.BOUND, ASTPath.INITIALIZER, |
| ASTPath.TYPE_PARAMETER}); |
| } else if (s.equals("CompoundAssignment")) { |
| // Always use Tree.Kind.PLUS_ASSIGNMENT for CompoundAssignment |
| return newASTEntry(Tree.Kind.PLUS_ASSIGNMENT, |
| new String[] {ASTPath.VARIABLE, ASTPath.EXPRESSION}); |
| } else if (s.equals("ConditionalExpression")) { |
| return newASTEntry(Tree.Kind.CONDITIONAL_EXPRESSION, |
| new String[] {ASTPath.CONDITION, |
| ASTPath.TRUE_EXPRESSION, |
| ASTPath.FALSE_EXPRESSION}); |
| } else if (s.equals("DoWhileLoop")) { |
| return newASTEntry(Tree.Kind.DO_WHILE_LOOP, |
| new String[] {ASTPath.CONDITION, ASTPath.STATEMENT}); |
| } else if (s.equals("EnhancedForLoop")) { |
| return newASTEntry(Tree.Kind.ENHANCED_FOR_LOOP, |
| new String[] {ASTPath.VARIABLE, |
| ASTPath.EXPRESSION, |
| ASTPath.STATEMENT}); |
| } else if (s.equals("ExpressionStatement")) { |
| return newASTEntry(Tree.Kind.EXPRESSION_STATEMENT, |
| new String[] {ASTPath.EXPRESSION}); |
| } else if (s.equals("ForLoop")) { |
| return newASTEntry(Tree.Kind.FOR_LOOP, |
| new String[] {ASTPath.INITIALIZER, ASTPath.CONDITION, |
| ASTPath.UPDATE, ASTPath.STATEMENT}, |
| new String[] {ASTPath.INITIALIZER, ASTPath.UPDATE}); |
| } else if (s.equals("If")) { |
| return newASTEntry(Tree.Kind.IF, |
| new String[] {ASTPath.CONDITION, |
| ASTPath.THEN_STATEMENT, ASTPath.ELSE_STATEMENT}); |
| } else if (s.equals("InstanceOf")) { |
| return newASTEntry(Tree.Kind.INSTANCE_OF, |
| new String[] {ASTPath.EXPRESSION, ASTPath.TYPE}); |
| } else if (s.equals("LabeledStatement")) { |
| return newASTEntry(Tree.Kind.LABELED_STATEMENT, |
| new String[] {ASTPath.STATEMENT}); |
| } else if (s.equals("LambdaExpression")) { |
| return newASTEntry(Tree.Kind.LAMBDA_EXPRESSION, |
| new String[] {ASTPath.PARAMETER, ASTPath.BODY}, |
| new String[] {ASTPath.PARAMETER}); |
| } else if (s.equals("MemberReference")) { |
| return newASTEntry(Tree.Kind.MEMBER_REFERENCE, |
| new String[] {ASTPath.QUALIFIER_EXPRESSION, ASTPath.TYPE_ARGUMENT}, |
| new String[] {ASTPath.TYPE_ARGUMENT}); |
| } else if (s.equals("MemberSelect")) { |
| return newASTEntry(Tree.Kind.MEMBER_SELECT, |
| new String[] {ASTPath.EXPRESSION}); |
| } else if (s.equals("Method")) { |
| return newASTEntry(Tree.Kind.METHOD, |
| new String[] {ASTPath.BODY, ASTPath.PARAMETER, |
| ASTPath.TYPE, ASTPath.TYPE_PARAMETER}, |
| new String[] {ASTPath.PARAMETER, ASTPath.TYPE_PARAMETER}); |
| } else if (s.equals("MethodInvocation")) { |
| return newASTEntry(Tree.Kind.METHOD_INVOCATION, |
| new String[] {ASTPath.TYPE_ARGUMENT, |
| ASTPath.METHOD_SELECT, ASTPath.ARGUMENT}, |
| new String[] {ASTPath.TYPE_ARGUMENT, ASTPath.ARGUMENT}); |
| } else if (s.equals("NewArray")) { |
| return newASTEntry(Tree.Kind.NEW_ARRAY, |
| new String[] {ASTPath.TYPE, ASTPath.DIMENSION, |
| ASTPath.INITIALIZER}, |
| new String[] {ASTPath.TYPE, ASTPath.DIMENSION, |
| ASTPath.INITIALIZER}); |
| } else if (s.equals("NewClass")) { |
| return newASTEntry(Tree.Kind.NEW_CLASS, |
| new String[] {ASTPath.ENCLOSING_EXPRESSION, |
| ASTPath.TYPE_ARGUMENT, ASTPath.IDENTIFIER, |
| ASTPath.ARGUMENT, ASTPath.CLASS_BODY}, |
| new String[] {ASTPath.TYPE_ARGUMENT, ASTPath.ARGUMENT}); |
| } else if (s.equals("ParameterizedType")) { |
| return newASTEntry(Tree.Kind.PARAMETERIZED_TYPE, |
| new String[] {ASTPath.TYPE, ASTPath.TYPE_ARGUMENT}, |
| new String[] {ASTPath.TYPE_ARGUMENT}); |
| } else if (s.equals("Parenthesized")) { |
| return newASTEntry(Tree.Kind.PARENTHESIZED, |
| new String[] {ASTPath.EXPRESSION}); |
| } else if (s.equals("Return")) { |
| return newASTEntry(Tree.Kind.RETURN, |
| new String[] {ASTPath.EXPRESSION}); |
| } else if (s.equals("Switch")) { |
| return newASTEntry(Tree.Kind.SWITCH, |
| new String[] {ASTPath.EXPRESSION, ASTPath.CASE}, |
| new String[] {ASTPath.CASE}); |
| } else if (s.equals("Synchronized")) { |
| return newASTEntry(Tree.Kind.SYNCHRONIZED, |
| new String[] {ASTPath.EXPRESSION, ASTPath.BLOCK}); |
| } else if (s.equals("Throw")) { |
| return newASTEntry(Tree.Kind.THROW, |
| new String[] {ASTPath.EXPRESSION}); |
| } else if (s.equals("Try")) { |
| return newASTEntry(Tree.Kind.TRY, |
| new String[] {ASTPath.BLOCK, ASTPath.CATCH, ASTPath.FINALLY_BLOCK}, |
| new String[] {ASTPath.CATCH}); |
| } else if (s.equals("TypeCast")) { |
| return newASTEntry(Tree.Kind.TYPE_CAST, |
| new String[] {ASTPath.TYPE, ASTPath.EXPRESSION}); |
| } else if (s.equals("Unary")) { |
| // Always use Tree.Kind.UNARY_PLUS for Unary |
| return newASTEntry(Tree.Kind.UNARY_PLUS, |
| new String[] {ASTPath.EXPRESSION}); |
| } else if (s.equals("UnionType")) { |
| return newASTEntry(Tree.Kind.UNION_TYPE, |
| new String[] {ASTPath.TYPE_ALTERNATIVE}, |
| new String[] {ASTPath.TYPE_ALTERNATIVE}); |
| } else if (s.equals("Variable")) { |
| return newASTEntry(Tree.Kind.VARIABLE, |
| new String[] {ASTPath.TYPE, ASTPath.INITIALIZER}); |
| } else if (s.equals("WhileLoop")) { |
| return newASTEntry(Tree.Kind.WHILE_LOOP, |
| new String[] {ASTPath.CONDITION, ASTPath.STATEMENT}); |
| } else if (s.equals("Wildcard")) { |
| // Always use Tree.Kind.UNBOUNDED_WILDCARD for Wildcard |
| return newASTEntry(Tree.Kind.UNBOUNDED_WILDCARD, |
| new String[] {ASTPath.BOUND}); |
| } |
| |
| throw new ParseException("Invalid AST path type: " + s); |
| } |
| |
| /** |
| * Parses and constructs a new AST entry, where none of the child selections require |
| * arguments. For example, the call: |
| * |
| * <pre> |
| * {@code newASTEntry(Tree.Kind.WHILE_LOOP, new String[] {"condition", "statement"});</pre> |
| * |
| * constructs a while loop AST entry, where the valid child selectors are "condition" or |
| * "statement". |
| * |
| * @param kind the kind of this AST entry |
| * @param legalChildSelectors a list of the legal child selectors for this AST entry |
| * @return a new {@link ASTEntry} |
| * @throws ParseException if an illegal argument is found |
| */ |
| private ASTEntry newASTEntry(Tree.Kind kind, String[] legalChildSelectors) |
| throws ParseException { |
| return newASTEntry(kind, legalChildSelectors, null); |
| } |
| |
| /** |
| * Parses and constructs a new AST entry. For example, the call: |
| * |
| * <pre> |
| * {@code newASTEntry(Tree.Kind.CASE, new String[] {"expression", "statement"}, new String[] {"statement"}); |
| * </pre> |
| * |
| * constructs a case AST entry, where the valid child selectors are |
| * "expression" or "statement" and the "statement" child selector requires |
| * an argument. |
| * |
| * @param kind the kind of this AST entry |
| * @param legalChildSelectors a list of the legal child selectors for this AST entry |
| * @param argumentChildSelectors a list of the child selectors that also require an argument. |
| * Entries here should also be in the legalChildSelectors list. |
| * @return a new {@link ASTEntry} |
| * @throws ParseException if an illegal argument is found |
| */ |
| private ASTEntry newASTEntry(Tree.Kind kind, String[] legalChildSelectors, |
| String[] argumentChildSelectors) throws ParseException { |
| if (gotType('.')) { |
| getTok(); |
| } else { |
| throw new ParseException("expected '.', got " + st); |
| } |
| |
| String s = strVal(); |
| for (String arg : legalChildSelectors) { |
| if (s.equals(arg)) { |
| if (argumentChildSelectors != null |
| && ArraysMDE.indexOf(argumentChildSelectors, arg) >= 0) { |
| getTok(); |
| return new ASTEntry(kind, arg, intVal()); |
| } else { |
| return new ASTEntry(kind, arg); |
| } |
| } |
| } |
| |
| throw new ParseException("Invalid argument for " + kind |
| + " (legal arguments - " + Arrays.toString(legalChildSelectors) |
| + "): " + s); |
| } |
| } |
| |
| static class Matcher { |
| // adapted from IndexFileParser.parseASTPath et al. |
| // TODO: refactor switch statement into TreeVisitor? |
| public static final DebugWriter dbug = new DebugWriter(); |
| private ASTPath astPath; |
| |
| Matcher(ASTPath astPath) { |
| this.astPath = astPath; |
| } |
| |
| private boolean nonDecl(TreePath path) { |
| switch (path.getLeaf().getKind()) { |
| case CLASS: |
| case METHOD: |
| return false; |
| case VARIABLE: |
| TreePath parentPath = path.getParentPath(); |
| return parentPath != null |
| && parentPath.getLeaf().getKind() != Tree.Kind.CLASS; |
| default: |
| return true; |
| } |
| } |
| |
| public boolean matches(TreePath path) { |
| return matches(path, -1); |
| } |
| |
| public boolean matches(TreePath path, int depth) { |
| if (path == null) { |
| return false; |
| } |
| |
| // actualPath stores the path through the source code AST to this |
| // location (specified by the "path" parameter to this method). It is |
| // computed by traversing from this location up the source code AST |
| // until it reaches a method node (this gets only the part of the path |
| // within a method) or class node (this gets only the part of the path |
| // within a field). |
| List<Tree> actualPath = new ArrayList<Tree>(); |
| while (path != null && nonDecl(path)) { |
| actualPath.add(0, path.getLeaf()); |
| path = path.getParentPath(); |
| } |
| |
| if (dbug.isEnabled()) { |
| dbug.debug("AST [%s]%n", astPath); |
| for (Tree t : actualPath) { |
| dbug.debug(" %s: %s%n", t.getKind(), |
| t.toString().replace('\n', ' ')); |
| } |
| } |
| |
| if (astPath.isEmpty() || actualPath.isEmpty() |
| || actualPath.size() != astPath.size() + 1) { |
| return false; |
| } |
| |
| for (int i = 0; i < astPath.size() && i < actualPath.size(); i++) { |
| ASTPath.ASTEntry astNode = astPath.get(i); |
| Tree actualNode = actualPath.get(i); |
| |
| // Based on the child selector and (optional) argument in "astNode", |
| // "next" will get set to the next source node below "actualNode". |
| // Then "next" will be compared with the node following "astNode" |
| // in "actualPath". If it's not a match, this is not the correct |
| // location. If it is a match, keep going. |
| Tree next = null; |
| dbug.debug("astNode: %s%n", astNode); |
| dbug.debug("actualNode: %s%n", actualNode.getKind()); |
| if (!kindsMatch(astNode.getTreeKind(), actualNode.getKind())) { |
| return false; |
| } |
| |
| switch (actualNode.getKind()) { |
| case ANNOTATED_TYPE: { |
| AnnotatedTypeTree annotatedType = (AnnotatedTypeTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.ANNOTATION)) { |
| int arg = astNode.getArgument(); |
| List<? extends AnnotationTree> annos = annotatedType.getAnnotations(); |
| if (arg >= annos.size()) { |
| return false; |
| } |
| next = annos.get(arg); |
| } else { |
| next = annotatedType.getUnderlyingType(); |
| } |
| break; |
| } |
| case ARRAY_ACCESS: { |
| ArrayAccessTree arrayAccess = (ArrayAccessTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.EXPRESSION)) { |
| next = arrayAccess.getExpression(); |
| } else { |
| next = arrayAccess.getIndex(); |
| } |
| break; |
| } |
| case ARRAY_TYPE: { |
| ArrayTypeTree arrayType = (ArrayTypeTree) actualNode; |
| next = arrayType.getType(); |
| break; |
| } |
| case ASSERT: { |
| AssertTree azzert = (AssertTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.CONDITION)) { |
| next = azzert.getCondition(); |
| } else { |
| next = azzert.getDetail(); |
| } |
| break; |
| } |
| case ASSIGNMENT: { |
| AssignmentTree assignment = (AssignmentTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.VARIABLE)) { |
| next = assignment.getVariable(); |
| } else { |
| next = assignment.getExpression(); |
| } |
| break; |
| } |
| case BLOCK: { |
| BlockTree block = (BlockTree) actualNode; |
| int arg = astNode.getArgument(); |
| List<? extends StatementTree> statements = block.getStatements(); |
| if (arg >= block.getStatements().size()) { |
| return false; |
| } |
| next = statements.get(arg); |
| break; |
| } |
| case CASE: { |
| CaseTree caze = (CaseTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.EXPRESSION)) { |
| next = caze.getExpression(); |
| } else { |
| int arg = astNode.getArgument(); |
| List<? extends StatementTree> statements = caze.getStatements(); |
| if (arg >= statements.size()) { |
| return false; |
| } |
| next = statements.get(arg); |
| } |
| break; |
| } |
| case CATCH: { |
| CatchTree cach = (CatchTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.PARAMETER)) { |
| next = cach.getParameter(); |
| } else { |
| next = cach.getBlock(); |
| } |
| break; |
| } |
| case CLASS: { |
| ClassTree clazz = (ClassTree) actualNode; |
| int arg = astNode.getArgument(); |
| if (astNode.childSelectorIs(ASTPath.BOUND)) { |
| next = arg == -1 ? clazz.getExtendsClause() |
| : clazz.getImplementsClause().get(arg); |
| } else { |
| next = clazz.getTypeParameters().get(arg); |
| } |
| break; |
| } |
| case CONDITIONAL_EXPRESSION: { |
| ConditionalExpressionTree conditionalExpression = |
| (ConditionalExpressionTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.CONDITION)) { |
| next = conditionalExpression.getCondition(); |
| } else if (astNode.childSelectorIs(ASTPath.TRUE_EXPRESSION)) { |
| next = conditionalExpression.getTrueExpression(); |
| } else { |
| next = conditionalExpression.getFalseExpression(); |
| } |
| break; |
| } |
| case DO_WHILE_LOOP: { |
| DoWhileLoopTree doWhileLoop =(DoWhileLoopTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.CONDITION)) { |
| next = doWhileLoop.getCondition(); |
| } else { |
| next = doWhileLoop.getStatement(); |
| } |
| break; |
| } |
| case ENHANCED_FOR_LOOP: { |
| EnhancedForLoopTree enhancedForLoop = (EnhancedForLoopTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.VARIABLE)) { |
| next = enhancedForLoop.getVariable(); |
| } else if (astNode.childSelectorIs(ASTPath.EXPRESSION)) { |
| next = enhancedForLoop.getExpression(); |
| } else { |
| next = enhancedForLoop.getStatement(); |
| } |
| break; |
| } |
| case EXPRESSION_STATEMENT: { |
| ExpressionStatementTree expressionStatement = |
| (ExpressionStatementTree) actualNode; |
| next = expressionStatement.getExpression(); |
| break; |
| } |
| case FOR_LOOP: { |
| ForLoopTree forLoop = (ForLoopTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.INITIALIZER)) { |
| int arg = astNode.getArgument(); |
| List<? extends StatementTree> inits = forLoop.getInitializer(); |
| if (arg >= inits.size()) { |
| return false; |
| } |
| next = inits.get(arg); |
| } else if (astNode.childSelectorIs(ASTPath.CONDITION)) { |
| next = forLoop.getCondition(); |
| } else if (astNode.childSelectorIs(ASTPath.UPDATE)) { |
| int arg = astNode.getArgument(); |
| List<? extends ExpressionStatementTree> updates = forLoop.getUpdate(); |
| if (arg >= updates.size()) { |
| return false; |
| } |
| next = updates.get(arg); |
| } else { |
| next = forLoop.getStatement(); |
| } |
| break; |
| } |
| case IF: { |
| IfTree iff = (IfTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.CONDITION)) { |
| next = iff.getCondition(); |
| } else if (astNode.childSelectorIs(ASTPath.THEN_STATEMENT)) { |
| next = iff.getThenStatement(); |
| } else { |
| next = iff.getElseStatement(); |
| } |
| break; |
| } |
| case INSTANCE_OF: { |
| InstanceOfTree instanceOf = (InstanceOfTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.EXPRESSION)) { |
| next = instanceOf.getExpression(); |
| } else { |
| next = instanceOf.getType(); |
| } |
| break; |
| } |
| case LABELED_STATEMENT: { |
| LabeledStatementTree labeledStatement = |
| (LabeledStatementTree) actualNode; |
| next = labeledStatement.getStatement(); |
| break; |
| } |
| case LAMBDA_EXPRESSION: { |
| LambdaExpressionTree lambdaExpression = |
| (LambdaExpressionTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.PARAMETER)) { |
| int arg = astNode.getArgument(); |
| List<? extends VariableTree> params = |
| lambdaExpression.getParameters(); |
| if (arg >= params.size()) { |
| return false; |
| } |
| next = params.get(arg); |
| } else { |
| next = lambdaExpression.getBody(); |
| } |
| break; |
| } |
| case MEMBER_REFERENCE: { |
| MemberReferenceTree memberReference = (MemberReferenceTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.QUALIFIER_EXPRESSION)) { |
| next = memberReference.getQualifierExpression(); |
| } else { |
| int arg = astNode.getArgument(); |
| List<? extends ExpressionTree> typeArgs = |
| memberReference.getTypeArguments(); |
| if (arg >= typeArgs.size()) { |
| return false; |
| } |
| next = typeArgs.get(arg); |
| } |
| break; |
| } |
| case MEMBER_SELECT: { |
| MemberSelectTree memberSelect = (MemberSelectTree) actualNode; |
| next = memberSelect.getExpression(); |
| break; |
| } |
| case METHOD: { |
| MethodTree method = (MethodTree) actualNode; |
| int arg = astNode.getArgument(); |
| if (astNode.childSelectorIs(ASTPath.TYPE)) { |
| next = method.getReturnType(); |
| } else if (astNode.childSelectorIs(ASTPath.PARAMETER)) { |
| next = arg == -1 ? method.getReceiverParameter() |
| : method.getParameters().get(arg); |
| } else if (astNode.childSelectorIs(ASTPath.TYPE_PARAMETER)) { |
| next = method.getTypeParameters().get(arg); |
| } else if (astNode.childSelectorIs(ASTPath.BODY)) { |
| next = method.getBody(); |
| } else { // THROWS? |
| return false; |
| } |
| break; |
| } |
| case METHOD_INVOCATION: { |
| MethodInvocationTree methodInvocation = |
| (MethodInvocationTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.TYPE_ARGUMENT)) { |
| int arg = astNode.getArgument(); |
| List<? extends Tree> typeArgs = methodInvocation.getTypeArguments(); |
| if (arg >= typeArgs.size()) { |
| return false; |
| } |
| next = typeArgs.get(arg); |
| } else if (astNode.childSelectorIs(ASTPath.METHOD_SELECT)) { |
| next = methodInvocation.getMethodSelect(); |
| } else { |
| int arg = astNode.getArgument(); |
| List<? extends ExpressionTree> args = methodInvocation.getArguments(); |
| if (arg >= args.size()) { |
| return false; |
| } |
| next = args.get(arg); |
| } |
| break; |
| } |
| case NEW_ARRAY: { |
| NewArrayTree newArray = (NewArrayTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.TYPE)) { |
| int arg = astNode.getArgument(); |
| if (arg < 0) { |
| next = newArray.getType(); |
| } else { |
| return arg == depth; |
| } |
| } else if (astNode.childSelectorIs(ASTPath.DIMENSION)) { |
| int arg = astNode.getArgument(); |
| List<? extends ExpressionTree> dims = newArray.getDimensions(); |
| if (arg >= dims.size()) { |
| return false; |
| } |
| next = dims.get(arg); |
| } else { |
| int arg = astNode.getArgument(); |
| List<? extends ExpressionTree> inits = newArray.getInitializers(); |
| if (arg >= inits.size()) { |
| return false; |
| } |
| next = inits.get(arg); |
| } |
| break; |
| } |
| case NEW_CLASS: { |
| NewClassTree newClass = (NewClassTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.ENCLOSING_EXPRESSION)) { |
| next = newClass.getEnclosingExpression(); |
| } else if (astNode.childSelectorIs(ASTPath.TYPE_ARGUMENT)) { |
| int arg = astNode.getArgument(); |
| List<? extends Tree> typeArgs = newClass.getTypeArguments(); |
| if (arg >= typeArgs.size()) { |
| return false; |
| } |
| next = typeArgs.get(arg); |
| } else if (astNode.childSelectorIs(ASTPath.IDENTIFIER)) { |
| next = newClass.getIdentifier(); |
| } else if (astNode.childSelectorIs(ASTPath.ARGUMENT)) { |
| int arg = astNode.getArgument(); |
| List<? extends ExpressionTree> args = newClass.getArguments(); |
| if (arg >= args.size()) { |
| return false; |
| } |
| next = args.get(arg); |
| } else { |
| next = newClass.getClassBody(); |
| } |
| break; |
| } |
| case PARAMETERIZED_TYPE: { |
| ParameterizedTypeTree parameterizedType = |
| (ParameterizedTypeTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.TYPE)) { |
| next = parameterizedType.getType(); |
| } else { |
| int arg = astNode.getArgument(); |
| List<? extends Tree> typeArgs = parameterizedType.getTypeArguments(); |
| if (arg >= typeArgs.size()) { |
| return false; |
| } |
| next = typeArgs.get(arg); |
| } |
| break; |
| } |
| case PARENTHESIZED: { |
| ParenthesizedTree parenthesized = (ParenthesizedTree) actualNode; |
| next = parenthesized.getExpression(); |
| break; |
| } |
| case RETURN: { |
| ReturnTree returnn = (ReturnTree) actualNode; |
| next = returnn.getExpression(); |
| break; |
| } |
| case SWITCH: { |
| SwitchTree zwitch = (SwitchTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.EXPRESSION)) { |
| next = zwitch.getExpression(); |
| } else { |
| int arg = astNode.getArgument(); |
| List<? extends CaseTree> cases = zwitch.getCases(); |
| if (arg >= cases.size()) { |
| return false; |
| } |
| next = cases.get(arg); |
| } |
| break; |
| } |
| case SYNCHRONIZED: { |
| SynchronizedTree synchronizzed = (SynchronizedTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.EXPRESSION)) { |
| next = synchronizzed.getExpression(); |
| } else { |
| next = synchronizzed.getBlock(); |
| } |
| break; |
| } |
| case THROW: { |
| ThrowTree throww = (ThrowTree) actualNode; |
| next = throww.getExpression(); |
| break; |
| } |
| case TRY: { |
| TryTree tryy = (TryTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.BLOCK)) { |
| next = tryy.getBlock(); |
| } else if (astNode.childSelectorIs(ASTPath.CATCH)) { |
| int arg = astNode.getArgument(); |
| List<? extends CatchTree> catches = tryy.getCatches(); |
| if (arg >= catches.size()) { |
| return false; |
| } |
| next = catches.get(arg); |
| } else if (astNode.childSelectorIs(ASTPath.FINALLY_BLOCK)) { |
| next = tryy.getFinallyBlock(); |
| } else { |
| int arg = astNode.getArgument(); |
| List<? extends Tree> resources = tryy.getResources(); |
| if (arg >= resources.size()) { |
| return false; |
| } |
| next = resources.get(arg); |
| } |
| break; |
| } |
| case TYPE_CAST: { |
| TypeCastTree typeCast = (TypeCastTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.TYPE)) { |
| next = typeCast.getType(); |
| } else { |
| next = typeCast.getExpression(); |
| } |
| break; |
| } |
| case UNION_TYPE: { |
| UnionTypeTree unionType = (UnionTypeTree) actualNode; |
| int arg = astNode.getArgument(); |
| List<? extends Tree> typeAlts = unionType.getTypeAlternatives(); |
| if (arg >= typeAlts.size()) { |
| return false; |
| } |
| next = typeAlts.get(arg); |
| break; |
| } |
| case VARIABLE: { |
| VariableTree var = (VariableTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.INITIALIZER)) { |
| next = var.getInitializer(); |
| } else { |
| next = var.getType(); |
| } |
| break; |
| } |
| case WHILE_LOOP: { |
| WhileLoopTree whileLoop = (WhileLoopTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.CONDITION)) { |
| next = whileLoop.getCondition(); |
| } else { |
| next = whileLoop.getStatement(); |
| } |
| break; |
| } |
| default: { |
| if (isBinaryOperator(actualNode.getKind())) { |
| BinaryTree binary = (BinaryTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.LEFT_OPERAND)) { |
| next = binary.getLeftOperand(); |
| } else { |
| next = binary.getRightOperand(); |
| } |
| } else if (isCompoundAssignment(actualNode.getKind())) { |
| CompoundAssignmentTree compoundAssignment = |
| (CompoundAssignmentTree) actualNode; |
| if (astNode.childSelectorIs(ASTPath.VARIABLE)) { |
| next = compoundAssignment.getVariable(); |
| } else { |
| next = compoundAssignment.getExpression(); |
| } |
| } else if (isUnaryOperator(actualNode.getKind())) { |
| UnaryTree unary = (UnaryTree) actualNode; |
| next = unary.getExpression(); |
| } else if (isWildcard(actualNode.getKind())) { |
| WildcardTree wildcard = (WildcardTree) actualNode; |
| // The following check is necessary because Oracle has decided that |
| // x instanceof Class<? extends Object> |
| // will remain illegal even though it means the same thing as |
| // x instanceof Class<?>. |
| if (i > 0) { // TODO: refactor GenericArrayLoc to use same code? |
| Tree ancestor = actualPath.get(i-1); |
| if (ancestor.getKind() == Tree.Kind.INSTANCE_OF) { |
| System.err.println("WARNING: wildcard bounds not allowed" |
| + " in 'instanceof' expression; skipping insertion"); |
| return false; |
| } else if (i > 1 && ancestor.getKind() == |
| Tree.Kind.PARAMETERIZED_TYPE) { |
| ancestor = actualPath.get(i-2); |
| if (ancestor.getKind() == Tree.Kind.ARRAY_TYPE) { |
| System.err.println("WARNING: wildcard bounds not allowed" |
| + " in generic array type; skipping insertion"); |
| return false; |
| } |
| } |
| } |
| next = wildcard.getBound(); |
| } else { |
| throw new IllegalArgumentException("Illegal kind: " |
| + actualNode.getKind()); |
| } |
| break; |
| } |
| } |
| |
| dbug.debug("next: %s%n", next); |
| if (next != actualPath.get(i + 1)) { |
| dbug.debug("no next match%n"); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Determines if the given kinds match, false otherwise. Two kinds match if |
| * they're exactly the same or if the two kinds are both compound |
| * assignments, unary operators, binary operators or wildcards. |
| * <p> |
| * This is necessary because in the JAIF file these kinds are represented by |
| * their general types (i.e. BinaryOperator, CompoundOperator, etc.) rather |
| * than their kind (i.e. PLUS, MINUS, PLUS_ASSIGNMENT, XOR_ASSIGNMENT, |
| * etc.). Internally, a single kind is used to represent each general type |
| * (i.e. PLUS is used for BinaryOperator, PLUS_ASSIGNMENT is used for |
| * CompoundAssignment, etc.). Yet, the actual source nodes have the correct |
| * kind. So if an AST path entry has a PLUS kind, that really means it could |
| * be any BinaryOperator, resulting in PLUS matching any other |
| * BinaryOperator. |
| * |
| * @param kind1 |
| * the first kind to match |
| * @param kind2 |
| * the second kind to match |
| * @return {@code true} if the kinds match as described above, {@code false} |
| * otherwise. |
| */ |
| private static boolean kindsMatch(Tree.Kind kind1, Tree.Kind kind2) { |
| return kind1 == kind2 |
| || (isCompoundAssignment(kind1) && isCompoundAssignment(kind2)) |
| || (isUnaryOperator(kind1) && isUnaryOperator(kind2)) |
| || (isBinaryOperator(kind1) && isBinaryOperator(kind2)) |
| || (isWildcard(kind1) && isWildcard(kind2)); |
| } |
| |
| /** |
| * Determines if the given kind is a compound assignment. |
| * |
| * @param kind |
| * the kind to test |
| * @return true if the given kind is a compound assignment |
| */ |
| private static boolean isCompoundAssignment(Tree.Kind kind) { |
| return kind == Tree.Kind.PLUS_ASSIGNMENT |
| || kind == Tree.Kind.MINUS_ASSIGNMENT |
| || kind == Tree.Kind.MULTIPLY_ASSIGNMENT |
| || kind == Tree.Kind.DIVIDE_ASSIGNMENT |
| || kind == Tree.Kind.OR_ASSIGNMENT |
| || kind == Tree.Kind.AND_ASSIGNMENT |
| || kind == Tree.Kind.REMAINDER_ASSIGNMENT |
| || kind == Tree.Kind.LEFT_SHIFT_ASSIGNMENT |
| || kind == Tree.Kind.RIGHT_SHIFT |
| || kind == Tree.Kind.UNSIGNED_RIGHT_SHIFT_ASSIGNMENT |
| || kind == Tree.Kind.XOR_ASSIGNMENT; |
| } |
| |
| /** |
| * Determines if the given kind is a unary operator. |
| * |
| * @param kind |
| * the kind to test |
| * @return true if the given kind is a unary operator |
| */ |
| private static boolean isUnaryOperator(Tree.Kind kind) { |
| return kind == Tree.Kind.POSTFIX_INCREMENT |
| || kind == Tree.Kind.POSTFIX_DECREMENT |
| || kind == Tree.Kind.PREFIX_INCREMENT |
| || kind == Tree.Kind.PREFIX_DECREMENT |
| || kind == Tree.Kind.UNARY_PLUS |
| || kind == Tree.Kind.UNARY_MINUS |
| || kind == Tree.Kind.BITWISE_COMPLEMENT |
| || kind == Tree.Kind.LOGICAL_COMPLEMENT; |
| } |
| |
| /** |
| * Determines if the given kind is a binary operator. |
| * |
| * @param kind |
| * the kind to test |
| * @return true if the given kind is a binary operator |
| */ |
| private static boolean isBinaryOperator(Tree.Kind kind) { |
| return kind == Tree.Kind.MULTIPLY |
| || kind == Tree.Kind.DIVIDE |
| || kind == Tree.Kind.REMAINDER |
| || kind == Tree.Kind.PLUS |
| || kind == Tree.Kind.MINUS |
| || kind == Tree.Kind.LEFT_SHIFT |
| || kind == Tree.Kind.RIGHT_SHIFT |
| || kind == Tree.Kind.UNSIGNED_RIGHT_SHIFT |
| || kind == Tree.Kind.LESS_THAN |
| || kind == Tree.Kind.GREATER_THAN |
| || kind == Tree.Kind.LESS_THAN_EQUAL |
| || kind == Tree.Kind.GREATER_THAN_EQUAL |
| || kind == Tree.Kind.EQUAL_TO |
| || kind == Tree.Kind.NOT_EQUAL_TO |
| || kind == Tree.Kind.AND |
| || kind == Tree.Kind.XOR |
| || kind == Tree.Kind.OR |
| || kind == Tree.Kind.CONDITIONAL_AND |
| || kind == Tree.Kind.CONDITIONAL_OR; |
| } |
| |
| /** |
| * Determines if the given kind is a wildcard. |
| * |
| * @param kind |
| * the kind to test |
| * @return true if the given kind is a wildcard |
| */ |
| private static boolean isWildcard(Tree.Kind kind) { |
| return kind == Tree.Kind.UNBOUNDED_WILDCARD |
| || kind == Tree.Kind.EXTENDS_WILDCARD |
| || kind == Tree.Kind.SUPER_WILDCARD; |
| } |
| } |
| |
| public static boolean isTypeSelector(String selector) { |
| return Arrays.<String>binarySearch(typeSelectors, |
| selector, Collator.getInstance()) >= 0; |
| } |
| |
| public static boolean isClassEquiv(Tree.Kind kind) { |
| switch (kind) { |
| case CLASS: |
| case INTERFACE: |
| case ENUM: |
| case ANNOTATION_TYPE: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Determines if the given kind is a compound assignment. |
| * |
| * @param kind |
| * the kind to test |
| * @return true if the given kind is a compound assignment |
| */ |
| public static boolean isCompoundAssignment(Tree.Kind kind) { |
| return kind == Tree.Kind.PLUS_ASSIGNMENT |
| || kind == Tree.Kind.MINUS_ASSIGNMENT |
| || kind == Tree.Kind.MULTIPLY_ASSIGNMENT |
| || kind == Tree.Kind.DIVIDE_ASSIGNMENT |
| || kind == Tree.Kind.OR_ASSIGNMENT |
| || kind == Tree.Kind.AND_ASSIGNMENT |
| || kind == Tree.Kind.REMAINDER_ASSIGNMENT |
| || kind == Tree.Kind.LEFT_SHIFT_ASSIGNMENT |
| || kind == Tree.Kind.RIGHT_SHIFT_ASSIGNMENT |
| || kind == Tree.Kind.UNSIGNED_RIGHT_SHIFT_ASSIGNMENT |
| || kind == Tree.Kind.XOR_ASSIGNMENT; |
| } |
| |
| /** |
| * Determines if the given kind is a unary operator. |
| * |
| * @param kind |
| * the kind to test |
| * @return true if the given kind is a unary operator |
| */ |
| public static boolean isUnaryOperator(Tree.Kind kind) { |
| return kind == Tree.Kind.POSTFIX_INCREMENT |
| || kind == Tree.Kind.POSTFIX_DECREMENT |
| || kind == Tree.Kind.PREFIX_INCREMENT |
| || kind == Tree.Kind.PREFIX_DECREMENT |
| || kind == Tree.Kind.UNARY_PLUS |
| || kind == Tree.Kind.UNARY_MINUS |
| || kind == Tree.Kind.BITWISE_COMPLEMENT |
| || kind == Tree.Kind.LOGICAL_COMPLEMENT; |
| } |
| |
| /** |
| * Determines if the given kind is a binary operator. |
| * |
| * @param kind |
| * the kind to test |
| * @return true if the given kind is a binary operator |
| */ |
| public static boolean isBinaryOperator(Tree.Kind kind) { |
| return kind == Tree.Kind.MULTIPLY || kind == Tree.Kind.DIVIDE |
| || kind == Tree.Kind.REMAINDER || kind == Tree.Kind.PLUS |
| || kind == Tree.Kind.MINUS || kind == Tree.Kind.LEFT_SHIFT |
| || kind == Tree.Kind.RIGHT_SHIFT |
| || kind == Tree.Kind.UNSIGNED_RIGHT_SHIFT |
| || kind == Tree.Kind.LESS_THAN |
| || kind == Tree.Kind.GREATER_THAN |
| || kind == Tree.Kind.LESS_THAN_EQUAL |
| || kind == Tree.Kind.GREATER_THAN_EQUAL |
| || kind == Tree.Kind.EQUAL_TO || kind == Tree.Kind.NOT_EQUAL_TO |
| || kind == Tree.Kind.AND || kind == Tree.Kind.XOR |
| || kind == Tree.Kind.OR || kind == Tree.Kind.CONDITIONAL_AND |
| || kind == Tree.Kind.CONDITIONAL_OR; |
| } |
| |
| public static boolean isLiteral(Tree.Kind kind) { |
| switch (kind) { |
| case INT_LITERAL: |
| case LONG_LITERAL: |
| case FLOAT_LITERAL: |
| case DOUBLE_LITERAL: |
| case BOOLEAN_LITERAL: |
| case CHAR_LITERAL: |
| case STRING_LITERAL: |
| case NULL_LITERAL: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| public static boolean isExpression(Tree.Kind kind) { |
| switch (kind) { |
| case ARRAY_ACCESS: |
| case ASSIGNMENT: |
| case CONDITIONAL_EXPRESSION: |
| case EXPRESSION_STATEMENT: |
| case MEMBER_SELECT: |
| case MEMBER_REFERENCE: |
| case IDENTIFIER: |
| case INSTANCE_OF: |
| case METHOD_INVOCATION: |
| case NEW_ARRAY: |
| case NEW_CLASS: |
| case LAMBDA_EXPRESSION: |
| case PARENTHESIZED: |
| case TYPE_CAST: |
| return true; |
| default: |
| return isUnaryOperator(kind) || isBinaryOperator(kind) |
| || isCompoundAssignment(kind) || isLiteral(kind); |
| } |
| } |
| |
| public static boolean isTypeKind(Tree.Kind kind) { |
| switch (kind) { |
| case ANNOTATED_TYPE: |
| case ARRAY_TYPE: |
| case IDENTIFIER: |
| case INTERSECTION_TYPE: |
| // case MEMBER_SELECT: |
| case PARAMETERIZED_TYPE: |
| case PRIMITIVE_TYPE: |
| case UNION_TYPE: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Determines if the given kind is a wildcard. |
| * |
| * @param kind |
| * the kind to test |
| * @return true if the given kind is a wildcard |
| */ |
| public static boolean isWildcard(Tree.Kind kind) { |
| return kind == Tree.Kind.UNBOUNDED_WILDCARD |
| || kind == Tree.Kind.EXTENDS_WILDCARD |
| || kind == Tree.Kind.SUPER_WILDCARD; |
| } |
| |
| /** |
| * Determines if the given kind is a declaration. |
| * |
| * @param kind |
| * the kind to test |
| * @return true if the given kind is a declaration |
| */ |
| public static boolean isDeclaration(Tree.Kind kind) { |
| return kind == Tree.Kind.ANNOTATION |
| || kind == Tree.Kind.CLASS |
| || kind == Tree.Kind.ENUM |
| || kind == Tree.Kind.INTERFACE |
| || kind == Tree.Kind.METHOD |
| || kind == Tree.Kind.VARIABLE; |
| } |
| |
| /** |
| * Determines whether an {@code ASTPath} can identify nodes of the |
| * given kind. |
| * |
| * @param kind |
| * the kind to test |
| * @return true if the given kind can be identified by an {@code ASTPath}. |
| */ |
| public static boolean isHandled(Tree.Kind kind) { |
| switch (kind) { |
| case BREAK: |
| case COMPILATION_UNIT: |
| case CONTINUE: |
| case IMPORT: |
| case MODIFIERS: |
| return false; |
| default: |
| return !isDeclaration(kind); |
| } |
| } // TODO: need "isType"? |
| } |
| |
| /** |
| * |
| * @author dbro |
| * |
| * @param <E> type of stack elements |
| */ |
| class ConsStack<E> implements PersistentStack<E> { |
| private int size; |
| private E elem; |
| private PersistentStack<E> rest; |
| |
| public ConsStack() { |
| size = 0; |
| elem = null; |
| rest = null; |
| } |
| |
| private static <T, S extends ConsStack<T>> S extend(T el, S s0) { |
| try { |
| @SuppressWarnings("unchecked") |
| S s1 = (S) s0.getClass().newInstance(); |
| ConsStack<T> cs = (ConsStack<T>) s1; |
| cs.size = 1 + s0.size(); |
| cs.elem = el; |
| cs.rest = s0; |
| return s1; |
| } catch (InstantiationException e) { |
| throw new RuntimeException(e); |
| } catch (IllegalAccessException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| @Override |
| public boolean isEmpty() { return size == 0; } |
| |
| @Override |
| public E peek() { |
| if (size > 0) { return elem; } |
| throw new IllegalStateException("peek() on empty stack"); |
| } |
| |
| @Override |
| public PersistentStack<E> pop() { |
| if (size > 0) { return rest; } |
| throw new IllegalStateException("pop() on empty stack"); |
| } |
| |
| @Override |
| public PersistentStack<E> push(E elem) { |
| return extend(elem, this); |
| } |
| |
| @Override |
| public int size() { return size; } |
| |
| @Override |
| public String toString() { |
| if (size > 0) { |
| StringBuilder sb = new StringBuilder("]").insert(0, peek()); |
| for (PersistentStack<E> stack = pop(); !stack.isEmpty(); |
| stack = stack.pop()) { |
| sb = sb.insert(0, ", ").insert(0, stack.peek()); |
| } |
| return sb.insert(0, "[").toString(); |
| } |
| return "[]"; |
| } |
| } |
