import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
private void locateNestedTypes(Type type, TypeAnnotationPosition p) {
    // The number of "steps" to get from the full type to the
    // left-most outer type.
    ListBuffer<TypePathEntry> depth = new ListBuffer<>();

    Type encl = type.getEnclosingType();
    while (encl != null &&
            encl.getKind() != TypeKind.NONE &&
            encl.getKind() != TypeKind.ERROR) {
        depth = depth.append(TypePathEntry.INNER_TYPE);
        encl = encl.getEnclosingType();
    }
    if (depth.nonEmpty()) {
        p.location = p.location.prependList(depth.toList());
    }
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
private void printInnerTypes(String indentation, ATypeElement e) {
  for (Map. Entry<InnerTypeLocation,
          ATypeElement> ite : e.innerTypes.entrySet()) {
      InnerTypeLocation loc = ite.getKey();
      AElement it = ite.getValue();
      pw.print(indentation + "inner-type");
      char sep = ' ';
      for (TypePathEntry l : loc.location) {
          pw.print(sep);
          pw.print(typePathEntryToString(l));
          sep = ',';
      }
      pw.print(':');
      printAnnotations(it);
      pw.println();
  }
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
/**
 * Constructs a new <code> SafeTypeAnnotationVisitor </code> that
 *  delegates all calls to the given visitor.
 *
 * @param xav the visitor to delegate all method calls to
 */
public SafeTypeAnnotationVisitor(TypeAnnotationVisitor xav) {
  this.xav = xav;
  // Start most of these with a capacity of one, since for legal annotations
  // they should not contain more than one element.
  xIndexArgs = new ArrayList<Integer>(1);
  xLengthArgs = new ArrayList<Integer>(1);
  xLocationArgs = new ArrayList<TypePathEntry>();
  xLocationLengthArgs = new ArrayList<Integer>(1);
  xOffsetArgs = new ArrayList<Integer>(1);
  xStartPcArgs = new ArrayList<Integer>(1);
  xTargetTypeArgs = new ArrayList<Integer>(1);
  xParamIndexArgs = new ArrayList<Integer>(1);
  xBoundIndexArgs = new ArrayList<Integer>(1);
  xTypeIndexArgs = new ArrayList<Integer>(1);
  xNameAndArgsCount = 0;
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
private static AnnotatedTypeMirror getLocationTypeATM(AnnotatedTypeMirror type, List<TypePathEntry> location) {
    if (debug) {
        System.out.println("getLocationTypeATM type: " + type + " location: " + location);
    }
    if (location.isEmpty()) {
        return type;
    } else if (type.getKind() == TypeKind.DECLARED) {
        return getLocationTypeADT((AnnotatedDeclaredType)type, location);
    } else if (type.getKind() == TypeKind.WILDCARD) {
        return getLocationTypeAWT((AnnotatedWildcardType)type, location);
    } else if (type.getKind() == TypeKind.ARRAY) {
        return getLocationTypeAAT((AnnotatedArrayType)type, location);
    } else {
        ErrorReporter.errorAbort("TypeFromElement.getLocationTypeATM: only declared types and arrays can have annotations with location; " +
                "found type: " + type + " location: " + location);
        return null; // dead code
    }
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
private static AnnotatedTypeMirror getLocationTypeAWT(AnnotatedWildcardType type,  List<TypePathEntry> location) {
    if (debug) {
        System.out.println("getLocationTypeAWT type: " + type + " location: " + location);
    }
    if (location.isEmpty()) {
        return type;
    } else if (location.get(0).tag.equals(TypePathEntryKind.WILDCARD)) {
        List<AnnotatedTypeMirror> bounds = getBounds(type);
        // TODO: what should happen if bounds is empty or has more than one entry?
        return getLocationTypeATM(bounds.get(0), tail(location));
    } else {
        if (strict) {
            System.out.println("TypeFromElement.getLocationTypeAWT: type not handled.\n" +
                    "    Found location: " + location + " for type: " + type);
        }
        return type;
    }
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
private ListBuffer<TypePathEntry>
    locateNestedTypes(Type type,
                      ListBuffer<TypePathEntry> depth) {
    Type encl = type.getEnclosingType();
    while (encl != null &&
            encl.getKind() != TypeKind.NONE &&
            encl.getKind() != TypeKind.ERROR) {
        depth = depth.prepend(TypePathEntry.INNER_TYPE);
        encl = encl.getEnclosingType();
    }
    return depth;
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
/**
 * Determines if the given list holds only {@link TypePathEntry}s with the tag
 * {@link TypePathEntryKind#ARRAY}.
 *
 * @param location the list to check
 * @return {@code true} if the list only contains
 *         {@link TypePathEntryKind#ARRAY}, {@code false} otherwise.
 */
private boolean containsOnlyArray(List<TypePathEntry> location) {
  for (TypePathEntry tpe : location) {
    if (tpe.tag != TypePathEntryKind.ARRAY) {
      return false;
    }
  }
  return true;
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
/**
 * Find an {@link ASTRecord} for the tree corresponding to a nested
 * type of the type (use) to which the given record corresponds.
 *
 * @param rec record of (outer) type AST to be annotated
 * @param loc inner type path
 * @return record that locates the (nested) type in the source
 */
private ASTRecord extendToInnerType(ASTRecord rec, List<TypePathEntry> loc) {
  ASTRecord r = rec;
  Iterator<TypePathEntry> iter = loc.iterator();
  int depth = 0;

  while (iter.hasNext()) {
    TypePathEntry tpe = iter.next();
    switch (tpe.tag) {
    case ARRAY:
      while (depth-- > 0) {
        r = r.extend(Tree.Kind.MEMBER_SELECT, ASTPath.EXPRESSION);
      }
      r = r.extend(Tree.Kind.ARRAY_TYPE, ASTPath.TYPE);
      break;
    case INNER_TYPE:
      ++depth;
      break;
    case TYPE_ARGUMENT:
      depth = 0;
      r = r.extend(Tree.Kind.PARAMETERIZED_TYPE, ASTPath.TYPE_ARGUMENT,
          tpe.arg);
      break;
    case WILDCARD:
      while (depth-- > 0) {
        r = r.extend(Tree.Kind.MEMBER_SELECT, ASTPath.EXPRESSION);
      }
      r = r.extend(Tree.Kind.UNBOUNDED_WILDCARD, ASTPath.BOUND);
      break;
    default:
      throw new RuntimeException();
    }
  }
  while (depth-- > 0) {
    r = r.extend(Tree.Kind.MEMBER_SELECT, ASTPath.EXPRESSION);
  }
  return r;
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
public void visitXLocation(TypePathEntry location) {
    buf.setLength(0);
    buf.append("xav").append(id).append(".visitXLocation(");
    buf.append(location.toString());
    buf.append(");\n");
    text.add(buf.toString());
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
public void visitXLocationLength(int location_length) {
  this.xlocation_length = location_length;
  this.xlocations = new TypePathEntry[this.xlocation_length];
  this.xlocations_index = 0;
  if(xav != null) {
    xav.visitXLocationLength(location_length);
  }
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
public void visitXLocation(TypePathEntry location) {
  this.xlocations[xlocations_index] = location;
  this.xlocations_index++;
  if(xav != null) {
    xav.visitXLocation(location);
  }
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
private static ATypeElement getInnerType(ATypeElement te,
                                         List<TypePathEntry> ls) {
    if (ls.isEmpty()) {
        return te;
    } else {
        return te.innerTypes.vivify(new InnerTypeLocation(ls));
    }
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
private void printAmbElementAndInnerTypes(String indentation,
        String desc,
        AElement e) {
    printElement(indentation, desc, e);
    if (e.type.tlAnnotationsHere.isEmpty() && e.type.innerTypes.isEmpty()) {
        return;
    }
    printElement(indentation + INDENT, "type", e.type);
    for (Map. Entry<InnerTypeLocation, ATypeElement> ite
            : e.type.innerTypes.entrySet()) {
        InnerTypeLocation loc = ite.getKey();
        AElement it = ite.getValue();
        pw.print(indentation + INDENT + INDENT + "inner-type");
        boolean first = true;
        for (TypePathEntry l : loc.location) {
            if (first) {
                pw.print(' ');
            } else {
                pw.print(',');
            }
            pw.print(typePathEntryToString(l));
            first = false;
        }
        pw.print(':');
        printAnnotations(it);
        pw.println();
    }
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
/**
 * Constructs a new AnnotationScene reader with the given description and
 * visibility.  Calling visitEnd() will ensure that this writes out the
 * annotation it visits into aElement.
 * @param desc JVML format for the field being read, or ClassAnnotationSceneReader.dummyDesc
 */
public AnnotationSceneReader(String desc, boolean visible, AElement aElement) {
  if (trace) { System.out.printf("AnnotationSceneReader(%s, %s, %s)%n", desc, visible, aElement); }
  this.visible = visible;
  this.aElement = aElement;
  if (desc != dummyDesc) {    // interned
    AnnotationDef ad = getAnnotationDef(desc);

    AnnotationBuilder ab = AnnotationFactory.saf.beginAnnotation(ad);
    if (ab == null) {
      throw new IllegalArgumentException("bad description: " + desc);
    } else {
      this.annotationBuilder = ab;
    }
  }

  // For legal annotations, and except for xLocationsArgs, these should
  //  contain at most one element.
  this.xTargetTypeArgs = new ArrayList<Integer>(1);
  this.xIndexArgs = new ArrayList<Integer>(1);
  this.xLengthArgs = new ArrayList<Integer>(1);
  this.xLocationLengthArgs = new ArrayList<Integer>(1);
  this.xOffsetArgs = new ArrayList<Integer>(1);
  this.xStartPcArgs = new ArrayList<Integer>(1);
  this.xLocationsArgs = new ArrayList<TypePathEntry>();
  this.xParamIndexArgs = new ArrayList<Integer>(1);
  this.xBoundIndexArgs = new ArrayList<Integer>(1);
  this.xExceptionIndexArgs = new ArrayList<Integer>(1);
  this.xTypeIndexArgs = new ArrayList<Integer>(1);
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
/**
 * Have xav visit the location length  and all locations in loc.
 */
private void visitLocations(TypeAnnotationVisitor xav, InnerTypeLocation loc) {
  List<TypePathEntry> location = loc.location;
  xav.visitXLocationLength(location.size());
  for (TypePathEntry l : location) {
    xav.visitXLocation(l);
  }
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
public AnnotationRecorder(String description) {
  this.description = description;
  fieldArgsName = new ArrayList<String>();
  fieldArgsValue = new ArrayList<Object>();

  enumArgsName = new ArrayList<String>();
  enumArgsDesc = new ArrayList<String>();
  enumArgsValue = new ArrayList<String>();

  innerAnnotationArgsName = new ArrayList<String>();
  innerAnnotationArgsDesc = new ArrayList<String>();
  innerAnnotationMap = new HashMap<String, AnnotationRecorder>();

  arrayArgs = new ArrayList<String>();
  arrayMap = new HashMap<String, AnnotationRecorder>();

  xIndexArgs = new ArrayList<Integer>();
  xLengthArgs = new ArrayList<Integer>();
  xLocationArgs = new ArrayList<TypePathEntry>();
  xLocationLengthArgs = new ArrayList<Integer>();
  xOffsetArgs = new ArrayList<Integer>();
  xStartPcArgs = new ArrayList<Integer>();
  xTargetTypeArgs = new ArrayList<Integer>();
  xParamIndexArgs = new ArrayList<Integer>();
  xBoundIndexArgs = new ArrayList<Integer>();
  xExceptionIndexArgs = new ArrayList<Integer>();
  xTypeIndexArgs = new ArrayList<Integer>();
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
@Override
public List<TypeCompound> visitArray(AnnotatedArrayType type,
        TypeAnnotationPosition tapos) {
    List<Attribute.TypeCompound> res;
    res = directAnnotations(type, tapos);

    TypeAnnotationPosition newpos = TypeAnnotationUtils.copyTAPosition(processingEnv.getSourceVersion(), tapos);
    newpos.location = tapos.location.append(TypePathEntry.ARRAY);

    return reduce(super.visitArray(type, newpos), res);
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
private static void annotate(AnnotatedTypeMirror type, List<TypePathEntry> location, List<? extends AnnotationMirror> annotations) {
    if (debug) {
        System.out.printf("TypeFromElement.annotate: type: %s, location: %s, annos: %s%n", type, location, annotations);
    }
    AnnotatedTypeMirror inner = getLocationTypeATM(type, location);
    inner.addAnnotations(annotations);
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
private static int countInner(List<TypePathEntry> location) {
    int cnt = 0;
    while (!location.isEmpty() &&
            location.get(0).tag.equals(TypePathEntryKind.INNER_TYPE)) {
        ++cnt;
        location = tail(location);
    }
    return cnt;
}
 

import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; //导入依赖的package包/类
private static AnnotatedTypeMirror getLocationTypeAAT(AnnotatedArrayType type, List<TypePathEntry> location) {
    if (debug) {
        System.out.println("getLocationTypeAAT type: " + type + " location: " + location);
    }
    if (location.size() >= 1 &&
            location.get(0).tag.equals(TypePathEntryKind.ARRAY)) {
        AnnotatedTypeMirror comptype = type.getComponentType();
        return getLocationTypeATM(comptype, tail(location));
    } else {
        ErrorReporter.errorAbort("TypeFromElement.annotateAAT: " +
                "invalid location " + location + " for type: " + type);
        return null; // dead code
    }
}