@Override public DeclaredType visitType(TypeMirror typeMirror, Void nothing) { return asDeclared(typeMirror); } }, null);
@Override public DeclaredType visitType(TypeMirror typeMirror, Void ignored) { return asDeclared(typeMirror); } }, null);
@Override public DeclaredType getAnnotationType() { return MoreTypes.asDeclared(annotationType.asType()); }
@Override public ImmutableSet<DeclaredType> visitType(TypeMirror typeMirror, Void v) { return ImmutableSet.of(MoreTypes.asDeclared(typeMirror)); }
@Override public ImmutableSet<DeclaredType> visitType(TypeMirror typeMirror, Void v) { return ImmutableSet.of(MoreTypes.asDeclared(typeMirror)); }
private TypeElement asTypeElement(TypeMirror typeMirror) { DeclaredType declaredType = MoreTypes.asDeclared(typeMirror); Element element = declaredType.asElement(); return MoreElements.asType(element); } }
private static TypeMirror mapKeyValue(TypeMirror annotation, Elements elements) { List<ExecutableElement> mapKeyMethods = methodsIn(elements.getTypeElement(annotation.toString()).getEnclosedElements()); TypeMirror returnType = getOnlyElement(mapKeyMethods).getReturnType(); // TODO(ronshapiro): replace with MoreTypes.asWildcard() when auto-common 0.9 is released return ((WildcardType) getOnlyElement(MoreTypes.asDeclared(returnType).getTypeArguments())) .getExtendsBound(); } }
null); return superclass != null ? Optional.of(MoreTypes.asDeclared(superclass)) : Optional.<DeclaredType>absent();
private SimpleTypeAnnotationValue(TypeMirror value) { checkArgument( value.getKind().isPrimitive() || value.getKind().equals(DECLARED) || value.getKind().equals(ARRAY), "value must be a primitive, array, or declared type, but was %s (%s)", value.getKind(), value); if (value.getKind().equals(DECLARED)) { checkArgument( MoreTypes.asDeclared(value).getTypeArguments().isEmpty(), "value must not be a parameterized type: %s", value); } this.value = value; }
private TypeMirror getPresenterMirror() { if (presenterMirror == null) { List<? extends TypeMirror> proxyGenericTypes = asDeclared(proxyMirror).getTypeArguments(); if (proxyGenericTypes.isEmpty()) { logger.error().context(element).log("This proxy must specify its presenter."); throw new UnableToProcessException(); } presenterMirror = proxyGenericTypes.get(0); } return presenterMirror; }
@Override public boolean apply(TypeMirror input) { return input.getKind().equals(TypeKind.DECLARED) && (MoreElements.asType(MoreTypes.asDeclared(input).asElement())) .getKind() .equals(ElementKind.CLASS) && !types.isSameType(objectType, input); } }),
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; } }
DeclaredType declared = MoreTypes.asDeclared(supertype); TypeElement element = MoreElements.asType(declared.asElement()); List<? extends TypeMirror> actuals = declared.getTypeArguments();
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; }
array = true; } else if (isType(type)) { DeclaredType declaredType = asDeclared(type); Element element = declaredType.asElement();
private DeclaredType extractHandlerTypeFromEvent(DeclaredType superType) { List<? extends TypeMirror> typeArguments = superType.getTypeArguments(); if (typeArguments.size() != 1) { logger.error().context(eventTypeMirror.asElement()) .log("GWT event does not specify a proper handler type while extending Event."); throw new UnableToProcessException(); } DeclaredType typeMirror = asDeclared(typeArguments.get(0)); if (typeMirror.asElement().getKind() != ElementKind.INTERFACE) { logger.error().context(typeMirror.asElement()).log("GWT event handler must be an interface."); throw new UnableToProcessException(); } return typeMirror; }
if (builderTypeElement.equals(typeUtils.asElement(method.getReturnType()))) { methods.add(method); DeclaredType returnType = MoreTypes.asDeclared(method.getReturnType()); ImmutableList.Builder<String> typeArguments = ImmutableList.builder(); for (TypeMirror typeArgument : returnType.getTypeArguments()) {
? MoreTypes.asDeclared(type).getTypeArguments().get(0) : boxedType(type, types); return new AutoValue_Key(
private boolean isSubsignature( ExecutableElement overrider, ExecutableElement overridden, TypeElement in) { DeclaredType inType = MoreTypes.asDeclared(in.asType()); try { ExecutableType overriderExecutable =
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; }