@Override public TypeElement apply(TypeMirror klass) { return MoreTypes.asTypeElement(klass); } }).toList();
private void handleBaseBuilder() { if (!MoreTypes.isTypeOf(Object.class, baseBuilder.asType())) { final List<ExecutableElement> constructors = ElementFilter.constructorsIn(baseBuilder.getEnclosedElements()); Optional<ExecutableElement> constructor = constructors.stream().filter(c -> c.getParameters().size() == 0).findAny(); if (constructor.isPresent()) { elements.add(modelFactory.fromDelegateConstructor(constructor.get(), false)); } else { constructor = constructors.stream().filter(c -> c.getParameters().size() == 1 && Types.CONTEXT.equals(TypeName.get(c.getParameters().get(0).asType()))).findAny(); if (constructor.isPresent()) { elements.add(modelFactory.fromDelegateConstructor(constructor.get(), true)); } else { final AnnotationMirror mirror = baseAnnotation.getAnnotationMirrors().stream() .filter(m -> MoreTypes.isTypeOf(Configuration.class, m.getAnnotationType())) .findAny().orElseThrow(IllegalArgumentException::new); messager.printMessage(Diagnostic.Kind.ERROR, "Classes used as base builder must have a constructor which takes no arguments, " + "or exactly one argument of type Class", baseAnnotation, mirror, mirror.getElementValues().entrySet().stream() .filter(entry -> entry.getKey().getSimpleName().toString().equals("builderSuperClass")).findAny().map(Map.Entry::getValue).orElse(null)); throw new IllegalArgumentException(); } } handleBaseBuilderMethods(); } }
@Override public DeclaredType visitType(TypeMirror typeMirror, Void nothing) { return asDeclared(typeMirror); } }, null);
@Override public Boolean visitAnnotation(AnnotationMirror a, TypeMirror expectedType) { return MoreTypes.equivalence().equivalent(a.getAnnotationType(), expectedType) && validateAnnotation(a); }
if (MoreTypes.asDeclared(injectedType).getTypeArguments().isEmpty()) { builder.injectedType(ClassName.get(MoreTypes.asTypeElement(injectedType))); builder.mapKeyType(ClassName.get(MoreTypes.asTypeElement(maybeFrameworkType.get().getKey()))); } else { reporter.reportError( for (TypeMirror module : getAnnotationValue(annotation, "modules").accept(new AllTypesVisitor(), null)) { if (isAnnotationPresent(MoreTypes.asElement(module), Module.class)) { builder.modulesBuilder().add((ClassName) TypeName.get(module)); } else {
packageName = ""; enclosingNames = ""; simpleName = asPrimitiveType(type).toString(); typeArguments = emptyList(); array = false; enclosingNames = ""; simpleName = ""; typeArguments = singletonList(new Type(asArray(type).getComponentType())); array = true; } else if (isType(type)) { DeclaredType declaredType = asDeclared(type); Element element = declaredType.asElement();
public StoreMethodModel(ExecutableElement element, StoreModel storeModel) { this.element = element; this.storeModel = storeModel; List<TypeName> states = FluentIterable.from(storeModel.getStoreImplModels()) .transform(new Function<StoreImplModel, TypeName>() { @Override public TypeName apply(StoreImplModel input) { return input.getState(); } }).toList(); returnType = MoreTypes.asDeclared(element.getReturnType()); if (states.contains(ClassName.get(returnType))) { kind = Kind.GETTER; isBindable = element.getAnnotation(Bindable.class) != null; } else if (getName().equals(DispatcherModel.DISPATCH_METHOD_NAME)) { kind = Kind.DISPATCH; } else if (MoreTypes.isTypeOf(OBSERVE_METHOD_CLASS, returnType.asElement().asType()) && states.contains(ClassName.get(returnType.getTypeArguments().get(0)))) { if (element.getParameters() != null && !element.getParameters().isEmpty() && MoreTypes.isTypeOf(BACKPRESSURE_STRATEGY_PARAM_CLASS, element.getParameters().get(0).asType())) { bpsParamName = element.getParameters().get(0).getSimpleName().toString(); kind = Kind.OBSERVE_WITH_BPS; } else { kind = Kind.OBSERVE; } } else { kind = Kind.UNKNOWN; } }
private boolean isSubsignature( ExecutableElement overrider, ExecutableElement overridden, TypeElement in) { DeclaredType inType = MoreTypes.asDeclared(in.asType()); try { ExecutableType overriderExecutable = MoreTypes.asExecutable(typeUtils.asMemberOf(inType, overrider)); ExecutableType overriddenExecutable = MoreTypes.asExecutable(typeUtils.asMemberOf(inType, overridden)); return typeUtils.isSubsignature(overriderExecutable, overriddenExecutable); } catch (IllegalArgumentException e) {
private boolean isGwtEventType(Element element, TypeMirror typeMirror) { return hasModifiers(Modifier.PUBLIC, Modifier.STATIC).apply(element) && isType(typeMirror) && utils.getTypes().isSubtype(typeMirror, utils.createWithWildcard(Event.Type.class)) && asDeclared(typeMirror).getTypeArguments().size() == 1; }
.map(a -> asElement(a.getAnnotationType()).getAnnotation(HttpMethod.class)) .filter(Objects::nonNull).map(HttpMethod::value).findFirst().orElse(GET))); MoreTypes.asDeclared(method.getReturnType()).getTypeArguments().stream().findFirst() .map(TypeName::get).orElse(TypeName.get(Void.class)));
private boolean isCookieCollection(DeclaredType type) { TypeMirror collectionType = utils.createWithWildcard(Collection.class); Optional<TypeMirror> typeArg = extractCollectionTypeArg(type); return utils.getTypes().isAssignable(type, collectionType) && typeArg.isPresent() && isType(typeArg.get()) && asTypeElement(typeArg.get()).getQualifiedName().contentEquals(Cookie.class.getCanonicalName()); }
private DeclaredType getHandlerTypeMirror() { if (handlerTypeMirror == null) { Optional<DeclaredType> optionalSuperType = nonObjectSuperclass(utils.getTypes(), utils.getElements(), getEventTypeMirror()); while (optionalSuperType.isPresent()) { DeclaredType superType = optionalSuperType.get(); if (isTypeOf(Event.class, superType)) { handlerTypeMirror = extractHandlerTypeFromEvent(superType); break; } else { optionalSuperType = nonObjectSuperclass(utils.getTypes(), utils.getElements(), superType); } } } return handlerTypeMirror; }
public static TypeElement asTypeElement(TypeMirror mirror) { return MoreElements.asType(asElement(mirror)); }
@Override public DeclaredType visitType(TypeMirror typeMirror, Void ignored) { return asDeclared(typeMirror); } }, null);
private Equivalence.Wrapper<TypeMirror> wrap(TypeMirror typeMirror) { return MoreTypes.equivalence().wrap(typeMirror); }
private DeclaredType getEventTypeMirror() { if (eventTypeMirror == null) { List<? extends TypeMirror> parameterTypes = asExecutable(element.asType()).getParameterTypes(); if (parameterTypes.size() != 1) { throwInvalidProxyMethodArguments(); } TypeMirror parameterType = parameterTypes.get(0); TypeMirror genericEventType = utils.createWithWildcard(Event.class); if (!utils.getTypes().isAssignable(parameterType, genericEventType)) { throwInvalidProxyMethodArguments(); } eventTypeMirror = asDeclared(parameterType); } return eventTypeMirror; }
private void ensureNoHandlerMethodClashes() { List<String> handlerMethodNames = FluentIterable.from(proxyEventMethods) .transform(ProxyEventMethod::getHandlerMethodName) .toList(); Set<String> uniqueHandlerMethodNames = new HashSet<>(handlerMethodNames); if (handlerMethodNames.size() != uniqueHandlerMethodNames.size()) { // TODO: Probably not worth it, but with some gymnastic we could print exactly which methods. logger.error() .context(asElement(getPresenterMirror())) .log("Presenter contains multiple @ProxyEvents with handlers that have clashing method names."); throw new UnableToProcessException(); } }
@Override public DeclaredType getAnnotationType() { return MoreTypes.asDeclared(annotationType.asType()); }
public void createClasses() throws IOException { TypeElement baseBuilder; try { baseBuilder = processingEnv.getElementUtils().getTypeElement(configuration.baseBuilderClass().getName()); } catch (MirroredTypeException e) { baseBuilder = MoreTypes.asTypeElement(e.getTypeMirror()); } final List<Element> elements = new ModelBuilder(baseAnnotation, new ElementFactory(processingEnv.getElementUtils()), baseBuilder, processingEnv.getMessager()).build(); createBuilderClass(elements); createConfigClass(elements); if (configuration.isPlugin()) { createBuilderInterface(elements); createFactoryClass(); } }