javax.lang.model.type.ErrorType Java Examples

public void testErrorTypes() {
  TypeElement extendsUndefinedType =
      processingEnv.getElementUtils().getTypeElement("ExtendsUndefinedType");
  ErrorType errorType = (ErrorType) extendsUndefinedType.getSuperclass();
  TypeMirror javaLangObject = typeMirrorOf("java.lang.Object");
  TypeElement list = typeElementOf("java.util.List");
  TypeMirror listOfError = typeUtil.getDeclaredType(list, errorType);
  TypeMirror queryExtendsError = typeUtil.getWildcardType(errorType, null);
  TypeMirror listOfQueryExtendsError = typeUtil.getDeclaredType(list, queryExtendsError);
  TypeMirror querySuperError = typeUtil.getWildcardType(null, errorType);
  TypeMirror listOfQuerySuperError = typeUtil.getDeclaredType(list, querySuperError);
  TypeMirror arrayOfError = typeUtil.getArrayType(errorType);
  TypeMirror[] typesWithErrors = {
      errorType, listOfError, listOfQueryExtendsError, listOfQuerySuperError, arrayOfError
  };
  for (TypeMirror typeWithError : typesWithErrors) {
    try {
      new TypeSimplifier(typeUtil, "foo.bar", ImmutableSet.of(typeWithError), javaLangObject);
      fail("Expected exception for type: " + typeWithError);
    } catch (MissingTypeException expected) {
    }
  }
}
 

private void test() {
  TypeElement extendsUndefinedType = elementUtils.getTypeElement("ExtendsUndefinedType");
  ErrorType errorType = (ErrorType) extendsUndefinedType.getSuperclass();
  TypeElement list = elementUtils.getTypeElement("java.util.List");
  TypeMirror listOfError = typeUtils.getDeclaredType(list, errorType);
  TypeMirror queryExtendsError = typeUtils.getWildcardType(errorType, null);
  TypeMirror listOfQueryExtendsError = typeUtils.getDeclaredType(list, queryExtendsError);
  TypeMirror querySuperError = typeUtils.getWildcardType(null, errorType);
  TypeMirror listOfQuerySuperError = typeUtils.getDeclaredType(list, querySuperError);
  TypeMirror arrayOfError = typeUtils.getArrayType(errorType);
  testErrorType(errorType);
  testErrorType(listOfError);
  testErrorType(listOfQueryExtendsError);
  testErrorType(listOfQuerySuperError);
  testErrorType(arrayOfError);
}
 

public void testErrorTypes() {
  TypeElement extendsUndefinedType =
      processingEnv.getElementUtils().getTypeElement("ExtendsUndefinedType");
  ErrorType errorType = (ErrorType) extendsUndefinedType.getSuperclass();
  TypeMirror javaLangObject = typeMirrorOf("java.lang.Object");
  TypeElement list = typeElementOf("java.util.List");
  TypeMirror listOfError = typeUtil.getDeclaredType(list, errorType);
  TypeMirror queryExtendsError = typeUtil.getWildcardType(errorType, null);
  TypeMirror listOfQueryExtendsError = typeUtil.getDeclaredType(list, queryExtendsError);
  TypeMirror querySuperError = typeUtil.getWildcardType(null, errorType);
  TypeMirror listOfQuerySuperError = typeUtil.getDeclaredType(list, querySuperError);
  TypeMirror arrayOfError = typeUtil.getArrayType(errorType);
  TypeMirror[] typesWithErrors = {
      errorType, listOfError, listOfQueryExtendsError, listOfQuerySuperError, arrayOfError
  };
  for (TypeMirror typeWithError : typesWithErrors) {
    try {
      new TypeSimplifier(typeUtil, "foo.bar", ImmutableSet.of(typeWithError), javaLangObject);
      fail("Expected exception for type: " + typeWithError);
    } catch (MissingTypeException expected) {
    }
  }
}
 

public void testErrorTypes() {
  TypeElement extendsUndefinedType =
      processingEnv.getElementUtils().getTypeElement("ExtendsUndefinedType");
  ErrorType errorType = (ErrorType) extendsUndefinedType.getSuperclass();
  TypeMirror javaLangObject = typeMirrorOf("java.lang.Object");
  TypeElement list = typeElementOf("java.util.List");
  TypeMirror listOfError = typeUtil.getDeclaredType(list, errorType);
  TypeMirror queryExtendsError = typeUtil.getWildcardType(errorType, null);
  TypeMirror listOfQueryExtendsError = typeUtil.getDeclaredType(list, queryExtendsError);
  TypeMirror querySuperError = typeUtil.getWildcardType(null, errorType);
  TypeMirror listOfQuerySuperError = typeUtil.getDeclaredType(list, querySuperError);
  TypeMirror arrayOfError = typeUtil.getArrayType(errorType);
  TypeMirror[] typesWithErrors = {
      errorType, listOfError, listOfQueryExtendsError, listOfQuerySuperError, arrayOfError
  };
  for (TypeMirror typeWithError : typesWithErrors) {
    try {
      new TypeSimplifier(typeUtil, "foo.bar", ImmutableSet.of(typeWithError), javaLangObject);
      fail("Expected exception for type: " + typeWithError);
    } catch (MissingTypeException expected) {
    }
  }
}
 

private static TypeMirror resolveCapturedType(CompilationInfo info, TypeMirror tm) {
    if (tm == null) {
        return tm;
    }
    if (tm.getKind() == TypeKind.ERROR) {
        tm = info.getTrees().getOriginalType((ErrorType) tm);
    }
    TypeMirror type = resolveCapturedTypeInt(info, tm);
    if (type == null) {
        return tm;
    }
    if (type.getKind() == TypeKind.WILDCARD) {
        TypeMirror tmirr = ((WildcardType) type).getExtendsBound();
        if (tmirr != null)
            return tmirr;
        else { //no extends, just '?'
            TypeElement te = info.getElements().getTypeElement("java.lang.Object"); // NOI18N
            return te == null ? null : te.asType();
        }
            
    }
    
    return type;
}
 

public static TypeMirror resolveCapturedType(CompilationInfo info, TypeMirror tm) {
    if (tm == null) {
        return tm;
    }
    if (tm.getKind() == TypeKind.ERROR) {
        tm = info.getTrees().getOriginalType((ErrorType) tm);
    }
    TypeMirror type = resolveCapturedTypeInt(info, tm);
    if (type == null) {
        return tm;
    }
    if (type.getKind() == TypeKind.WILDCARD) {
        TypeMirror tmirr = ((WildcardType) type).getExtendsBound();
        if (tmirr != null)
            return tmirr;
        else { //no extends, just '?'
            TypeElement te = info.getElements().getTypeElement("java.lang.Object"); // NOI18N
            return te == null ? null : te.asType();
        }
            
    }
    
    return type;
}
 

@Test
public void testSkipsErrorTypes() {
  TypeElement testClass = model.newType(
      "package com.example;",
      "class TestClass extends MissingType implements OtherMissingType {",
      "  public int foo(short a);",
      "}");
  List<ErrorType> errorTypes = new ArrayList<>();

  List<String> methods =
      toStrings(MethodFinder.methodsOn(testClass, model.elementUtils(), errorTypes::add));

  assertThat(methods).containsExactly("int TestClass::foo(short)");
  assertThat(errorTypes).hasSize(2);
}
 

private TypeMirror purify(CompilationInfo info, TypeMirror targetType) {
    if (targetType != null && targetType.getKind() == TypeKind.ERROR) {
        targetType = info.getTrees().getOriginalType((ErrorType) targetType);
    }

    if (targetType == null || targetType.getKind() == /*XXX:*/TypeKind.ERROR || targetType.getKind() == TypeKind.NONE || targetType.getKind() == TypeKind.NULL) return null;

    return Utilities.resolveTypeForDeclaration(info, targetType);
}
 

@Override
public Void visitError(ErrorType t, SignatureVisitor visitor) {
  // We don't really know, but if there's an error type the compilation is going to fail
  // anyway, so just pretend it's Object.
  visitor.visitClassType("java/lang/Object");
  visitor.visitEnd();
  return null;
}
 

@Override
public StringBuilder visitError(ErrorType t, Boolean p) {
    Element e = t.asElement();
    if (e instanceof TypeElement) {
        TypeElement te = (TypeElement)e;
        return DEFAULT_VALUE.append((p ? te.getQualifiedName() : te.getSimpleName()).toString());
    }
    return DEFAULT_VALUE;
}
 

@Override
public StringBuilder visitError(ErrorType t, Boolean p) {
    Element e = t.asElement();
    if (e instanceof TypeElement) {
        TypeElement te = (TypeElement)e;
        return DEFAULT_VALUE.append((p ? te.getQualifiedName() : te.getSimpleName()).toString());
    }
    return DEFAULT_VALUE;
}
 

@Test public void errorTypes() {
  JavaFileObject hasErrorTypes =
      JavaFileObjects.forSourceLines(
          "com.squareup.tacos.ErrorTypes",
          "package com.squareup.tacos;",
          "",
          "@SuppressWarnings(\"hook-into-compiler\")",
          "class ErrorTypes {",
          "  Tacos tacos;",
          "  Ingredients.Guacamole guacamole;",
          "}");
  Compilation compilation = javac().withProcessors(new AbstractProcessor() {
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
      TypeElement classFile =
          processingEnv.getElementUtils().getTypeElement("com.squareup.tacos.ErrorTypes");
      List<VariableElement> fields = fieldsIn(classFile.getEnclosedElements());
      ErrorType topLevel = (ErrorType) fields.get(0).asType();
      ErrorType member = (ErrorType) fields.get(1).asType();

      assertThat(TypeName.get(topLevel)).isEqualTo(ClassName.get("", "Tacos"));
      assertThat(TypeName.get(member)).isEqualTo(ClassName.get("Ingredients", "Guacamole"));
      return false;
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
      return Collections.singleton("*");
    }
  }).compile(hasErrorTypes);

  assertThat(compilation).failed();
}
 

@Override
public StringBuilder visitError(ErrorType t, Boolean p) {
    Element e = t.asElement();
    if (e instanceof TypeElement) {
        TypeElement te = (TypeElement)e;
        return DEFAULT_VALUE.append((p ? te.getQualifiedName() : te.getSimpleName()).toString());
    }
    return DEFAULT_VALUE;
}
 

private TypeMirror purify(CompilationInfo info, TypeMirror targetType) {
    if (targetType != null && targetType.getKind() == TypeKind.ERROR) {
        targetType = info.getTrees().getOriginalType((ErrorType) targetType);
    }

    if (targetType == null || targetType.getKind() == /*XXX:*/TypeKind.ERROR || targetType.getKind() == TypeKind.NONE || targetType.getKind() == TypeKind.NULL) return null;

    return Utilities.resolveCapturedType(info, targetType);
}
 

@Override
public Void visitError(ErrorType type, Void p) {
    Element e = type.asElement();
    if (e instanceof TypeElement) {
        TypeElement te = (TypeElement)e;
        builder.append(te.getSimpleName());            
    }
    return null;
}
 

@Override
public StringBuilder visitError(ErrorType t, Boolean p) {
    Element e = t.asElement();
    if (e instanceof TypeElement) {
        TypeElement te = (TypeElement)e;
        return DEFAULT_VALUE.append((p ? te.getQualifiedName() : te.getSimpleName()).toString());
    }
    return DEFAULT_VALUE;
}
 

@Override
public StringBuilder visitError(ErrorType t, Boolean p) {
    Element e = t.asElement();
    if (e instanceof TypeElement) {
        TypeElement te = (TypeElement)e;
        return DEFAULT_VALUE.append((p ? te.getQualifiedName() : te.getSimpleName()).toString());
    }
    return DEFAULT_VALUE;
}
 

@Override
public <R, P> R accept(TypeVisitor<R, P> v, P p) {
  switch (kind) {
    case BOOLEAN:
    case BYTE:
    case SHORT:
    case INT:
    case LONG:
    case CHAR:
    case FLOAT:
    case DOUBLE:
      return v.visitPrimitive((PrimitiveType) this, p);
    case PACKAGE:
    case VOID:
    case NONE:
      return v.visitNoType((NoType) this, p);
    case NULL:
      return v.visitNull((NullType) this, p);
    case ARRAY:
      return v.visitArray((ArrayType) this, p);
    case DECLARED:
      return v.visitDeclared((DeclaredType) this, p);
    case ERROR:
      return v.visitError((ErrorType) this, p);
    case TYPEVAR:
      return v.visitTypeVariable((TypeVariable) this, p);
    case WILDCARD:
      return v.visitWildcard((WildcardType) this, p);
    case EXECUTABLE:
      return v.visitExecutable((ExecutableType) this, p);
    case OTHER:
      return v.visit(this, p);
    case UNION:
      return v.visitUnion((UnionType) this, p);
    case INTERSECTION:
      return v.visitIntersection((IntersectionType) this, p);
    default:
      throw new AssertionError(String.format("Unknown TypeKind: %s", kind));
  }
}
 

/**
 * Returns a {@link ExecutableType} if the {@link TypeMirror} represents an executable type such
 * as may result from missing code, or bad compiles or throws an {@link IllegalArgumentException}.
 */
public static ErrorType asError(TypeMirror maybeErrorType) {
    return maybeErrorType.accept(new CastingTypeVisitor<ErrorType>() {
        @Override
        public ErrorType visitError(ErrorType type, String p) {
            return type;
        }
    }, "error type");
}
 

@Override
public final T visitError(ErrorType t, StringBuilderAndState<S> st) {
    try {
        st.depth++;
        return doVisitError(t, st);
    } finally {
        st.depth--;
    }
}
 

private boolean checkFirstArgType(TypeMirror type, DeclaredTypeName generatedClassName) {
    if (type instanceof ErrorType) {
        return true;
    }
    if (!(type instanceof DeclaredType)) {
        return false;
    }

    DeclaredTypeName typeName = (DeclaredTypeName) utils.getTypeNameFromTypeMirror(type);

    return typeName.equals(generatedClassName) || typeName.equals(TypeConstants.ABSTRACT_MODEL);
}
 

private static <E extends Exception> Optional<TypeElement> maybeTypeElement(
    TypeMirror mirror, ErrorTypeHandling<E> errorTypeHandling) throws E {
  if (mirror.getKind() == TypeKind.ERROR) {
    errorTypeHandling.handleErrorType((ErrorType) mirror);
  }
  return maybeAsTypeElement(mirror);
}
 

/**
 * Any reference to the as-yet-ungenerated builder should be an unresolved ERROR.
 * Similarly for many copy-and-paste errors
 */
@Override
public Boolean visitError(ErrorType t, Void p) {
  if (typeParameters.isEmpty()) {
    // For non-generic types, the ErrorType will have the correct name.
    String simpleName = t.toString();
    return equal(simpleName, superclass.getSimpleName());
  }
  // For generic types, we'll just have to hope for the best.
  // TODO: Revalidate in a subsequent round?
  return true;
}
 

@Override
public StringBuilder visitError(ErrorType t, Void p) {
    Element e = t.asElement();
    if (e instanceof TypeElement) {
        TypeElement te = (TypeElement) e;
        return DEFAULT_VALUE.append(te.getQualifiedName().toString());
    }
    return DEFAULT_VALUE;
}
 

public ErrorType getErrorType(ReferenceBinding binding) {
	return new ErrorTypeImpl(this._env, binding);
}
 

@Override public Element visitError(ErrorType t, Void p) {
  return t.asElement();
}
 

@Override
public Boolean visitError(ErrorType t, Void p) {
  return false;
}
 

@Override public Void visitError(ErrorType t, Void p) {
  throw new MissingTypeException();
}
 

@Override
public StringBuilder visitError(ErrorType t, StringBuilder p) {
  throw new MissingTypeException(t);
}
 

@Override
public Boolean visitError(ErrorType t, Void __) {
    return true;
}