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()); }
public List<Element> getAllMembers(TypeElement type, Class<?> exclusion) { return getAllMembers(type, elements.getTypeElement(exclusion.getCanonicalName())); }
public boolean elementIsPartOfGwtSource(Element element) { PackageElement packageElement = utils.getElements().getPackageOf(element); String packageName = packageElement.getQualifiedName() + "."; for (String sourcePackage : getSourcePackages()) { if (packageName.startsWith(sourcePackage + ".")) { return true; } } return false; }
public static Type findRestModuleType(Utils utils) { return new Type(utils.getSourceFilter().getApplicationPackage(), REST_MODULE_NAME + "$$" + utils.getRoundNumber()); }
private boolean processGwtElements(RoundEnvironment roundEnv) { Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Path.class); elements = utils.getSourceFilter().filterElements(elements); elements.stream().filter(MoreElements::isType).forEach(this::process); return !elements.isEmpty(); }
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; }
private void validateCustomProviderType(LogBuilder errorBuilder, DeclaredType type) { TypeElement customProviderElement = asTypeElement(type); TypeMirror expectedSuperType = utils.createWithTypeArguments(IndirectProvider.class, getPresenterMirror()); if (customProviderElement.getKind() != CLASS || !hasModifiers(PUBLIC).apply(customProviderElement) || hasModifiers(ABSTRACT).apply(customProviderElement) || !utils.getTypes().isSubtype(type, expectedSuperType)) { errorBuilder.log("Element passed to @CustomProvider must be a public, non-abstract class " + "and implement `%s`.", new Type(expectedSuperType).getParameterizedName()); throw new UnableToProcessException(); } }
public TypeMirror createWithWildcard(Class<?> clazz) { return createWithWildcard(clazz.getCanonicalName()); }
private boolean isBoxed(DeclaredType type) { try { PrimitiveType primitiveType = utils.getTypes().unboxedType(type); return primitiveType != null; } catch (IllegalArgumentException e) { return false; } }
private String appendRoundNumber(String className) { int roundNumber = utils.getRoundNumber(); if (roundNumber > 1) { return className + "$$" + roundNumber; } return className; } }
public TypeMirror createWithTypeArguments(Class<?> clazz, TypeMirror... typeArguments) { return createWithTypeArguments(clazz.getCanonicalName(), typeArguments); }
private void loadFromOptions() { String modules = utils.getOption(GWTP_MODULE_OPTION); if (modules == null) { logger.warning("Add `-A%s=com.domain.YourModule` to your compiler options to enable GWTP " + "annotation processors.", GWTP_MODULE_OPTION); } else { addModules(modules.split(",")); } }
@Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); try { Map<String, String> options = processingEnv.getOptions(); logger = new Logger(processingEnv.getMessager(), options); utils = new Utils(logger, processingEnv.getTypeUtils(), processingEnv.getElementUtils(), options); outputter = new Outputter(logger, this, processingEnv.getFiler(), getMacroFiles()); initSafe(); } catch (UnableToProcessException ignore) { } catch (Exception e) { logger.error().throwable(e).log(UNRESOLVABLE_EXCEPTION); } }
private void loadGwtpApp(RoundEnvironment roundEnv) { if (!gwtpAppPresent) { Set<? extends Element> annotations = roundEnv.getElementsAnnotatedWith(GwtpApp.class); annotations = utils.getSourceFilter().filterElements(annotations); gwtpAppPresent = !annotations.isEmpty(); } }
private boolean verifyIsGatekeeperWithParams() { TypeMirror gatekeeperMirror = extractGatekeeperMirror(); TypeMirror expectedParentMirror = utils.getElements() .getTypeElement(GatekeeperWithParams.class.getCanonicalName()) .asType(); if (gatekeeperMirror == null || !utils.getTypes().isSubtype(gatekeeperMirror, expectedParentMirror)) { logger.mandatoryWarning() .context(element) .log("Proxy annotated with @GatekeeperParams with missing or invalid gatekeeper argument. " + "A gatekeeper that implements GatekeeperWithParams must be provided to @UseGatekeeper."); return false; } return true; }
private void validateCustomProviderConstructor(LogBuilder errorBuilder, DeclaredType type) { TypeMirror expectedParameterMirror = utils.createWithTypeArguments( getBundleDetails() != null || isCodeSplit() ? AsyncProvider.class : Provider.class, getPresenterMirror()); List<ExecutableElement> constructors = constructorsIn(asTypeElement(type).getEnclosedElements()); for (ExecutableElement constructor : constructors) { List<? extends VariableElement> parameters = constructor.getParameters(); if (hasModifiers(PUBLIC).apply(constructor) && parameters.size() == 1 && utils.getTypes().isAssignable(expectedParameterMirror, parameters.get(0).asType())) { return; } } errorBuilder.log("Class passed to @CustomProvider must have a public constructor with a single parameter of " + "type `%s`.", new Type(expectedParameterMirror).getParameterizedName()); throw new UnableToProcessException(); }
private void validateEventHandler(ExecutableElement handlerMethod) { if (handlerMethod.getReturnType().getKind() != TypeKind.VOID) { throwBadHandlerSignature(handlerMethod); } List<? extends VariableElement> parameters = handlerMethod.getParameters(); if (parameters.size() != 1) { throwBadHandlerSignature(handlerMethod); } VariableElement parameter = parameters.get(0); TypeMirror parameterType = asMemberOf(utils.getTypes(), getHandlerTypeMirror(), parameter); if (!utils.getTypes().isSameType(parameterType, getEventTypeMirror())) { throwBadHandlerSignature(parameter); } }
private Type createModuleType(ProxyDetails proxy) { String packageName = proxy.getType().getPackageName(); String moduleName = PROXY_MODULE_NAME; if (utils.getRoundNumber() > 1) { moduleName += "$$" + utils.getRoundNumber(); } return new Type(packageName, moduleName); }
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; }
private boolean processGwtElements(RoundEnvironment roundEnv) { Set<Element> elements = new HashSet<>(roundEnv.getElementsAnnotatedWith(ProxyStandard.class)); elements.addAll(roundEnv.getElementsAnnotatedWith(ProxyCodeSplit.class)); elements.addAll(roundEnv.getElementsAnnotatedWith(ProxyCodeSplitBundle.class)); elements = utils.getSourceFilter().filterElements(elements); elements.forEach(this::process); return !elements.isEmpty(); }