Refine search
private FunctionInRootNamespaceError rootNamespaceError( ExecutableElement method ) { return new FunctionInRootNamespaceError( method, "Function defined in <%s#%s> cannot be defined in the root namespace. " + "Valid name example: com.acme.my_function", method.getEnclosingElement().getSimpleName(), method.getSimpleName() ); }
public Stream<CompilationMessage> validateReturnType( ExecutableElement method ) { TypeMirror returnType = method.getReturnType(); if ( !allowedTypesValidator.test( returnType ) ) { return Stream.of( new ReturnTypeError( method, "Unsupported return type <%s> of function defined in <%s#%s>.", returnType, method.getEnclosingElement(), method.getSimpleName() ) ); } return Stream.empty(); }
/** * 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 String computePath(ExecutableElement element) { String path = element.getSimpleName().toString(); for (Element e = element.getEnclosingElement(); // e.getKind().isClass() || e.getKind().isInterface(); // e = e.getEnclosingElement()) { path = e.getSimpleName() + "." + path; } if (element.getModifiers().contains(Modifier.ABSTRACT)) { return path; } return path + "()"; }
TypeMirror paramType = getParamTypeMirror(parameters.get(0), null); TypeElement paramElement = (TypeElement) processingEnv.getTypeUtils().asElement(paramType); String methodName = method.getSimpleName().toString(); String eventClass = getClassString(paramElement, myPackage) + ".class"; method.getEnclosingElement().getSimpleName() + "." + methodName + "(" + paramElement.getSimpleName() + ")");
private void debugMethod(ExecutableElement method) { logger.finest(format(" method: simpleName=%s, asType=%s, varargs=%s, returnType=%s, enclosingElement=%s, params=%s, typeParams=%s", method.getSimpleName(), method.asType(), method.isVarArgs(), method.getReturnType(), method.getEnclosingElement(), method.getParameters(), method.getTypeParameters())); for (VariableElement variable : method.getParameters()) { logger.finest(format(" variable: name=%s, annotationMirrors=%s, @Option=%s, @Parameters=%s", variable.getSimpleName(), variable.getAnnotationMirrors(), variable.getAnnotation( Option.class), variable.getAnnotation(Parameters.class))); } }
private Stream<CompilationMessage> validateReturnType( ExecutableElement method ) { String streamClassName = Stream.class.getCanonicalName(); TypeMirror streamType = typeUtils.erasure( elementUtils.getTypeElement( streamClassName ).asType() ); TypeMirror returnType = method.getReturnType(); TypeMirror erasedReturnType = typeUtils.erasure( returnType ); TypeMirror voidType = typeUtils.getNoType( TypeKind.VOID ); if ( typeUtils.isSameType( returnType, voidType ) ) { return Stream.empty(); } if ( !typeUtils.isSubtype( erasedReturnType, streamType ) ) { return Stream.of( new ReturnTypeError( method, "Return type of %s#%s must be %s", method.getEnclosingElement().getSimpleName(), method.getSimpleName(), streamClassName ) ); } return recordVisitor.visit( returnType ); }
"The " + element.getSimpleName() + " method annotated with @GlideOption in the " + element.getEnclosingElement().getSimpleName() + " @GlideExtension is using a legacy" + " format that is no longer supported. Please change your method definition so that" + " your @GlideModule annotated methods return BaseRequestOptions<?> objects instead" String methodName = element.getSimpleName().toString(); MethodSpec.Builder builder = MethodSpec.methodBuilder(methodName) .addModifiers(Modifier.PUBLIC) methodArgs.add(element.getSimpleName().toString()); StringBuilder methodLiterals = new StringBuilder(); if (!parameters.isEmpty()) { StringBuilder code = new StringBuilder("return ($T) $T.$L($L, "); args.add(containingClassName); args.add(ClassName.get(element.getEnclosingElement().asType())); args.add(element.getSimpleName().toString()); args.add(extensionRequestOptionsArgument);
checkNotNull(method, "method == null"); Element enclosingClass = method.getEnclosingElement(); if (enclosingClass.getModifiers().contains(Modifier.FINAL)) { throw new IllegalArgumentException("Cannot override method on final class " + enclosingClass); String methodName = method.getSimpleName().toString(); MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(methodName);
if (enclosedElt.getKind() == ElementKind.METHOD) { ExecutableElement methodElt = (ExecutableElement) enclosedElt; if (methodElt.getSimpleName().toString().equals("start") && methodElt.getParameters().isEmpty()) { methodElts.add(methodElt); TypeElement typeElt = (TypeElement) methodElt.getEnclosingElement(); FileObject obj = processingEnv.getFiler().getResource(StandardLocation.SOURCE_PATH, "", typeElt.getQualifiedName().toString().replace('.', '/') + ".java"); File srcFolder = new File(obj.toUri()).getParentFile(); if (isSkipped(typeElt, lang)) { log.write("Skipping " + lang.getExtension() + " translation for " + typeElt.getQualifiedName() + "#" + methodElt.getSimpleName()); continue;
private MethodSpec generateAdditionalRequestManagerMethodNew( ExecutableElement extensionMethod) { String returnType = processorUtil.findClassValuesFromAnnotationOnClassAsNames(extensionMethod, GlideType.class).iterator().next(); ClassName returnTypeClassName = ClassName.bestGuess(returnType); ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(generatedRequestBuilderClassName, returnTypeClassName); return MethodSpec.methodBuilder(extensionMethod.getSimpleName().toString()) .addModifiers(Modifier.PUBLIC) .returns(parameterizedTypeName) .addJavadoc(processorUtil.generateSeeMethodJavadoc(extensionMethod)) .addAnnotation(nonNull()) .addAnnotation(checkResult()) .addStatement( "return ($T) $T.$N(this.as($T.class))", parameterizedTypeName, extensionMethod.getEnclosingElement(), extensionMethod.getSimpleName(), returnTypeClassName) .build(); }
private TypeSpec generateProvidesAdapter(ClassName moduleClassName, ClassName adapterName, ExecutableElement providerMethod, Map<ExecutableElement, ClassName> methodToClassName, Map<String, AtomicInteger> methodNameToNextId, boolean library) { String methodName = providerMethod.getSimpleName().toString(); TypeMirror moduleType = providerMethod.getEnclosingElement().asType(); ClassName className = bindingClassName( adapterName, providerMethod, methodToClassName, methodNameToNextId);
private void processUtilityCandidateMethod(ExecutableElement utilityMethodCandidate, TypeElement originalType) { Name name = utilityMethodCandidate.getSimpleName(); List<? extends VariableElement> parameters = utilityMethodCandidate.getParameters(); TypeElement definingType = (TypeElement) utilityMethodCandidate.getEnclosingElement(); boolean nonFinal = !utilityMethodCandidate.getModifiers().contains(Modifier.FINAL); boolean nonAbstract = !utilityMethodCandidate.getModifiers().contains(Modifier.ABSTRACT);
private MethodSpec generateAdditionalRequestManagerMethodLegacy( ExecutableElement extensionMethod) { String returnType = processorUtil.findClassValuesFromAnnotationOnClassAsNames(extensionMethod, GlideType.class).iterator().next(); ClassName returnTypeClassName = ClassName.bestGuess(returnType); ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(generatedRequestBuilderClassName, returnTypeClassName); return MethodSpec.methodBuilder(extensionMethod.getSimpleName().toString()) .addModifiers(Modifier.PUBLIC) .returns(parameterizedTypeName) .addJavadoc(processorUtil.generateSeeMethodJavadoc(extensionMethod)) .addAnnotation(nonNull()) .addAnnotation(checkResult()) .addStatement( "$T requestBuilder = this.as($T.class)", parameterizedTypeName, returnTypeClassName) .addStatement("$T.$N(requestBuilder)", extensionMethod.getEnclosingElement(), extensionMethod.getSimpleName()) .addStatement("return requestBuilder") .build(); }
public JMethod overrideAnnotatedMethod(ExecutableElement executableElement, GeneratedClassHolder holder) { TypeMirror annotatedClass = holder.getAnnotatedElement().asType(); DeclaredType baseClass = (DeclaredType) executableElement.getEnclosingElement().asType(); String methodName = executableElement.getSimpleName().toString(); AbstractJClass returnType = typeMirrorToJClass(executableElement.getReturnType(), actualTypes); int modifier = elementVisibilityModifierToJMod(executableElement);
TypeElement typeElement = (TypeElement) method.getEnclosingElement(); String typeName = typeElement.getQualifiedName().toString(); ProxyInfo info = map.get(typeName); String methodName = method.getSimpleName().toString(); if (annotation instanceof PermissionsGranted) { int[] value = ((PermissionsGranted) annotation).value();
ExecutableElement m = (ExecutableElement) userObject; StringBuilder sb = new StringBuilder(128); sb.append(typeName(m.getReturnType())).append(" ").append(m.getSimpleName()); sb.append('('); List<? extends VariableElement> parameters = m.getParameters(); pw.print(result); if (m.getEnclosingElement().getKind() == ElementKind.INTERFACE) { pw.print(";"); } else {
target = ValueToBuilderTarget.BUILDER_CONSTRUCTOR; } else if (copyMethod.getModifiers().contains(Modifier.STATIC)) { if (copyMethod.getEnclosingElement().equals(attributeValueType())) { target = ValueToBuilderTarget.VALUE_TYPE; } else { if (copyMethod.getEnclosingElement().equals(attributeValueType())) { target = ValueToBuilderTarget.VALUE_INSTANCE; } else { if (builderMethod.getEnclosingElement().equals(attributeValueType())) { qualifiedBuilderConstructorMethod = String.format("%s.%s", attributeValueType().getQualifiedName(), builderMethod.getSimpleName()); } else { if (builderMethod.getKind() == ElementKind.CONSTRUCTOR) { qualifiedBuilderConstructorMethod = String.format("%s.%s", attributeBuilderType.getQualifiedName(), builderMethod.getSimpleName()); .valueToBuilderMethod(copyMethod.getSimpleName().toString()) .buildMethod(buildMethod.getSimpleName().toString()) .qualifiedValueTypeName(attributeValueType().getQualifiedName().toString())
updateCommandAttributes(result, cmd); result.setAddMethodSubcommands(false); result.withToString(commandClassName + "." + method.getSimpleName()); result.name(method.getSimpleName().toString()); Element cls = method.getEnclosingElement(); if (cls.getAnnotation(Command.class) != null && cls.getAnnotation(Command.class).addMethodSubcommands()) { CommandSpec commandSpec = buildCommand(cls,
private void processGenerationCandidateMethod(ExecutableElement attributeMethodCandidate, TypeElement originalType) { Name name = attributeMethodCandidate.getSimpleName(); if (attributeMethodCandidate.getEnclosingElement().equals(originalType)) { hasNonInheritedAttributes = true;