Java ClassType.getEnclosingType方法代码示例

import com.sun.tools.javac.code.Type.ClassType; //导入方法依赖的package包/类
@Override
public String visitClassType(ClassType t, Locale locale) {
    StringBuffer buf = new StringBuffer();
    if (t.getEnclosingType().tag == CLASS && t.tsym.owner.kind == Kinds.TYP) {
        buf.append(visit(t.getEnclosingType(), locale));
        buf.append(".");
        buf.append(className(t, false, locale));
    } else {
        buf.append(className(t, true, locale));
    }
    if (t.getTypeArguments().nonEmpty()) {
        buf.append('<');
        buf.append(visitTypes(t.getTypeArguments(), locale));
        buf.append(">");
    }
    return buf.toString();
}
 

import com.sun.tools.javac.code.Type.ClassType; //导入方法依赖的package包/类
static String parameterizedTypeToString(DocEnv env, ClassType cl,
                                        boolean full) {
    if (env.legacyDoclet) {
        return TypeMaker.getTypeName(cl, full);
    }
    StringBuilder s = new StringBuilder();
    if (!(cl.getEnclosingType().hasTag(CLASS))) {               // if not an inner class...
        s.append(TypeMaker.getTypeName(cl, full));
    } else {
        ClassType encl = (ClassType)cl.getEnclosingType();
        s.append(parameterizedTypeToString(env, encl, full))
         .append('.')
         .append(cl.tsym.name.toString());
    }
    s.append(TypeMaker.typeArgumentsString(env, cl, full));
    return s.toString();
}
 

import com.sun.tools.javac.code.Type.ClassType; //导入方法依赖的package包/类
static String parameterizedTypeToString(DocEnv env, ClassType cl,
                                        boolean full) {
    if (env.legacyDoclet) {
        return TypeMaker.getTypeName(cl, full);
    }
    StringBuffer s = new StringBuffer();
    if (cl.getEnclosingType().tag != CLASS) {               // if not an inner class...
        s.append(TypeMaker.getTypeName(cl, full));
    } else {
        ClassType encl = (ClassType)cl.getEnclosingType();
        s.append(parameterizedTypeToString(env, encl, full))
         .append('.')
         .append(cl.tsym.name.toString());
    }
    s.append(TypeMaker.typeArgumentsString(env, cl, full));
    return s.toString();
}
 

import com.sun.tools.javac.code.Type.ClassType; //导入方法依赖的package包/类
/** Returns an enclosing instance for the specified type if it is thread-safe. */
public Type mutableEnclosingInstance(Optional<ClassTree> tree, ClassType type) {
  if (tree.isPresent()
      && !CanBeStaticAnalyzer.referencesOuter(
          tree.get(), ASTHelpers.getSymbol(tree.get()), state)) {
    return null;
  }
  Type enclosing = type.getEnclosingType();
  while (!Type.noType.equals(enclosing)) {
    if (getMarkerOrAcceptedAnnotation(enclosing.tsym, state) == null
        && isThreadSafeType(
                /* allowContainerTypeParameters= */ false,
                /* containerTypeParameters= */ ImmutableSet.of(),
                enclosing)
            .isPresent()) {
      return enclosing;
    }
    enclosing = enclosing.getEnclosingType();
  }
  return null;
}
 

import com.sun.tools.javac.code.Type.ClassType; //导入方法依赖的package包/类
static String parameterizedTypeToString(DocEnv env, ClassType cl,
                                        boolean full) {
    if (env.legacyDoclet) {
        return TypeMaker.getTypeName(cl, full);
    }
    StringBuilder s = new StringBuilder();
    if (cl.getEnclosingType().tag != CLASS) {               // if not an inner class...
        s.append(TypeMaker.getTypeName(cl, full));
    } else {
        ClassType encl = (ClassType)cl.getEnclosingType();
        s.append(parameterizedTypeToString(env, encl, full))
         .append('.')
         .append(cl.tsym.name.toString());
    }
    s.append(TypeMaker.typeArgumentsString(env, cl, full));
    return s.toString();
}
 

import com.sun.tools.javac.code.Type.ClassType; //导入方法依赖的package包/类
@Override
public Type visitClassType(ClassType t, Boolean upward) {
    if (upward && !t.isCompound() && t.tsym.name.isEmpty()) {
        //lift anonymous class type to first supertype (class or interface)
        return types.directSupertypes(t).last();
    } else if (t.isCompound()) {
        List<Type> components = types.directSupertypes(t);
        List<Type> components1 = components.map(c -> c.map(this, upward));
        if (components == components1) return t;
        else return types.makeIntersectionType(components1);
    } else {
        Type outer = t.getEnclosingType();
        Type outer1 = visit(outer, upward);
        List<Type> typarams = t.getTypeArguments();
        List<Type> typarams1 = typarams.map(ta -> mapTypeArgument(ta, upward));
        if (typarams1.stream().anyMatch(ta -> ta.hasTag(BOT))) {
            //not defined
            return syms.botType;
        }
        if (outer1 == outer && typarams1 == typarams) return t;
        else return new ClassType(outer1, typarams1, t.tsym, t.getMetadata()) {
            @Override
            protected boolean needsStripping() {
                return true;
            }
        };
    }
}