private static boolean memoizeStaticMethodFromArguments(ExecutableElement staticMethod) { return staticMethod.getParameters().isEmpty() || (staticMethod.getParameters().size() == 1 && staticMethod.getParameters().get(0).getSimpleName().toString() .equals("android.content.Context")); }
public Element getParam(Element element) { if (element instanceof ExecutableElement) { return ((ExecutableElement) element).getParameters().get(0); } return element; }
private static List<String> getComparableParameterNames( ExecutableElement element, boolean skipFirst) { List<? extends VariableElement> parameters = element.getParameters(); if (skipFirst) { parameters = parameters.subList(1, parameters.size()); } List<String> result = new ArrayList<>(parameters.size()); for (VariableElement parameter : parameters) { result.add(parameter.asType().toString()); } return result; }
private static void validateGlideTypeParameters(ExecutableElement executableElement) { if (executableElement.getParameters().size() != 1) { throw new IllegalArgumentException("@GlideType methods must take a" + " RequestBuilder object as their first and only parameter, but given multiple for: " + getQualifiedMethodName(executableElement)); } VariableElement first = executableElement.getParameters().get(0); TypeMirror argumentType = first.asType(); if (!argumentType.toString().startsWith("com.bumptech.glide.RequestBuilder")) { throw new IllegalArgumentException("@GlideType methods must take a" + " RequestBuilder object as their first and only parameter, but given: " + argumentType + " for: " + getQualifiedMethodName(executableElement)); } }
private boolean checkHasNoErrors(ExecutableElement element, Messager messager) { if (element.getModifiers().contains(Modifier.STATIC)) { messager.printMessage(Diagnostic.Kind.ERROR, "Subscriber method must not be static", element); return false; } if (!element.getModifiers().contains(Modifier.PUBLIC)) { messager.printMessage(Diagnostic.Kind.ERROR, "Subscriber method must be public", element); return false; } List<? extends VariableElement> parameters = ((ExecutableElement) element).getParameters(); if (parameters.size() != 1) { messager.printMessage(Diagnostic.Kind.ERROR, "Subscriber method must have exactly 1 parameter", element); return false; } return true; }
@Override public Optional<ExecutableElement> factoryMethod() { Optional<ExecutableElement> staticFactory = ElementFilter.methodsIn(element().getEnclosedElements()).stream() .filter(element -> element.getModifiers().contains(Modifier.STATIC)) .filter(element -> element.getSimpleName().toString().equalsIgnoreCase("create")) .filter(element -> element.getParameters().size() > 0) .filter(element -> element.getReturnType().equals(element().asType())) .findAny(); Optional<ExecutableElement> constructor = ElementFilter.constructorsIn(element().getEnclosedElements()).stream() .filter(element -> element.getParameters().size() > 0) .findAny(); return staticFactory.isPresent() ? staticFactory : constructor; }
static boolean isSetterMethod(Element element) { if (element.getKind() != ElementKind.METHOD) { return false; } ExecutableElement method = (ExecutableElement) element; String methodName = method.getSimpleName().toString(); return PATTERN_STARTS_WITH_SET.matcher(methodName).matches() && method.getParameters().size() == 1; }
private static void validateGlideOptionParameters(ExecutableElement executableElement) { if (executableElement.getParameters().isEmpty()) { throw new IllegalArgumentException("@GlideOption methods must take a " + "BaseRequestOptions<?> object as their first parameter, but " + getQualifiedMethodName(executableElement) + " has none"); } VariableElement first = executableElement.getParameters().get(0); TypeMirror expected = first.asType(); if (!isBaseRequestOptions(expected)) { throw new IllegalArgumentException("@GlideOption methods must take a" + " BaseRequestOptions<?> object as their first parameter, but the first parameter in " + getQualifiedMethodName(executableElement) + " is " + expected); } }
private boolean processBuilderIsInitMethod(ExecutableElement method) { if (isInit != null) { reporter.withElement(method) .error("@Encoding.IsInit duplicate is init method '%s'. Cannot have more than one", method.getSimpleName()); return true; } if (typesReader.get(method.getReturnType()) != Type.Primitive.BOOLEAN) { reporter.withElement(method) .error("@Encoding.IsInit method '%s' must return boolean if ", method.getSimpleName()); return true; } if (!method.getTypeParameters().isEmpty()) { reporter.withElement(method) .error("@Encoding.IsInit method '%s' cannot have type parameters", method.getSimpleName()); return true; } if (!method.getParameters().isEmpty()) { reporter.withElement(method) .error("@Encoding.IsInit method '%s' cannot have parameters", method.getSimpleName()); return true; } List<EncodedElement> captured = new ArrayList<>(); boolean result = processGenericEncodedMethod(method, captured, Tag.IS_INIT, Tag.BUILDER, Tag.PRIVATE); if (result) { this.isInit = captured.get(0); } return result; }
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())); }
@NonNull public Element fromConfigDelegateMethod(@NonNull ExecutableElement method) { return new DelegateMethod.Config(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), getAnnotations(method).getLeft(), method.getParameters().stream().map(p -> ParameterSpec.builder(TypeName.get(p.asType()), p.getSimpleName().toString()).build()).collect(Collectors.toList()), method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()), method.getModifiers(), elements.getDocComment(method)); }
/** Create a MethodInfo from AST (an @Implementation method in a shadow class). */ public MethodInfo(ExecutableElement methodElement) { this.name = cleanMethodName(methodElement); for (VariableElement variableElement : methodElement.getParameters()) { TypeMirror varTypeMirror = variableElement.asType(); String paramType = canonicalize(varTypeMirror); String paramTypeWithoutGenerics = typeWithoutGenerics(paramType); paramTypes.add(paramTypeWithoutGenerics); } }
public void hasSeekBarProgressChangeMethodParameters(ExecutableElement executableElement, ElementValidation valid) { List<? extends VariableElement> parameters = executableElement.getParameters(); boolean seekBarParameterFound = false; boolean fromUserParameterFound = false; boolean progressParameterFound = false; for (VariableElement parameter : parameters) { String parameterType = parameter.asType().toString(); if (parameterType.equals(CanonicalNameConstants.SEEKBAR)) { if (seekBarParameterFound) { continue; if (parameter.asType().getKind() == TypeKind.INT || CanonicalNameConstants.INTEGER.equals(parameterType)) { if (progressParameterFound) { valid.addError("You can have only one parameter of type " + CanonicalNameConstants.INTEGER); continue; if (parameter.asType().getKind() == TypeKind.BOOLEAN || CanonicalNameConstants.BOOLEAN.equals(parameterType)) { if (fromUserParameterFound) { valid.addError("You can have only one parameter of type " + CanonicalNameConstants.BOOLEAN); continue; valid.addError("Unrecognized parameter '" + parameter.toString() + "'. %s signature should be " + executableElement.getSimpleName() + "(" + CanonicalNameConstants.SEEKBAR + " seekBar, int progress, boolean fromUser). The 'fromUser' and 'progress' parameters are optional.");
private boolean isSimpleAccessor(ExecutableElement method) { return method.getParameters().isEmpty() && method.getThrownTypes().isEmpty() && method.getTypeParameters().isEmpty() && method.getReturnType().getKind() != TypeKind.VOID; }
private void collectSimpleUsages(TypeElement type, Map<String, TypeMirror> collected) { for (ExecutableElement method : ElementFilter.methodsIn(elements.getAllMembers(type))) { if (shouldConsideredAsTypeUsage(method)) { collectIfSimpleType(method.getReturnType(), collected); for (VariableElement parameter : method.getParameters()) { collectIfSimpleType(parameter.asType(), collected); } } } }
/** * Generates a Javadoc code block for generated methods that delegate to methods in * {@link GlideExtension}s. * * <p>The generated block looks something like this: * <pre> * <code> * {@literal @see} com.extension.package.name.ExtensionClassName#extensionMethod(arg1, argN) * </code> * </pre> * * @param method The method from the {@link GlideExtension} annotated class that the generated * method this Javadoc will be attached to delegates to. */ CodeBlock generateSeeMethodJavadoc(ExecutableElement method) { // Use the simple name of the containing type instead of just the containing type's TypeMirror // so that we avoid appending <CHILD> or other type arguments to the class and breaking // Javadoc's linking. // With this we get @see RequestOptions#methodName(). // With just ClassName.get(element.getEnclosingElement().asType()), we get: // @see RequestOptions<CHILD>#methodName(). return generateSeeMethodJavadoc(getJavadocSafeName(method.getEnclosingElement()), method.getSimpleName().toString(), method.getParameters()); }
private boolean hasActivityOptions(TypeElement type, int optionsParamPosition) { if (type == null) { return false; } for (ExecutableElement element : ElementFilter.methodsIn(elementUtils.getAllMembers(type))) { if (element.getSimpleName().contentEquals("startActivity")) { List<? extends VariableElement> parameters = element.getParameters(); if (parameters.size() == optionsParamPosition + 1) { VariableElement parameter = parameters.get(optionsParamPosition); if (parameter.asType().toString().equals(CanonicalNameConstants.BUNDLE)) { return true; } } } } return false; }
@Override public void attach(Linker linker) { for (int i = 0; i < method.getParameters().size(); i++) { VariableElement parameter = method.getParameters().get(i); String parameterKey = GeneratorKeys.get(parameter); parameters[i] = linker.requestBinding(parameterKey, method.toString(), getClass().getClassLoader()); } }
@Override public void passParametersToMethodCall(Element element, HasKeyEventCallbackMethods holder, JInvocation methodCall) { ExecutableElement executableElement = (ExecutableElement) element; List<? extends VariableElement> parameters = executableElement.getParameters(); if (parameters.size() == 1) { methodCall.arg(holder.getOnKeyLongPressKeyEventParam()); } } }
List<ExecutableElement> elementMethods = ElementFilter.methodsIn(elementMembers); for (ExecutableElement methodElement : elementMethods) { if (methodElement.getParameters().size() == 0) { String methodNameString = methodElement.getSimpleName().toString(); String methodNameLowerCase = methodNameString.toLowerCase(); if (methodElement.getParameters().size() == 0) { if (methodElement.getReturnType().toString().equals(element.asType().toString())) { return methodNameString;