/** * Returns the list of erased parameter types of the given method as they appear in the given * type. For example, if the method is {@code add(E)} from {@code List<E>} and we ask how it * appears in {@code class NumberList implements List<Number>}, the answer will be * {@code Number}. That will also be the answer for {@code class NumberList<E extends Number> * implements List<E>}. The parameter types are erased since the purpose of this method is to * determine whether two methods are candidates for one to override the other. */ ImmutableList<TypeMirror> erasedParameterTypes(ExecutableElement method, TypeElement in) { if (method.getParameters().isEmpty()) { return ImmutableList.of(); } return new TypeSubstVisitor().erasedParameterTypes(method, in); }
ImmutableList.Builder<TypeMirror> params = ImmutableList.builder(); for (VariableElement param : method.getParameters()) { params.add(typeUtils.erasure(visit(param.asType()))); typeBindings.put(formals.get(i), actuals.get(i)); ImmutableList<TypeMirror> params = erasedParameterTypes(method, element); if (params != null) { return params;
@Override public TypeMirror visitArray(ArrayType t, Void p) { return typeUtils.getArrayType(visit(t.getComponentType())); } }
@Override public TypeMirror visitDeclared(DeclaredType t, Void p) { if (t.getTypeArguments().isEmpty()) { return t; } List<TypeMirror> newArgs = Lists.newArrayList(); for (TypeMirror arg : t.getTypeArguments()) { newArgs.add(visit(arg)); } return typeUtils.getDeclaredType(asTypeElement(t), newArgs.toArray(new TypeMirror[0])); }
@Override public TypeMirror visitTypeVariable(TypeVariable t, Void p) { Element element = typeUtils.asElement(t); if (element instanceof TypeParameterElement) { TypeParameterElement e = (TypeParameterElement) element; if (typeBindings.containsKey(e)) { return visit(typeBindings.get(e)); } } // We erase the upper bound to avoid infinite recursion. We can get away with erasure for // the reasons described above. return visit(typeUtils.erasure(t.getUpperBound())); }