Java NoType类代码示例

import javax.lang.model.type.NoType; //导入依赖的package包/类
private Type eraseBound( Type t, Type bound )
{
  if( bound == null || bound instanceof NoType )
  {
    return bound;
  }

  Type erasedBound;
  if( bound.contains( t ) )
  {
    erasedBound = visit( _types.erasure( bound ) );
  }
  else
  {
    erasedBound = visit( bound );
  }
  return erasedBound;
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
private SrcType makeNestedType( Type type )
{
  String fqn = type.toString();
  Type enclosingType = type.getEnclosingType();
  SrcType srcType;
  if( enclosingType != null && !(enclosingType instanceof NoType) && fqn.length() > enclosingType.toString().length() )
  {
    String simpleName = fqn.substring( enclosingType.toString().length() + 1 );
    srcType = new SrcType( simpleName );
    srcType.setEnclosingType( makeNestedType( enclosingType ) );
  }
  else
  {
    srcType = new SrcType( fqn );
  }
  return srcType;
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
private SrcType makeTypeVarType( Symbol.TypeVariableSymbol typeVar )
{
  StringBuilder sb = new StringBuilder( typeVar.type.toString() );
  Type lowerBound = typeVar.type.getLowerBound();
  if( lowerBound != null && !(lowerBound instanceof NullType) )
  {
    sb.append( " super " ).append( lowerBound.toString() );
  }
  else
  {
    Type upperBound = typeVar.type.getUpperBound();
    if( upperBound != null && !(upperBound instanceof NoType) && !upperBound.toString().equals( Object.class.getName() ) )
    {
      sb.append( " extends " ).append( upperBound.toString() );
    }
  }
  return new SrcType( sb.toString() );
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
public TypeRef apply(TypeMirror item) {
    if (item instanceof NoType) {
        return new VoidRef();
    }

    Element element = CodegenContext.getContext().getTypes().asElement(item);
    TypeDef known = element != null ? CodegenContext.getContext().getDefinitionRepository().getDefinition(element.toString()) : null;

    if (known == null && element instanceof TypeElement) {
        known = TYPEDEF.apply((TypeElement) element);
    }
    TypeRef typeRef = item.accept(new TypeRefTypeVisitor(), 0);
    if (typeRef instanceof ClassRef && known != null) {
        return new ClassRefBuilder((ClassRef) typeRef).withDefinition(known).build();
    }
    return typeRef;
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
/**
 * Checks if the given {@link Element} is, implements or extends the given target type.
 * 
 * @param type the element to analyze
 * @param targetType the type to check
 * @return <code>true</code> if the given {@link Element} corresponds to a type that implements
 *         {@link List}, <code>false</code> otherwise.
 */
public static boolean isAssignable(final DeclaredType type, final Class<?> targetType) {
  if (type instanceof NoType) {
    return false;
  }
  if (type.asElement().toString().equals(targetType.getName())) {
    return true;
  }
  final TypeElement element = (TypeElement) type.asElement();
  final boolean implementation = element.getInterfaces().stream()
      .filter(interfaceMirror -> interfaceMirror.getKind() == TypeKind.DECLARED)
      .map(interfaceMirror -> (DeclaredType) interfaceMirror)
      .map(declaredInterface -> declaredInterface.asElement())
      .anyMatch(declaredElement -> declaredElement.toString().equals(targetType.getName()));
  if (implementation) {
    return true;
  }
  if (element.getSuperclass().getKind() == TypeKind.DECLARED) {
    return isAssignable((DeclaredType)(element.getSuperclass()), targetType);
  } 
  return false;
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
/**
 * Check if the given Element extends a given type. A fully qualified name of another type
 * to check for must be given. Throws an IllegalArgumentException if Element is not an instance of
 * TypeElement. The method will recursively climb up the type hierarchy until it reaches either
 * the desired type or a root type.
 *
 * @param element   element to perform the check for
 * @param superType fully qualified name of a type
 * @return true if given element represents a type that extends another type with the given fully
 * qualified name
 * @throws java.lang.IllegalArgumentException if element is not an instance of TypeElement
 */
public static boolean checkIfExtends(Element element, String superType) {
    if (!(element instanceof TypeElement)) {
        throw new IllegalArgumentException("Can only check if TypeElement extends a certain superType");
    }

    TypeElement typeElement = (TypeElement) element;

    if (typeElement.getSuperclass() instanceof NoType) {
        return false;
    } else if (((DeclaredType) typeElement.getSuperclass()).asElement().toString().equals(superType)) {
        return true;
    } else {
        return checkIfExtends(((DeclaredType) typeElement.getSuperclass()).asElement(), superType);
    }
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
public static boolean instanceOf(Types types, TypeMirror type, String className) {
    //System.out.println("instanceOf : "+type.toString()+":"+className);
    
    String baseType = type.toString();
    if (type instanceof DeclaredType) {
        baseType = ((DeclaredType)type).asElement().toString();
    }
    //System.out.println("BaseType: "+baseType);
    
    if (baseType.equals(className)) {
        return true;
    }
    TypeElement elem = (TypeElement) types.asElement(type);
    for (TypeMirror i : elem.getInterfaces()) {
        if (instanceOf(types,i,className)) {
            return true;
        }
    }
    
    TypeMirror sup =  elem.getSuperclass();
    if (sup instanceof NoType) {
        return false;
    }
    return (instanceOf(types,sup,className));
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
@Test
public void testAsType() throws IOException {
  compile("class Foo { }");

  TypeElement fooElement = elements.getTypeElement("Foo");
  TypeMirror fooTypeMirror = fooElement.asType();

  assertEquals(TypeKind.DECLARED, fooTypeMirror.getKind());
  DeclaredType fooDeclaredType = (DeclaredType) fooTypeMirror;
  assertSame(fooElement, fooDeclaredType.asElement());
  assertEquals(0, fooDeclaredType.getTypeArguments().size());

  TypeMirror enclosingType = fooDeclaredType.getEnclosingType();
  assertEquals(TypeKind.NONE, enclosingType.getKind());
  assertTrue(enclosingType instanceof NoType);
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
@Test
public void testAsTypeGeneric() throws IOException {
  compile("class Foo<T> { }");

  TypeElement fooElement = elements.getTypeElement("Foo");
  TypeMirror fooTypeMirror = fooElement.asType();

  assertEquals(TypeKind.DECLARED, fooTypeMirror.getKind());
  DeclaredType fooDeclaredType = (DeclaredType) fooTypeMirror;
  assertSame(fooElement, fooDeclaredType.asElement());
  List<? extends TypeMirror> typeArguments = fooDeclaredType.getTypeArguments();
  assertEquals("T", ((TypeVariable) typeArguments.get(0)).asElement().getSimpleName().toString());
  assertEquals(1, typeArguments.size());

  TypeMirror enclosingType = fooDeclaredType.getEnclosingType();
  assertEquals(TypeKind.NONE, enclosingType.getKind());
  assertTrue(enclosingType instanceof NoType);
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
@Test
public void testGetDeclaredTypeTopLevelNoGenerics() throws IOException {
  compile("class Foo { }");

  TypeElement fooElement = elements.getTypeElement("Foo");
  TypeMirror fooTypeMirror = types.getDeclaredType(fooElement);

  assertEquals(TypeKind.DECLARED, fooTypeMirror.getKind());
  DeclaredType fooDeclaredType = (DeclaredType) fooTypeMirror;
  assertNotSame(fooElement.asType(), fooDeclaredType);
  assertSame(fooElement, fooDeclaredType.asElement());
  assertEquals(0, fooDeclaredType.getTypeArguments().size());

  TypeMirror enclosingType = fooDeclaredType.getEnclosingType();
  assertEquals(TypeKind.NONE, enclosingType.getKind());
  assertTrue(enclosingType instanceof NoType);
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
@Test
public void testGetDeclaredTypeTopLevelRawType() throws IOException {
  compile("class Foo<T> { }");

  TypeElement fooElement = elements.getTypeElement("Foo");
  TypeMirror fooTypeMirror = types.getDeclaredType(fooElement);

  assertEquals(TypeKind.DECLARED, fooTypeMirror.getKind());
  DeclaredType fooDeclaredType = (DeclaredType) fooTypeMirror;
  assertNotSame(fooElement.asType(), fooDeclaredType);
  assertSame(fooElement, fooDeclaredType.asElement());
  assertEquals(0, fooDeclaredType.getTypeArguments().size());

  TypeMirror enclosingType = fooDeclaredType.getEnclosingType();
  assertEquals(TypeKind.NONE, enclosingType.getKind());
  assertTrue(enclosingType instanceof NoType);
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
private Set<MethodSpec> getMethods(Types typeUtils) {
    Set<MethodSpec> methods = new HashSet<>();

    MethodSpec constructor = MethodSpec.constructorBuilder()
            .addModifiers(Modifier.PUBLIC)
            .addParameter(classTypeName, MEMBER_FIELD_NAME)
            .addStatement("this.$N = $N", MEMBER_FIELD_NAME, MEMBER_FIELD_NAME)
            .build();

    methods.add(constructor);

    Set<Element> allElements = new HashSet<>();
    allElements.addAll(element.getEnclosedElements());
    for (TypeMirror typeMirror : element.getInterfaces()) {
        allElements.addAll(typeUtils.asElement(typeMirror).getEnclosedElements());
    }

    for (Element e : allElements) {
        if (!(e instanceof ExecutableElement)) {
            continue;
        }
        ExecutableElement method = (ExecutableElement) e;
        String methodName = method.getSimpleName().toString();
        if ("<init>".equals(methodName)) { // skip constructors
            continue;
        }
        Set<Modifier> modifiers = new HashSet<>(method.getModifiers());
        if (modifiers.contains(Modifier.PRIVATE)
                || modifiers.contains(Modifier.STATIC)
                || modifiers.contains(Modifier.FINAL)) {
            continue;
        }
        modifiers.remove(Modifier.ABSTRACT);
        modifiers.add(Modifier.SYNCHRONIZED);

        MethodSpec.Builder spec = MethodSpec.methodBuilder(methodName)
                .addModifiers(modifiers);

        List<? extends TypeMirror> thrownTypes = method.getThrownTypes();
        for (TypeMirror throwable : thrownTypes) {
            spec = spec.addException(TypeName.get(throwable));
        }

        String arguments = "";
        List<? extends VariableElement> parameters = method.getParameters();
        for (VariableElement parameter : parameters) {
            arguments += parameter.getSimpleName().toString();
            if (parameters.indexOf(parameter) != parameters.size() - 1) {
                arguments += ", ";
            }
            spec.addParameter(ParameterSpec.get(parameter));
        }

        if (method.getReturnType() instanceof NoType) {
            spec = spec.addStatement("$N.$N($L)", MEMBER_FIELD_NAME, methodName, arguments);
        } else {
            spec = spec.addStatement("return $N.$N($L)", MEMBER_FIELD_NAME, methodName, arguments)
                    .returns(TypeName.get(method.getReturnType()));
        }

        methods.add(spec.build());
    }
    return methods;
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
private TypeElement getSuperClassForDataBinding(TypeElement te) {
    TypeMirror superclass = te.getSuperclass();
    String superName = superclass.toString();
    if(superclass instanceof NoType){
        //no super.
    }else if(superName.startsWith("java.") || superName.startsWith("android.")){
        // no super too.
    }else{
        TypeElement newTe = new FieldData.TypeCompat(mContext.getTypes(), superclass).getElementAsType();
        DataBindingInfo info = mInfoMap.get(superName);
        if(info == null){
            //-------------- handle cross modules ------------
            //by class annotation
            if(hasDataBindingClassAnnotation(newTe)){
                return newTe;
            }
            //by field annotation
            List<VariableElement> elements = ElementFilter.fieldsIn(newTe.getEnclosedElements());
            if(elements.size() > 0){
                for(VariableElement ve: elements){
                    if(hasDataBindingFieldAnnotation(ve)){
                        return newTe;
                    }
                }
            }
            //may super's N class is using data-binding
            return getSuperClassForDataBinding(newTe);
        }else{
            //found
            return newTe;
        }
    }
    return null;
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
/**
 * Returns a {@link NoType} if the {@link TypeMirror} represents an non-type such
 * as void, or package, etc. or throws an {@link IllegalArgumentException}.
 */
public static NoType asNoType(TypeMirror maybeNoType) {
    return maybeNoType.accept(new CastingTypeVisitor<NoType>() {
        @Override
        public NoType visitNoType(NoType noType, String p) {
            return noType;
        }
    }, "non-type");
}
 

import javax.lang.model.type.NoType; //导入依赖的package包/类
private boolean hasPotentialMethod( Symbol.ClassSymbol rootClassSymbol, String name, int paramCount )
{
  if( rootClassSymbol == null || rootClassSymbol instanceof NoType )
  {
    return false;
  }

  for( Symbol member : IDynamicJdk.instance().getMembers( rootClassSymbol, e -> e.flatName().toString().equals( name ) ) )
  {
    Symbol.MethodSymbol methodSym = (Symbol.MethodSymbol)member;
    if( methodSym.getParameters().size() == paramCount )
    {
      return true;
    }
  }
  if( hasPotentialMethod( (Symbol.ClassSymbol)rootClassSymbol.getSuperclass().tsym, name, paramCount ) )
  {
    return true;
  }
  for( Type iface : rootClassSymbol.getInterfaces() )
  {
    if( hasPotentialMethod( (Symbol.ClassSymbol)iface.tsym, name, paramCount ) )
    {
      return true;
    }
  }
  return false;
}