Refine search
@Override public Void visitExecutable(ExecutableType x, State state) { x.getReturnType().accept(this, state); for (TypeMirror p : x.getParameterTypes()) { p.accept(this, state); } for (TypeMirror t : x.getTypeVariables()) { t.accept(this, state); } return null; }
ExecutableType executableType = (ExecutableType) types.asMemberOf(enclosing, method); List<? extends TypeMirror> resolvedParameterTypes = executableType.getParameterTypes(); List<? extends TypeMirror> resolvedThrownTypes = executableType.getThrownTypes(); TypeMirror resolvedReturnType = executableType.getReturnType();
/** * Check if method respects Java Bean conventions for getter and setters. * * @param methodOfClass method element * * @return whether method respects Java Bean conventions. */ private boolean isGetterOrSetter(Element methodOfClass) { ExecutableType methodType = (ExecutableType) methodOfClass.asType(); String methodSimpleName = methodOfClass.getSimpleName().toString(); List<? extends TypeMirror> methodParameterTypes = methodType.getParameterTypes(); TypeMirror returnType = methodType.getReturnType(); if( methodSimpleName.startsWith("set") && methodParameterTypes.size() == 1 && "void".equalsIgnoreCase( returnType.toString() ) ) { return true; } else if( ( methodSimpleName.startsWith("get") || methodSimpleName.startsWith("is") ) && methodParameterTypes.isEmpty() && !"void".equalsIgnoreCase( returnType.toString() ) ) { return true; } else { return false; } }
private void debugType(TypeMirror typeMirror, Element element, String indent) { if (indent.length() > 20) { return; } if (typeMirror.getKind() == TypeKind.DECLARED) { DeclaredType declaredType = (DeclaredType) typeMirror; logger.finest(format("%stype=%s, asElement=%s, (elementKind=%s, elementClass=%s), typeArgs=%s, enclosing=%s", indent, declaredType, declaredType.asElement(), declaredType.asElement().getKind(), declaredType.asElement().getClass(), declaredType.getTypeArguments(), declaredType.getEnclosingType())); for (TypeMirror tm : declaredType.getTypeArguments()) { if (!tm.equals(typeMirror)) { debugType(tm, element, indent + " "); if (declaredType.asElement().getKind() == ENUM && !element.equals(declaredType.asElement())) { debugElement(declaredType.asElement(), indent + " --> "); } else if (typeMirror.getKind() == TypeKind.EXECUTABLE) { ExecutableType type = (ExecutableType) typeMirror; logger.finest(format("%stype=%s, typeArgs=%s, paramTypes=%s, returnType=%s", indent, type, type.getTypeVariables(), type.getParameterTypes(), type.getReturnType())); for (TypeMirror tm : type.getParameterTypes()) { if (!tm.equals(typeMirror)) { debugType(tm, element, indent + " ");
/** * Get information about methods returning class type of the original class so we can duplicate * them in the generated class for chaining purposes */ protected void collectMethodsReturningClassType(TypeElement modelClass, Types typeUtils) { TypeElement clazz = modelClass; while (clazz.getSuperclass().getKind() != TypeKind.NONE) { for (Element subElement : clazz.getEnclosedElements()) { Set<Modifier> modifiers = subElement.getModifiers(); if (subElement.getKind() == ElementKind.METHOD && !modifiers.contains(Modifier.PRIVATE) && !modifiers.contains(Modifier.FINAL) && !modifiers.contains(Modifier.STATIC)) { TypeMirror methodReturnType = ((ExecutableType) subElement.asType()).getReturnType(); if (methodReturnType.equals(clazz.asType()) || typeUtils.isSubtype(clazz.asType(), methodReturnType)) { ExecutableElement castedSubElement = ((ExecutableElement) subElement); List<? extends VariableElement> params = castedSubElement.getParameters(); String methodName = subElement.getSimpleName().toString(); if (methodName.equals(RESET_METHOD) && params.isEmpty()) { continue; } methodsReturningClassType.add(new MethodInfo(methodName, modifiers, buildParamSpecs(params), castedSubElement.isVarArgs())); } } } clazz = (TypeElement) typeUtils.asElement(clazz.getSuperclass()); } }
@Override public Void visitExecutable(ExecutableElement x, State state) { if (shouldIgnore(x, state)) { // Ignore initializers and methods from Object and RequestFactory return null; } if (!x.getParameters().isEmpty()) { state.poison(x, Messages.factoryNoMethodParameters()); } // resolve type parameters, if any ExecutableType xType = viewIn(checkedElement, x, state); TypeMirror returnType = xType.getReturnType(); if (state.types.isAssignable(returnType, state.requestContextType)) { Element returnTypeElement = state.types.asElement(returnType); if (!returnTypeElement.getKind().equals(ElementKind.INTERFACE)) { state.poison(x, Messages.factoryMustReturnInterface(returnTypeElement.getSimpleName())); } else { TypeElement contextElement = (TypeElement) returnTypeElement; state.maybeScanContext(contextElement); state.requireMapping(contextElement); } } else { state.poison(x, Messages.factoryMustBeAssignable(state.requestContextType.asElement() .getSimpleName())); } return null; }
TypeUtilities tu = info.getTypeUtilities(); for (Element e : elements) { if ((e.getKind() == CONSTRUCTOR || e.getKind() == METHOD) && name.contentEquals(e.getSimpleName())) { List<? extends VariableElement> params = ((ExecutableElement) e).getParameters(); int parSize = params.size(); boolean varArgs = ((ExecutableElement) e).isVarArgs(); if (!varArgs && (parSize < argTypes.length)) { continue; } else { ExecutableType eType = (ExecutableType) asMemberOf(e, type, types); Iterator<? extends TypeMirror> parIt = eType.getParameterTypes().iterator(); TypeMirror param = null; for (int i = 0; i <= argTypes.length; i++) { if (parIt.hasNext()) { param = parIt.next(); if (!parIt.hasNext() && param.getKind() == TypeKind.ARRAY) { param = ((ArrayType) param).getComponentType(); Iterator<? extends TypeMirror> tIt = eType.getParameterTypes().iterator(); for (Iterator<? extends VariableElement> it = params.iterator(); it.hasNext();) { VariableElement ve = it.next(); break; if (argTypes[i] == null || argTypes[i].getKind() != TypeKind.ERROR && !types.isAssignable(argTypes[i], param)) { break;
@Override public AnnotationMetaAttribute visitExecutable(ExecutableType t, Element p) { if ( !p.getKind().equals( ElementKind.METHOD ) ) { return null; } String string = p.getSimpleName().toString(); if ( !StringUtil.isProperty( string, TypeUtils.toTypeString( t.getReturnType() ) ) ) { return null; } TypeMirror returnType = t.getReturnType(); return returnType.accept( this, p ); }
private void enumerateFields(final Types types) { final List<ExecutableElement> methods = methods(valueTypeElement); for (final Element member : methods) { if (member.getKind() != ElementKind.METHOD || isStaticOrDefault(member)) { continue; } final ExecutableElement method = (ExecutableElement) member; if (member.getSimpleName().toString().equals("builder")) { final TypeMirror returnType = (method).getReturnType(); // TODO: javac does not seem to want to provide the name of the return type if it is not yet present and generic if (!isGeneric && !returnType.toString().equals(concreteBuilderName) && !returnType.toString().equals(fullyQualifiedBuilderName)) { throw new AutoMatterProcessorException( "builder() return type must be " + concreteBuilderName, valueTypeElement); } toBuilder = true; continue; } verifyResolved(method.getReturnType()); fields.add(method); // Resolve inherited members final ExecutableType methodType = (ExecutableType) types.asMemberOf(valueType, member); final TypeMirror fieldType = methodType.getReturnType(); // Resolve types fieldTypes.put(method, TypeName.get(fieldType)); } }
public MethodItem(int substitutionOffset, ExecutableElement element, boolean isInherited, boolean isDeprecated) { super(substitutionOffset); this.elementHandle = ElementHandle.create(element); this.isDeprecated = isDeprecated; this.isInherited = isInherited; this.simpleName = element.getSimpleName().toString(); this.modifiers = element.getModifiers(); this.params = new ArrayList<ParamDesc>(); Iterator<? extends VariableElement> it = element.getParameters().iterator(); Iterator<? extends TypeMirror> tIt = ((ExecutableType) element.asType()).getParameterTypes().iterator(); while(it.hasNext() && tIt.hasNext()) { TypeMirror tm = tIt.next(); this.params.add(new ParamDesc(tm.toString(), getTypeName(tm, false, element.isVarArgs() && !tIt.hasNext()).toString(), it.next().getSimpleName().toString())); } TypeMirror retType = element.getReturnType(); this.typeName = getTypeName(retType, false).toString(); this.isPrimitive = retType.getKind().isPrimitive() || retType.getKind() == TypeKind.VOID; }
public static Method create(ExecutableElement elt) { TypeElement typeElt = (TypeElement)elt.getEnclosingElement(); String name = elt.getSimpleName().toString(); Name fqn = Name.parse(typeElt.getQualifiedName().toString()); ArrayList<String> parameterTypes = new ArrayList<String>(); for (TypeMirror parameterType : ((ExecutableType)elt.asType()).getParameterTypes()) { parameterTypes.add(parameterType.toString()); } return new Method(fqn, name, parameterTypes); }
flags.remove(Modifier.DEFAULT); ExecutableType et = (ExecutableType) method.asType(); try { et = (ExecutableType) copy.getTypes().asMemberOf(asMemberOf, method); } catch (IllegalArgumentException iae) { for (TypeVariable typeVariable : et.getTypeVariables()) { List<ExpressionTree> bounds = new ArrayList<ExpressionTree>(); TypeMirror bound = typeVariable.getUpperBound(); if (bound.getKind() != TypeKind.NULL) { if (bound.getKind() == TypeKind.DECLARED) { ClassSymbol boundSymbol = (ClassSymbol) ((DeclaredType) bound).asElement(); if (boundSymbol.getSimpleName().length() == 0 && (boundSymbol.flags() & Flags.COMPOUND) != 0) { typeParams.add(make.TypeParameter(typeVariable.asElement().getSimpleName(), bounds)); Tree returnType = make.Type(et.getReturnType()); boolean isVarArgs = method.isVarArgs(); Iterator<? extends VariableElement> formArgNames = method.getParameters().iterator(); Iterator<? extends TypeMirror> formArgTypes = et.getParameterTypes().iterator(); ModifiersTree parameterModifiers = make.Modifiers(EnumSet.noneOf(Modifier.class)); while (formArgNames.hasNext() && formArgTypes.hasNext()) { for (TypeMirror tm : et.getThrownTypes()) { throwsList.add((ExpressionTree) make.Type(tm));
TreeMaker make = copy.getTreeMaker(); CodeStyle cs = DiffContext.getCodeStyle(copy); Set<Modifier> mods = EnumSet.of(clazz.getKind() == ElementKind.ENUM ? Modifier.PRIVATE : Modifier.PUBLIC); List<VariableTree> parameters = new ArrayList<VariableTree>(); LinkedList<StatementTree> statements = new LinkedList<StatementTree>(); List<TypeParameterTree> typeParams = new LinkedList<TypeParameterTree>(); for (VariableElement ve : fields) { TypeMirror type = copy.getTypes().asMemberOf((DeclaredType)clazz.asType(), ve); if (isDefault) { statements.add(make.ExpressionStatement(make.Assignment(make.MemberSelect(make.Identifier("this"), ve.getSimpleName()), make.Literal(defaultValue(type))))); //NOI18N ExecutableType constructorType = clazz.getSuperclass().getKind() == TypeKind.DECLARED && ((DeclaredType) clazz.getSuperclass()).asElement() == constructor.getEnclosingElement() ? (ExecutableType) copy.getTypes().asMemberOf((DeclaredType) clazz.getSuperclass(), constructor) : null; if (!constructor.getParameters().isEmpty()) { List<ExpressionTree> arguments = new ArrayList<ExpressionTree>(); Iterator<? extends VariableElement> parameterElements = constructor.getParameters().iterator(); Iterator<? extends TypeMirror> parameterTypes = constructorType != null ? constructorType.getParameterTypes().iterator() : null; while (parameterElements.hasNext()) { VariableElement ve = parameterElements.next(); constructorType = constructorType != null ? constructorType : (ExecutableType) constructor.asType(); for (TypeMirror th : constructorType.getThrownTypes()) { throwsList.add((ExpressionTree) make.Type(th));
if (method.getParameters().size() == 1 && method.getModifiers().contains(Modifier.PUBLIC) && !method.getModifiers().contains(Modifier.STATIC)) { boolean validReturnType = method.getReturnType().getKind() == TypeKind.VOID; if (!validReturnType) { ExecutableType memberMethod = (ExecutableType) context.type.asMemberOf(parentType, method); TypeMirror memberReturnType = memberMethod.getReturnType(); if (memberReturnType.getKind() == TypeKind.TYPEVAR) { memberReturnType = ((TypeVariable) memberReturnType).getUpperBound(); validReturnType = context.type.isSameType(memberReturnType, parentType);
@Override public boolean test(ExecutableElement element) { if (element.getParameters().size() != 1) { return false; } if (!element.getSimpleName().contentEquals("mergeFrom")) { return false; } ExecutableType method = (ExecutableType) types.asMemberOf(builder, element); if (!types.isSubtype(parameter, method.getParameterTypes().get(0))) { return false; } return true; } }
@Override public String resolveMethodLink(ExecutableElement elt, Coordinate coordinate) { TypeElement typeElt = (TypeElement)elt.getEnclosingElement(); String link = resolveTypeLink(typeElt, coordinate); if (link != null) if (link.contains("cheatsheet")) link = link + '#' + java.beans.Introspector.decapitalize(elt.getSimpleName().toString().substring(3)); else { StringBuilder anchor = new StringBuilder('#' + elt.getSimpleName().toString() + "("); TypeMirror type = elt.asType(); ExecutableType methodType = (ExecutableType)env.getTypeUtils().erasure(type); List<? extends TypeMirror> parameterTypes = methodType.getParameterTypes(); IntStream.range(0, parameterTypes.size()-1).forEach(index -> { if(index > 0) anchor.append(",%20"); //drop preceding annotations as they mess up linking String[] splitted = parameterTypes.get(index).toString().split(" :: "); anchor.append(splitted[splitted.length - 1]); }); anchor.append(')'); link = link + anchor.toString(); } return link; }
/** * Returns whether the given surrounding type has a (static) method (with the given suffix) to check the validity of an instance of the given element type. */ @Pure protected static boolean hasMethodToCheckValidity(@Nonnull DeclaredType declaredType, @Nonnull TypeMirror elementType, boolean onlyStatic, @Nonnull String suffix) { for (@Nonnull ExecutableElement inheritedMethod : ProcessingUtility.getAllMethods((TypeElement) declaredType.asElement())) { if (inheritedMethod.getThrownTypes().isEmpty() && inheritedMethod.getSimpleName().contentEquals("isValid" + suffix) && !inheritedMethod.getModifiers().contains(Modifier.PRIVATE) && (!onlyStatic || inheritedMethod.getModifiers().contains(Modifier.STATIC)) && inheritedMethod.getReturnType().getKind() == TypeKind.BOOLEAN) { final @Nonnull ExecutableType methodType = (ExecutableType) StaticProcessingEnvironment.getTypeUtils().asMemberOf(declaredType, inheritedMethod); if (methodType.getParameterTypes().size() == 1 && StaticProcessingEnvironment.getTypeUtils().isAssignable(elementType, methodType.getParameterTypes().get(0))) { return true; } } } return false; }
@Override protected ExecutableElement doGet(ProcessingEnvironment env) { TypeElement typeElt = env.getElementUtils().getTypeElement(type.name); if (typeElt != null) { next: for (ExecutableElement executableElement : ElementFilter.methodsIn(typeElt.getEnclosedElements())) { if (executableElement.getSimpleName().toString().equals(name)) { List<? extends TypeMirror> parameterTypes = ((ExecutableType)executableElement.asType()).getParameterTypes(); int len = parameterTypes.size(); if (len == this.parameterTypes.size()) { for (int i = 0;i < len;i++) { if (!parameterTypes.get(i).toString().equals(this.parameterTypes.get(i))) { continue next; } } return executableElement; } } } } return null; }
private TypeMirror getCorrectedReturnType(Env env, ExecutableType et, ExecutableElement el, TypeMirror site) { TypeMirror type = et.getReturnType(); if (site.getKind() == TypeKind.DECLARED) { if ("getClass".contentEquals(el.getSimpleName()) && et.getParameterTypes().isEmpty() //NOI18N && type.getKind() == TypeKind.DECLARED && JAVA_LANG_CLASS.contentEquals(((TypeElement) ((DeclaredType) type).asElement()).getQualifiedName()) && ((TypeElement) ((DeclaredType) type).asElement()).getTypeParameters().size() == 1) { Types types = env.getController().getTypes(); type = types.getDeclaredType((TypeElement) ((DeclaredType) type).asElement(), types.getWildcardType(site, null)); } } return type; }
/** * Returns the non-private method with the given name, return type, parameter types and no thrown types in the given type element or null if no such method is found. */ @Pure public static @Nullable ExecutableElement getNonPrivateMethod(@Nonnull TypeElement typeElement, @Nonnull String methodName, @Nonnull Class<?> returnType, @Nonnull @NonNullableElements Class<?>... parameterTypes) { final @Nonnull DeclaredType surroundingType = (DeclaredType) typeElement.asType(); for (@Nonnull ExecutableElement inheritedMethod : getAllMethods(typeElement)) { if (!inheritedMethod.getModifiers().contains(Modifier.PRIVATE) && inheritedMethod.getSimpleName().contentEquals(methodName) && inheritedMethod.getThrownTypes().isEmpty()) { final @Nonnull ExecutableType methodType = (ExecutableType) StaticProcessingEnvironment.getTypeUtils().asMemberOf(surroundingType, inheritedMethod); if (isRawSubtype(methodType.getReturnType(), returnType)) { if (methodType.getParameterTypes().size() == parameterTypes.length) { boolean isAssignable = true; for (int i = 0; i < parameterTypes.length; i++) { final @Nonnull TypeMirror parameterType = methodType.getParameterTypes().get(i); if (parameterType.getKind() == TypeKind.TYPEVAR || !correspond(parameterType, parameterTypes[i])) { isAssignable = false; } } if (isAssignable) { return inheritedMethod; } } } } } return null; }