Java ArrayTypeTree类代码示例

import com.sun.source.tree.ArrayTypeTree; //导入依赖的package包/类
public void moveToEnd(Tree t) {
    if (t == null) {
        return ;
    }

    long end = sourcePositions.getEndPosition(info.getCompilationUnit(), t);

    if (end == (-1))
        return ;

    if (t.getKind() == Kind.ARRAY_TYPE) {
        moveToEnd(((ArrayTypeTree) t).getType());
        return ;
    }
    moveToOffset(end);
}
 

import com.sun.source.tree.ArrayTypeTree; //导入依赖的package包/类
@Override
public Mirror visitArrayType(ArrayTypeTree arg0, EvaluationContext evaluationContext) {
    Mirror arrayType = arg0.getType().accept(this, evaluationContext);
    if (!(arrayType instanceof Type)) {
        return arrayType;
    }
    Type type = (Type) arrayType;
    String arrayClassName = type.name()+"[]";
    ReferenceType aType = getOrLoadClass(type.virtualMachine(), arrayClassName, evaluationContext);
    if (aType != null) {
        return aType;
    } else {
        Assert.error(arg0, "unknownType", arrayClassName);
        return null;
    }
}
 

import com.sun.source.tree.ArrayTypeTree; //导入依赖的package包/类
/**
 * Accumulates a flattened list of array dimensions specifiers with type annotations, and returns
 * the base type.
 * <p>
 * <p>Given {@code int @A @B [][] @C []}, adds {@code [[@A, @B], [@C]]} to dims and returns {@code
 * int}.
 */
private static Tree extractDims(Deque<List<AnnotationTree>> dims, Tree node) {
    switch (node.getKind()) {
        case ARRAY_TYPE:
            return extractDims(dims, ((ArrayTypeTree) node).getType());
        // TODO: 22-Jul-17 missing type
       /* case ANNOTATED_TYPE:
            AnnotatedTypeTree annotatedTypeTree = (AnnotatedTypeTree) node;
            if (annotatedTypeTree.getUnderlyingType().getKind() != Tree.Kind.ARRAY_TYPE) {
                return node;
            }
            node = extractDims(dims, annotatedTypeTree.getUnderlyingType());
            dims.addFirst(ImmutableList.<AnnotationTree>copyOf(annotatedTypeTree.getAnnotations()));
            return node;*/
        default:
            return node;
    }
}
 

import com.sun.source.tree.ArrayTypeTree; //导入依赖的package包/类
@Override
public Pair<ASTRecord, Integer> visitArrayType(ArrayTypeTree node, Insertion ins) {
  dbug.debug("TypePositionFinder.visitArrayType(%s)%n", node);
  JCArrayTypeTree att = (JCArrayTypeTree) node;
  dbug.debug("TypePositionFinder.visitArrayType(%s) preferred = %s%n",
      node, att.getPreferredPosition());
  // If the code has a type like "String[][][]", then this gets called
  // three times:  for String[][][], String[][], and String[]
  // respectively.  For each of the three, call String[][][] "largest".
  ArrayTypeTree largest = largestContainingArray(node);
  int largestLevels = arrayLevels(largest);
  int levels = arrayLevels(node);
  int start = arrayContentType(att).getPreferredPosition() + 1;
  int end = att.getEndPosition(tree.endPositions);
  int pos = arrayInsertPos(start, end);

  dbug.debug("  levels=%d largestLevels=%d%n", levels, largestLevels);
  for (int i=levels; i<largestLevels; i++) {
    pos = getFirstInstanceAfter('[', pos+1);
    dbug.debug("  pos %d at i=%d%n", pos, i);
  }
  return Pair.of(astRecord(node), pos);
}
 

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

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

    ArrayTypeTree at = (ArrayTypeTree) p.getLeaf();

    return scan(node.getType(), at.getType(), p);
}
 

import com.sun.source.tree.ArrayTypeTree; //导入依赖的package包/类
@Override
public Void visitArrayType(ArrayTypeTree node, EnumSet<UseTypes> p) {
    if (node.getType() != null) {
        handlePossibleIdentifier(new TreePath(getCurrentPath(), node.getType()), EnumSet.of(UseTypes.CLASS_USE));
    }
    return super.visitArrayType(node, p);
}
 

import com.sun.source.tree.ArrayTypeTree; //导入依赖的package包/类
private static Tree normalizeLastLeftTree(Tree lastLeft) {
    while (lastLeft != null && lastLeft.getKind() == Kind.ARRAY_TYPE) {
        lastLeft = ((ArrayTypeTree) lastLeft).getType();
    }
    
    return lastLeft;
}
 

import com.sun.source.tree.ArrayTypeTree; //导入依赖的package包/类
private ReplaceConstructorWithBuilderUI(TreePathHandle constructor, CompilationInfo info) {
    this.refactoring = new ReplaceConstructorWithBuilderRefactoring(constructor);
    ExecutableElement contructorElement = (ExecutableElement) constructor.resolveElement(info);
    this.name = contructorElement.getSimpleName().toString();
    MethodTree constTree = (MethodTree) constructor.resolve(info).getLeaf();
    paramaterNames = new ArrayList<String>();
    parameterTypes = new ArrayList<String>();
    parameterTypeVars = new ArrayList<Boolean>();
    boolean varargs = contructorElement.isVarArgs();
    List<? extends VariableElement> parameterElements = contructorElement.getParameters();
    List<? extends VariableTree> parameters = constTree.getParameters();
    for (int i = 0; i < parameters.size(); i++) {
        VariableTree var = parameters.get(i);
        paramaterNames.add(var.getName().toString());
        String type = contructorElement.getParameters().get(i).asType().toString();
        if(varargs && i+1 == parameters.size()) {
            if(var.getType().getKind() == Tree.Kind.ARRAY_TYPE) {
                ArrayTypeTree att = (ArrayTypeTree) var.getType();
                type = att.getType().toString();
                type += "..."; //NOI18N
            }
        }
        parameterTypes.add(type);
        parameterTypeVars.add(parameterElements.get(i).asType().getKind() == TypeKind.TYPEVAR);
    }
    TypeElement typeEl = (TypeElement) contructorElement.getEnclosingElement();
    if(typeEl.getNestingKind() != NestingKind.TOP_LEVEL) {
        PackageElement packageOf = info.getElements().getPackageOf(typeEl);
        builderFQN = packageOf.toString() + "." + typeEl.getSimpleName().toString();
    } else {
        builderFQN = typeEl.getQualifiedName().toString();
    }
    buildMethodName = "create" + typeEl.getSimpleName();
}
 

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

import com.sun.source.tree.ArrayTypeTree; //导入依赖的package包/类
private ExpressionTree transformInitializer(ExpressionTree initializer, Tree type, TreeMaker make) {
    if(initializer.getKind() == Tree.Kind.NEW_ARRAY) {
        NewArrayTree nat = (NewArrayTree) initializer;
        if(nat.getType() == null) {
            if(type.getKind() == Tree.Kind.ARRAY_TYPE) {
                ArrayTypeTree arrayTypeTree = (ArrayTypeTree) type;
                type = arrayTypeTree.getType();
            }
            return make.NewArray(type, nat.getDimensions(), nat.getInitializers());
        }
    }
    return initializer;
}
 

import com.sun.source.tree.ArrayTypeTree; //导入依赖的package包/类
private String createType(VariableTree tree) {
    Tree returnType = tree.getType();

    if (returnType instanceof ParameterizedTypeTree || returnType instanceof ArrayTypeTree) {
        return returnType.toString();
    } else {
        return TreeUtils.getTokenFromIdentifierTree(returnType).getImage();
    }
}
 

import com.sun.source.tree.ArrayTypeTree; //导入依赖的package包/类
private String createDataType(Tree returnType) {
    if (returnType instanceof ParameterizedTypeTree || returnType instanceof ArrayTypeTree) {
        return returnType.toString();
    } else {
        return TreeUtils.getTokenFromIdentifierTree(returnType).getImage();
    }
}
 

import com.sun.source.tree.ArrayTypeTree; //导入依赖的package包/类
private int arrayLevels(Tree node) {
  int result = 0;
  while (node.getKind() == Tree.Kind.ARRAY_TYPE) {
    result++;
    node = ((ArrayTypeTree) node).getType();
  }
  return result;
}
 

import com.sun.source.tree.ArrayTypeTree; //导入依赖的package包/类
private boolean checkTypePath(int i, Tree typeTree) {
        try {
loop:       while (typeTree != null && i < astPath.size()) {
                ASTPath.ASTEntry entry = astPath.get(i);
                Tree.Kind kind = entry.getTreeKind();
                switch (kind) {
                case ANNOTATED_TYPE:
                    typeTree = ((AnnotatedTypeTree) typeTree)
                        .getUnderlyingType();
                    continue;
                case ARRAY_TYPE:
                    typeTree = ((ArrayTypeTree) typeTree).getType();
                    break;
                case MEMBER_SELECT:
                    typeTree = ((MemberSelectTree) typeTree).getExpression();
                    break;
                case PARAMETERIZED_TYPE:
                    if (entry.childSelectorIs(ASTPath.TYPE_ARGUMENT)) {
                        int arg = entry.getArgument();
                        typeTree = ((ParameterizedTypeTree) typeTree)
                                .getTypeArguments().get(arg);
                    } else {  // TYPE
                        typeTree = ((ParameterizedTypeTree) typeTree).getType();
                    }
                    break;
                default:
                    if (isWildcard(kind)) {
                        return ++i == astPath.size();  // ???
                    }
                    break loop;
                }
                ++i;
            }
        } catch (RuntimeException ex) {}
        return false;
    }