private VoidReturnType(final Types types) { voidType = types.getNoType(TypeKind.VOID); voidElement = types.asElement(voidType); hash = "void".hashCode(); }
private Stream<CompilationMessage> validateReturnType( ExecutableElement method ) { String streamClassName = Stream.class.getCanonicalName(); TypeMirror streamType = typeUtils.erasure( elementUtils.getTypeElement( streamClassName ).asType() ); TypeMirror returnType = method.getReturnType(); TypeMirror erasedReturnType = typeUtils.erasure( returnType ); TypeMirror voidType = typeUtils.getNoType( TypeKind.VOID ); if ( typeUtils.isSameType( returnType, voidType ) ) { return Stream.empty(); } if ( !typeUtils.isSubtype( erasedReturnType, streamType ) ) { return Stream.of( new ReturnTypeError( method, "Return type of %s#%s must be %s", method.getEnclosingElement().getSimpleName(), method.getSimpleName(), streamClassName ) ); } return recordVisitor.visit( returnType ); }
@Override protected TypeMirror defaultAction(TypeMirror x, State state) { return state.types.getNoType(TypeKind.NONE); } }
/** * Utility method to convert a {@code Foo<BarProxy> -> BarDomain}. The * {@code param} parameter specifies the index of the type parameter to * extract. */ protected TypeMirror convertSingleParamType(DeclaredType x, DeclaredType convertTo, int param, State state) { DeclaredType converted = (DeclaredType) State.viewAs(convertTo, x, state); if (converted == null) { return state.types.getNoType(TypeKind.NONE); } if (converted.getTypeArguments().isEmpty()) { return defaultAction(x, state); } return converted.getTypeArguments().get(param).accept(this, state); }
/** Returns a {@link TypeMirror} for the given class (raw T, not T<?>, if T is generic). */ public static TypeMirror typeMirror( Types typeUtils, Elements elementUtils, Class<?> cls) { if (cls.equals(void.class)) { return typeUtils.getNoType(TypeKind.VOID); } else if (cls.isPrimitive()) { return typeUtils.getPrimitiveType(TypeKind.valueOf(cls.getSimpleName().toUpperCase())); } else if (cls.isArray()) { return typeUtils.getArrayType(typeMirror(typeUtils, elementUtils, cls.getComponentType())); } else { return rawType(typeUtils, elementUtils, cls.getCanonicalName()); } }
new MethodFinder(name, state.types.getNoType(TypeKind.VOID), lookFor, false, state).scan( domainElement, state); if (domainMethod == null) {
@Override public NoType getNoType(TypeKind kind) { return types.getNoType(kind); }
public MarkerNode(@Nullable Tree tree, String message, Types types) { super(types.getNoType(TypeKind.NONE)); this.tree = tree; this.message = message; }
public SynchronizedNode( @Nullable Tree tree, Node expression, boolean startOfBlock, Types types) { super(types.getNoType(TypeKind.NONE)); this.tree = tree; this.expression = expression; this.startOfBlock = startOfBlock; }
public static TypeMirror get(ProcessingEnvironment processingEnvironment, Class<?> cls) { if (cls.isPrimitive()) { if(cls.equals(void.class)) { return processingEnvironment.getTypeUtils().getNoType(TypeKind.VOID); } final Class<?> boxedClass = PRIMITIVES_TO_WRAPPERS.get(cls); final TypeElement boxedElement = processingEnvironment.getElementUtils().getTypeElement(boxedClass.getName()); return processingEnvironment.getTypeUtils().unboxedType(boxedElement.asType()); } return processingEnvironment.getElementUtils().getTypeElement(cls.getName()).asType(); } }
@Override public TypeMirror getReceiverType() { return env.getTypeUtils().getNoType(TypeKind.NONE); }
@Override public TypeMirror getReceiverType() { return env.getTypeUtils().getNoType(TypeKind.NONE); }
@Override public TypeMirror getReceiverType() { return env.getTypeUtils().getNoType(TypeKind.NONE); }
/** * creates a void return type * * @return void type */ public Type createVoidType() { return getType( typeUtils.getNoType( TypeKind.VOID ) ); }
@Override public TypeMirror getReceiverType() { return env.getTypeUtils().getNoType(TypeKind.NONE); }
private boolean isGetter(ExecutableElement element) { return !types.isSameType(element.getReturnType(), types.getNoType(TypeKind.VOID)) && element.getParameters().size() == 0; }
private boolean isSetter(ExecutableElement element) { return types.isSameType(element.getReturnType(), types.getNoType(TypeKind.VOID)) && element.getParameters().size() == 1; }
@Override public VoidType getVoidType() { return ConvertTypeMirror.convert(internal.getNoType(TypeKind.VOID), VoidType.class); }
public CaseNode(CaseTree tree, Node switchExpr, Node caseExpr, Types types) { super(types.getNoType(TypeKind.NONE)); assert tree.getKind().equals(Kind.CASE); this.tree = tree; this.switchExpr = switchExpr; this.caseExpr = caseExpr; }
public ReturnNode(ReturnTree t, @Nullable Node result, Types types, MethodTree methodTree) { super(types.getNoType(TypeKind.NONE)); this.result = result; tree = t; result.setAssignmentContext(new MethodReturnContext(methodTree)); }