@Override public List<? extends TypeMirror> getThrownTypes() { return delegate.getThrownTypes(); }
private static boolean doesNotThrow(ExecutableElement elem) { return elem.getThrownTypes().isEmpty(); } }
public void doesntThrowException(Element element, ElementValidation valid) { ExecutableElement executableElement = (ExecutableElement) element; if (executableElement.getThrownTypes().size() > 0) { valid.addError("%s annotated methods should not declare throwing any exception"); } }
public void throwsOnlyRestClientException(ExecutableElement element, ElementValidation valid) { List<? extends TypeMirror> thrownTypes = element.getThrownTypes(); if (thrownTypes.size() > 0) { if (thrownTypes.size() > 1 || !thrownTypes.get(0).toString().equals(REST_CLIENT_EXCEPTION)) { valid.addError("%s annotated methods can only declare throwing a RestClientException"); } } }
private boolean isSimpleAccessor(ExecutableElement method) { return method.getParameters().isEmpty() && method.getThrownTypes().isEmpty() && method.getTypeParameters().isEmpty() && method.getReturnType().getKind() != TypeKind.VOID; }
private static ImmutableList<String> extractThrowsClause(ExecutableElement factoryMethodElement) { return FluentIterable.from(factoryMethodElement.getThrownTypes()) .transform(Functions.toStringFunction()) .toList(); } }
public static MethodSpec.Builder overriding(ExecutableElement method) { return MethodSpec.methodBuilder(method.getSimpleName().toString()) .addAnnotation(Override.class) .addModifiers(method.getModifiers().stream().filter(modifier -> modifier != Modifier.ABSTRACT).collect(Collectors.toList())) .returns(TypeName.get(method.getReturnType())) .varargs(method.isVarArgs()) .addExceptions(method.getThrownTypes().stream().map(TypeName::get).collect(Collectors.toList())) .addTypeVariables(method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList())) .addParameters(method.getParameters().stream().map(element -> ParameterSpec.get(element).toBuilder() .addAnnotations(element.getAnnotationMirrors().stream().map(AnnotationSpec::get).collect(Collectors.toList())).build()).collect(Collectors.toList())); }
@Override default List<? extends TypeMirror> getThrownTypes() { return getDelegate().getThrownTypes(); }
private ImmutableSet<String> collectThrownCheckedExceptions() { Set<String> exceptions = new HashSet<>(2); Environment env = protoclass().environment(); for (TypeMirror thrown : ((ExecutableElement) element).getThrownTypes()) { if (env.isCheckedException(thrown)) { exceptions.add(thrown.toString()); } } return ImmutableSet.copyOf(exceptions); }
methodBuilder.varargs(method.isVarArgs()); for (TypeMirror thrownType : method.getThrownTypes()) { methodBuilder.addException(TypeName.get(thrownType));
validator.error("Callback method cannot be abstract"); if (!element.getThrownTypes().isEmpty()) { Types types = processingEnvironment.getTypeUtils(); for (TypeMirror mirror : element.getThrownTypes()) { Element exceptionElement = types.asElement(mirror); if (exceptionElement != null &&
if (!providerMethodAsExecutable.getThrownTypes().isEmpty()) { error("@Provides methods must not have a throws clause: " + type.getQualifiedName() + "." + providerMethod, providerMethod);
for (TypeMirror typeMirror : methodElement.getThrownTypes()) { documentedMethod.exceptions.add(typeMirror.toString());
static MethodSpec.Builder overriding(ExecutableElement method) { String methodName = method.getSimpleName().toString(); MethodSpec.Builder builder = MethodSpec.methodBuilder(methodName) .addAnnotation(Override.class); Set<Modifier> modifiers = method.getModifiers(); modifiers = new LinkedHashSet<>(modifiers); modifiers.remove(Modifier.ABSTRACT); Modifier defaultModifier = null; // Modifier.DEFAULT doesn't exist until Java 8. try { defaultModifier = Modifier.valueOf("DEFAULT"); } catch (IllegalArgumentException e) { // Ignored. } modifiers.remove(defaultModifier); builder = builder.addModifiers(modifiers); for (TypeParameterElement typeParameterElement : method.getTypeParameters()) { TypeVariable var = (TypeVariable) typeParameterElement.asType(); builder = builder.addTypeVariable(TypeVariableName.get(var)); } builder = builder.returns(TypeName.get(method.getReturnType())) .addParameters(getParameters(method)) .varargs(method.isVarArgs()); for (TypeMirror thrownType : method.getThrownTypes()) { builder = builder.addException(TypeName.get(thrownType)); } return builder; }
for (TypeMirror superThrownType : executableElement.getThrownTypes()) { AbstractJClass thrownType = typeMirrorToJClass(superThrownType, actualTypes); method._throws(thrownType);
if (!method.getThrownTypes().isEmpty()) { reporter.withElement(method) .error("@Encoding.Of method '%s' cannot have throws declaration",
private boolean processGenericEncodedMethod( ExecutableElement method, List<EncodedElement> collection, Tag... additionalTags) { EncodedElement.Builder builder = new EncodedElement.Builder(); TypeExtractor typesReader = processTypeParameters(method, builder); AtomicReference<StandardNaming> standardNaming = new AtomicReference<>(StandardNaming.NONE); EnumSet<Tag> tags = EnumSet.noneOf(Tag.class); for (Tag t : additionalTags) { tags.add(t); } collection.add(builder .name(method.getSimpleName().toString()) .type(typesReader.get(method.getReturnType())) .naming(inferNaming(method, tags, standardNaming)) .standardNaming(standardNaming.get()) .addAllTags(inferTags(method, tags)) .addAllParams(getParameters(typesReader, method)) .addAllDoc(docFrom(method)) .addAllAnnotations(annotationsFrom(method)) .addAllCode(sourceMapper.getBlock(memberPath(method))) .addAllThrown(typesReader.getDefined(method.getThrownTypes())) .build()); return true; }
if (!method.getThrownTypes().isEmpty()) { reporter.withElement(method) .error("@Encoding.Expose method '%s' cannot have throws declaration",
if (!method.getThrownTypes().isEmpty()) { reporter.withElement(method) .error("@Encoding.Build method '%s' cannot have throws declaration",
Set<MessageMethod> build() { final Elements elements = processingEnv.getElementUtils(); final Set<MessageMethod> result = new LinkedHashSet<>(); for (ExecutableElement elementMethod : methods) { final AptMessageMethod resultMethod = new AptMessageMethod(elements, elementMethod); resultMethod.inheritsMessage = inheritsMessage(methods, elementMethod); resultMethod.message = findMessage(methods, elementMethod); resultMethod.isOverloaded = isOverloaded(methods, elementMethod); for (TypeMirror thrownType : elementMethod.getThrownTypes()) { resultMethod.thrownTypes.add(ThrowableTypeFactory.of(processingEnv, thrownType)); } // Create a list of parameters for (Parameter parameter : ParameterFactory.of(processingEnv, resultMethod.method)) { resultMethod.add(parameter); } // Check to see if the method is overloaded if (resultMethod.isOverloaded()) { resultMethod.messageMethodName = resultMethod.name() + resultMethod.formatParameterCount() + MESSAGE_METHOD_SUFFIX; resultMethod.translationKey = resultMethod.name() + "." + resultMethod.formatParameterCount(); } else { resultMethod.messageMethodName = resultMethod.name() + MESSAGE_METHOD_SUFFIX; resultMethod.translationKey = resultMethod.name(); } // Set the return type resultMethod.returnType = ReturnTypeFactory.of(processingEnv, elementMethod.getReturnType(), resultMethod); result.add(resultMethod); } return Collections.unmodifiableSet(result); }