Java ArrayAccessTree类代码示例

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
@Override
public List<Fix> run(CompilationInfo info, String diagnosticKey, int offset, TreePath treePath, Data<Void> data) {
    if (treePath.getLeaf().getKind() != Kind.ARRAY_ACCESS) {
        return Collections.emptyList();
    }
    ArrayAccessTree aa = (ArrayAccessTree) treePath.getLeaf();
    TypeMirror onType = info.getTrees().getTypeMirror(new TreePath(treePath, aa.getExpression()));
    boolean list = isSubType(info, onType, "java.util.List");
    boolean map = isSubType(info, onType, "java.util.Map");
    
    if (list || map) {
        Kind parentKind = treePath.getParentPath().getLeaf().getKind();
        if (CANNOT_HANDLE_PARENTS.contains(parentKind)) return null;
        return Collections.singletonList(new ConvertFromArrayAccess(info, treePath, map, parentKind == Kind.ASSIGNMENT).toEditorFix());
    }
    
    return Collections.emptyList();
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
@Override
public Mirror visitArrayAccess(ArrayAccessTree arg0, EvaluationContext evaluationContext) {
    Mirror array = arg0.getExpression().accept(this, evaluationContext);
    if (array == null) {
        Assert.error(arg0, "arrayIsNull", arg0.getExpression());
    }
    Mirror index = arg0.getIndex().accept(this, evaluationContext);
    if (!(array instanceof ArrayReference)) {
        Assert.error(arg0, "notArrayType", arg0.getExpression());
    }
    if (!(index instanceof PrimitiveValue)) {
        Assert.error(arg0, "arraySizeBadType", index);
    }
    int i = ((PrimitiveValue) index).intValue();
    if (i < 0 || i >= ((ArrayReference) array).length()) {
        Assert.error(arg0, "arrayIndexOutOfBounds", array, i);
    }
    evaluationContext.putArrayAccess(arg0, (ArrayReference)array, i);
    return ((ArrayReference) array).getValue(i);
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
@Override
public Description matchTypeCast(TypeCastTree typeCastTree, VisitorState visitorState) {
  CastingMatcher castingMatcher = new CastingMatcher();

  if (!(typeCastTree.getExpression() instanceof IdentifierTree
      || typeCastTree.getExpression() instanceof ArrayAccessTree)) {
    return Description.NO_MATCH;
  }
  if (castingMatcher.matches(typeCastTree, visitorState)) {
    return buildDescription(typeCastTree)
        .addFix(
            SuggestedFix.replace(castingMatcher.nodeToReplace, typeCastTree.getType().toString()))
        .build();
  }
  return Description.NO_MATCH;
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
@Override
public AnnotatedTypeMirror visitArrayAccess(ArrayAccessTree node,
        AnnotatedTypeFactory f) {

    Pair<Tree, AnnotatedTypeMirror> preAssCtxt = f.visitorState.getAssignmentContext();
    try {
        // TODO: what other trees shouldn't maintain the context?
        f.visitorState.setAssignmentContext(null);

        AnnotatedTypeMirror type = f.getAnnotatedType(node.getExpression());
        assert type instanceof AnnotatedArrayType;
        return ((AnnotatedArrayType)type).getComponentType();
    } finally {
        f.visitorState.setAssignmentContext(preAssCtxt);
    }
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
@Override
public Tree visitArrayAccess(ArrayAccessTree tree, Void p) {
    ArrayAccessTree n = make.ArrayAccess(tree.getExpression(), tree.getIndex());
    model.setType(n, model.getType(tree));
    comments.copyComments(tree, n);
    model.setPos(n, model.getPos(tree));
    return n;
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
public Boolean visitArrayAccess(ArrayAccessTree node, TreePath p) {
    if (p == null)
        return super.visitArrayAccess(node, p);

    ArrayAccessTree t = (ArrayAccessTree) p.getLeaf();

    if (!scan(node.getExpression(), t.getExpression(), p))
        return false;

    return scan(node.getIndex(), t.getIndex(), p);
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
@Override
public Void visitArrayAccess(ArrayAccessTree tree, EnumSet<UseTypes> d) {
    scan(tree.getExpression(), EnumSet.of(UseTypes.READ));
    scan(tree.getIndex(), EnumSet.of(UseTypes.READ));
    
    return null;
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
@Override
public Void visitArrayAccess(ArrayAccessTree tree, List<Node> d) {
    List<Node> below = new ArrayList<Node>();
    
    addCorrespondingType(below);
    addCorrespondingComments(below);
    super.visitArrayAccess(tree, below);
    
    d.add(new TreeNode(info, getCurrentPath(), below));
    return null;
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
@TriggerPattern(value="for (int $index = 0; $index < $arr.length; $index++) $statement;", [email protected](variable="$arr", type="Object[]"))
public static ErrorDescription forIndexedArray(final HintContext ctx) {
    AccessAndVarVisitor v = new AccessAndVarVisitor(ctx) {
        @Override public Void visitArrayAccess(ArrayAccessTree node, Void p) {
        TreePath path = getCurrentPath();
            if (MatcherUtilities.matches(ctx, path, "$arr[$index]")) { // NOI18N
                if (path.getParentPath() != null) {
                    if (   path.getParentPath().getLeaf().getKind() == Kind.ASSIGNMENT
                        && ((AssignmentTree) path.getParentPath().getLeaf()).getVariable() == node) {
                        unsuitable();
                    }
                    if (CompoundAssignmentTree.class.isAssignableFrom(path.getParentPath().getLeaf().getKind().asInterface())
                        && ((CompoundAssignmentTree) path.getParentPath().getLeaf()).getVariable() == node) {
                        unsuitable();
                    }
                }
                toReplace.add(path);
                return null;
            }
            return super.visitArrayAccess(node, p);
        }
    };
    v.scan(ctx.getVariables().get("$statement"), null); // NOI18N
    if (v.unsuitable) return null;
    
    return ErrorDescriptionFactory.forName(ctx, ctx.getPath(), Bundle.ERR_IteratorToForArray(), 
            new ReplaceIndexedForEachLoop(ctx.getInfo(), ctx.getPath(), ctx.getVariables().get("$arr"), 
            v.toReplace, v.definedVariables).toEditorFix());
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
public Boolean visitArrayAccess(ArrayAccessTree node, ConstructorData p) {
    boolean lv = lValueDereference;
    // even the array reference is just read from. There's no support to track array-item lvalues.
    this.lValueDereference = false;
    scan(node.getExpression(), p);
    scan(node.getIndex(), p);
    this.lValueDereference = lv;
    return null;
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
@Override
protected void performRewrite(TransformationContext ctx) throws Exception {
    ArrayAccessTree aa = (ArrayAccessTree) ctx.getPath().getLeaf();
    TreeMaker make = ctx.getWorkingCopy().getTreeMaker();
    
    if (assignment) {
        AssignmentTree at = (AssignmentTree) ctx.getPath().getParentPath().getLeaf();
        ctx.getWorkingCopy().rewrite(at, make.MethodInvocation(Collections.<ExpressionTree>emptyList(), make.MemberSelect(aa.getExpression(), map ? " put" : "set"), Arrays.asList(aa.getIndex(), at.getExpression())));
    } else {
        ctx.getWorkingCopy().rewrite(aa, make.MethodInvocation(Collections.<ExpressionTree>emptyList(), make.MemberSelect(aa.getExpression(), "get"), Collections.singletonList(aa.getIndex())));
    }
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
/**
 * Index in array access must be int
 */
@Override
public List<? extends TypeMirror> visitArrayAccess(ArrayAccessTree node, Object p) {
    if (theExpression == null) {
        return null;
    }
    // for now we do not guess array type, just the indexes.
    if (theExpression == node.getExpression()) {
        return null;
    }
    return Collections.singletonList(info.getTypes().getPrimitiveType(TypeKind.INT));
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
private Element getElement(Tree tree) {
    TreePath expPath = TreePath.getPath(cut, tree);
    Element e = trees.getElement(expPath);
    if (e == null) {
        if (tree instanceof ParenthesizedTree) {
            e = getElement(((ParenthesizedTree) tree).getExpression());
            //if (e == null) {
            //    System.err.println("Have null element for "+tree);
            //}
            //System.err.println("\nHAVE "+e.asType().toString()+" for ParenthesizedTree "+tree);
        }
        else if (tree instanceof TypeCastTree) {
            e = getElement(((TypeCastTree) tree).getType());
            //if (e == null) {
            //    System.err.println("Have null element for "+tree);
            //}
            //System.err.println("\nHAVE "+e.asType().toString()+" for TypeCastTree "+tree);
        }
        else if (tree instanceof AssignmentTree) {
            e = getElement(((AssignmentTree) tree).getVariable());
        }
        else if (tree instanceof ArrayAccessTree) {
            e = getElement(((ArrayAccessTree) tree).getExpression());
            if (e != null) {
                TypeMirror tm = e.asType();
                if (tm.getKind() == TypeKind.ARRAY) {
                    tm = ((ArrayType) tm).getComponentType();
                    e = types.asElement(tm);
                }
            }
            //System.err.println("ArrayAccessTree = "+((ArrayAccessTree) tree).getExpression()+", element = "+getElement(((ArrayAccessTree) tree).getExpression())+", type = "+getElement(((ArrayAccessTree) tree).getExpression()).asType());
        }
    }
    return e;
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
@Override
public Description matchArrayAccess(ArrayAccessTree tree, VisitorState state) {
  if (!matchWithinClass) {
    return Description.NO_MATCH;
  }
  return matchDereference(tree.getExpression(), tree, state);
}
 

import com.sun.source.tree.ArrayAccessTree; //导入依赖的package包/类
/**
 * Returns the base expression of an erray access, e.g. given {@code foo[0][0]} returns {@code
 * foo}.
 */
private ExpressionTree getArrayBase(ExpressionTree node) {
    while (node instanceof ArrayAccessTree) {
        node = ((ArrayAccessTree) node).getExpression();
    }
    return node;
}