001/*
002 * Copyright (C) 2009 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
005 * in compliance with the License. You may obtain a copy of the License at
006 *
007 * http://www.apache.org/licenses/LICENSE-2.0
008 *
009 * Unless required by applicable law or agreed to in writing, software distributed under the License
010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
011 * or implied. See the License for the specific language governing permissions and limitations under
012 * the License.
013 */
014
015package com.google.common.reflect;
016
017import static com.google.common.base.Preconditions.checkArgument;
018import static com.google.common.base.Preconditions.checkNotNull;
019import static com.google.common.base.Preconditions.checkState;
020import static java.util.Arrays.asList;
021
022import com.google.common.annotations.Beta;
023import com.google.common.base.Joiner;
024import com.google.common.base.Objects;
025import com.google.common.collect.ImmutableMap;
026import com.google.common.collect.Maps;
027import java.lang.reflect.GenericArrayType;
028import java.lang.reflect.ParameterizedType;
029import java.lang.reflect.Type;
030import java.lang.reflect.TypeVariable;
031import java.lang.reflect.WildcardType;
032import java.util.Arrays;
033import java.util.LinkedHashSet;
034import java.util.Map;
035import java.util.Set;
036import java.util.concurrent.atomic.AtomicInteger;
037import javax.annotation.Nullable;
038
039/**
040 * An object of this class encapsulates type mappings from type variables. Mappings are established
041 * with {@link #where} and types are resolved using {@link #resolveType}.
042 *
043 * <p>Note that usually type mappings are already implied by the static type hierarchy (for example,
044 * the {@code E} type variable declared by class {@code List} naturally maps to {@code String} in
045 * the context of {@code class MyStringList implements List<String>}. In such case, prefer to use
046 * {@link TypeToken#resolveType} since it's simpler and more type safe. This class should only be
047 * used when the type mapping isn't implied by the static type hierarchy, but provided through other
048 * means such as an annotation or external configuration file.
049 *
050 * @author Ben Yu
051 * @since 15.0
052 */
053@Beta
054public final class TypeResolver {
055
056  private final TypeTable typeTable;
057
058  public TypeResolver() {
059    this.typeTable = new TypeTable();
060  }
061
062  private TypeResolver(TypeTable typeTable) {
063    this.typeTable = typeTable;
064  }
065
066  static TypeResolver accordingTo(Type type) {
067    return new TypeResolver().where(TypeMappingIntrospector.getTypeMappings(type));
068  }
069
070  /**
071   * Returns a new {@code TypeResolver} with type variables in {@code formal} mapping to types in
072   * {@code actual}.
073   *
074   * <p>For example, if {@code formal} is a {@code TypeVariable T}, and {@code actual} is {@code
075   * String.class}, then {@code new TypeResolver().where(formal, actual)} will
076   * {@linkplain #resolveType resolve} {@code ParameterizedType List<T>} to {@code List<String>},
077   * and resolve {@code Map<T, Something>} to {@code Map<String, Something>} etc. Similarly,
078   * {@code formal} and {@code actual} can be {@code Map<K, V>} and {@code Map<String, Integer>}
079   * respectively, or they can be {@code E[]} and {@code String[]} respectively, or even any
080   * arbitrary combination thereof.
081   *
082   * @param formal The type whose type variables or itself is mapped to other type(s). It's almost
083   *     always a bug if {@code formal} isn't a type variable and contains no type variable. Make
084   *     sure you are passing the two parameters in the right order.
085   * @param actual The type that the formal type variable(s) are mapped to. It can be or contain yet
086   *     other type variables, in which case these type variables will be further resolved if
087   *     corresponding mappings exist in the current {@code TypeResolver} instance.
088   */
089  public TypeResolver where(Type formal, Type actual) {
090    Map<TypeVariableKey, Type> mappings = Maps.newHashMap();
091    populateTypeMappings(mappings, checkNotNull(formal), checkNotNull(actual));
092    return where(mappings);
093  }
094
095  /** Returns a new {@code TypeResolver} with {@code variable} mapping to {@code type}. */
096  TypeResolver where(Map<TypeVariableKey, ? extends Type> mappings) {
097    return new TypeResolver(typeTable.where(mappings));
098  }
099
100  private static void populateTypeMappings(
101      final Map<TypeVariableKey, Type> mappings, Type from, final Type to) {
102    if (from.equals(to)) {
103      return;
104    }
105    new TypeVisitor() {
106      @Override
107      void visitTypeVariable(TypeVariable<?> typeVariable) {
108        mappings.put(new TypeVariableKey(typeVariable), to);
109      }
110
111      @Override
112      void visitWildcardType(WildcardType fromWildcardType) {
113        if (!(to instanceof WildcardType)) {
114          return; // okay to say <?> is anything
115        }
116        WildcardType toWildcardType = (WildcardType) to;
117        Type[] fromUpperBounds = fromWildcardType.getUpperBounds();
118        Type[] toUpperBounds = toWildcardType.getUpperBounds();
119        Type[] fromLowerBounds = fromWildcardType.getLowerBounds();
120        Type[] toLowerBounds = toWildcardType.getLowerBounds();
121        checkArgument(
122            fromUpperBounds.length == toUpperBounds.length
123                && fromLowerBounds.length == toLowerBounds.length,
124            "Incompatible type: %s vs. %s",
125            fromWildcardType,
126            to);
127        for (int i = 0; i < fromUpperBounds.length; i++) {
128          populateTypeMappings(mappings, fromUpperBounds[i], toUpperBounds[i]);
129        }
130        for (int i = 0; i < fromLowerBounds.length; i++) {
131          populateTypeMappings(mappings, fromLowerBounds[i], toLowerBounds[i]);
132        }
133      }
134
135      @Override
136      void visitParameterizedType(ParameterizedType fromParameterizedType) {
137        if (to instanceof WildcardType) {
138          return; // Okay to say Foo<A> is <?>
139        }
140        ParameterizedType toParameterizedType = expectArgument(ParameterizedType.class, to);
141        if (fromParameterizedType.getOwnerType() != null
142            && toParameterizedType.getOwnerType() != null) {
143          populateTypeMappings(
144              mappings, fromParameterizedType.getOwnerType(), toParameterizedType.getOwnerType());
145        }
146        checkArgument(
147            fromParameterizedType.getRawType().equals(toParameterizedType.getRawType()),
148            "Inconsistent raw type: %s vs. %s",
149            fromParameterizedType,
150            to);
151        Type[] fromArgs = fromParameterizedType.getActualTypeArguments();
152        Type[] toArgs = toParameterizedType.getActualTypeArguments();
153        checkArgument(
154            fromArgs.length == toArgs.length,
155            "%s not compatible with %s",
156            fromParameterizedType,
157            toParameterizedType);
158        for (int i = 0; i < fromArgs.length; i++) {
159          populateTypeMappings(mappings, fromArgs[i], toArgs[i]);
160        }
161      }
162
163      @Override
164      void visitGenericArrayType(GenericArrayType fromArrayType) {
165        if (to instanceof WildcardType) {
166          return; // Okay to say A[] is <?>
167        }
168        Type componentType = Types.getComponentType(to);
169        checkArgument(componentType != null, "%s is not an array type.", to);
170        populateTypeMappings(mappings, fromArrayType.getGenericComponentType(), componentType);
171      }
172
173      @Override
174      void visitClass(Class<?> fromClass) {
175        if (to instanceof WildcardType) {
176          return; // Okay to say Foo is <?>
177        }
178        // Can't map from a raw class to anything other than itself or a wildcard.
179        // You can't say "assuming String is Integer".
180        // And we don't support "assuming String is T"; user has to say "assuming T is String".
181        throw new IllegalArgumentException("No type mapping from " + fromClass + " to " + to);
182      }
183    }.visit(from);
184  }
185
186  /**
187   * Resolves all type variables in {@code type} and all downstream types and returns a
188   * corresponding type with type variables resolved.
189   */
190  public Type resolveType(Type type) {
191    checkNotNull(type);
192    if (type instanceof TypeVariable) {
193      return typeTable.resolve((TypeVariable<?>) type);
194    } else if (type instanceof ParameterizedType) {
195      return resolveParameterizedType((ParameterizedType) type);
196    } else if (type instanceof GenericArrayType) {
197      return resolveGenericArrayType((GenericArrayType) type);
198    } else if (type instanceof WildcardType) {
199      return resolveWildcardType((WildcardType) type);
200    } else {
201      // if Class<?>, no resolution needed, we are done.
202      return type;
203    }
204  }
205
206  private Type[] resolveTypes(Type[] types) {
207    Type[] result = new Type[types.length];
208    for (int i = 0; i < types.length; i++) {
209      result[i] = resolveType(types[i]);
210    }
211    return result;
212  }
213
214  private WildcardType resolveWildcardType(WildcardType type) {
215    Type[] lowerBounds = type.getLowerBounds();
216    Type[] upperBounds = type.getUpperBounds();
217    return new Types.WildcardTypeImpl(resolveTypes(lowerBounds), resolveTypes(upperBounds));
218  }
219
220  private Type resolveGenericArrayType(GenericArrayType type) {
221    Type componentType = type.getGenericComponentType();
222    Type resolvedComponentType = resolveType(componentType);
223    return Types.newArrayType(resolvedComponentType);
224  }
225
226  private ParameterizedType resolveParameterizedType(ParameterizedType type) {
227    Type owner = type.getOwnerType();
228    Type resolvedOwner = (owner == null) ? null : resolveType(owner);
229    Type resolvedRawType = resolveType(type.getRawType());
230
231    Type[] args = type.getActualTypeArguments();
232    Type[] resolvedArgs = resolveTypes(args);
233    return Types.newParameterizedTypeWithOwner(
234        resolvedOwner, (Class<?>) resolvedRawType, resolvedArgs);
235  }
236
237  private static <T> T expectArgument(Class<T> type, Object arg) {
238    try {
239      return type.cast(arg);
240    } catch (ClassCastException e) {
241      throw new IllegalArgumentException(arg + " is not a " + type.getSimpleName());
242    }
243  }
244
245  /** A TypeTable maintains mapping from {@link TypeVariable} to types. */
246  private static class TypeTable {
247    private final ImmutableMap<TypeVariableKey, Type> map;
248
249    TypeTable() {
250      this.map = ImmutableMap.of();
251    }
252
253    private TypeTable(ImmutableMap<TypeVariableKey, Type> map) {
254      this.map = map;
255    }
256
257    /** Returns a new {@code TypeResolver} with {@code variable} mapping to {@code type}. */
258    final TypeTable where(Map<TypeVariableKey, ? extends Type> mappings) {
259      ImmutableMap.Builder<TypeVariableKey, Type> builder = ImmutableMap.builder();
260      builder.putAll(map);
261      for (Map.Entry<TypeVariableKey, ? extends Type> mapping : mappings.entrySet()) {
262        TypeVariableKey variable = mapping.getKey();
263        Type type = mapping.getValue();
264        checkArgument(!variable.equalsType(type), "Type variable %s bound to itself", variable);
265        builder.put(variable, type);
266      }
267      return new TypeTable(builder.build());
268    }
269
270    final Type resolve(final TypeVariable<?> var) {
271      final TypeTable unguarded = this;
272      TypeTable guarded =
273          new TypeTable() {
274            @Override
275            public Type resolveInternal(TypeVariable<?> intermediateVar, TypeTable forDependent) {
276              if (intermediateVar.getGenericDeclaration().equals(var.getGenericDeclaration())) {
277                return intermediateVar;
278              }
279              return unguarded.resolveInternal(intermediateVar, forDependent);
280            }
281          };
282      return resolveInternal(var, guarded);
283    }
284
285    /**
286     * Resolves {@code var} using the encapsulated type mapping. If it maps to yet another
287     * non-reified type or has bounds, {@code forDependants} is used to do further resolution, which
288     * doesn't try to resolve any type variable on generic declarations that are already being
289     * resolved.
290     *
291     * <p>Should only be called and overridden by {@link #resolve(TypeVariable)}.
292     */
293    Type resolveInternal(TypeVariable<?> var, TypeTable forDependants) {
294      Type type = map.get(new TypeVariableKey(var));
295      if (type == null) {
296        Type[] bounds = var.getBounds();
297        if (bounds.length == 0) {
298          return var;
299        }
300        Type[] resolvedBounds = new TypeResolver(forDependants).resolveTypes(bounds);
301        /*
302         * We'd like to simply create our own TypeVariable with the newly resolved bounds. There's
303         * just one problem: Starting with JDK 7u51, the JDK TypeVariable's equals() method doesn't
304         * recognize instances of our TypeVariable implementation. This is a problem because users
305         * compare TypeVariables from the JDK against TypeVariables returned by TypeResolver. To
306         * work with all JDK versions, TypeResolver must return the appropriate TypeVariable
307         * implementation in each of the three possible cases:
308         *
309         * 1. Prior to JDK 7u51, the JDK TypeVariable implementation interoperates with ours.
310         * Therefore, we can always create our own TypeVariable.
311         *
312         * 2. Starting with JDK 7u51, the JDK TypeVariable implementations does not interoperate
313         * with ours. Therefore, we have to be careful about whether we create our own TypeVariable:
314         *
315         * 2a. If the resolved types are identical to the original types, then we can return the
316         * original, identical JDK TypeVariable. By doing so, we sidestep the problem entirely.
317         *
318         * 2b. If the resolved types are different from the original types, things are trickier. The
319         * only way to get a TypeVariable instance for the resolved types is to create our own. The
320         * created TypeVariable will not interoperate with any JDK TypeVariable. But this is OK: We
321         * don't _want_ our new TypeVariable to be equal to the JDK TypeVariable because it has
322         * _different bounds_ than the JDK TypeVariable. And it wouldn't make sense for our new
323         * TypeVariable to be equal to any _other_ JDK TypeVariable, either, because any other JDK
324         * TypeVariable must have a different declaration or name. The only TypeVariable that our
325         * new TypeVariable _will_ be equal to is an equivalent TypeVariable that was also created
326         * by us. And that equality is guaranteed to hold because it doesn't involve the JDK
327         * TypeVariable implementation at all.
328         */
329        if (Types.NativeTypeVariableEquals.NATIVE_TYPE_VARIABLE_ONLY
330            && Arrays.equals(bounds, resolvedBounds)) {
331          return var;
332        }
333        return Types.newArtificialTypeVariable(
334            var.getGenericDeclaration(), var.getName(), resolvedBounds);
335      }
336      // in case the type is yet another type variable.
337      return new TypeResolver(forDependants).resolveType(type);
338    }
339  }
340
341  private static final class TypeMappingIntrospector extends TypeVisitor {
342
343    private static final WildcardCapturer wildcardCapturer = new WildcardCapturer();
344
345    private final Map<TypeVariableKey, Type> mappings = Maps.newHashMap();
346
347    /**
348     * Returns type mappings using type parameters and type arguments found in the generic
349     * superclass and the super interfaces of {@code contextClass}.
350     */
351    static ImmutableMap<TypeVariableKey, Type> getTypeMappings(Type contextType) {
352      TypeMappingIntrospector introspector = new TypeMappingIntrospector();
353      introspector.visit(wildcardCapturer.capture(contextType));
354      return ImmutableMap.copyOf(introspector.mappings);
355    }
356
357    @Override
358    void visitClass(Class<?> clazz) {
359      visit(clazz.getGenericSuperclass());
360      visit(clazz.getGenericInterfaces());
361    }
362
363    @Override
364    void visitParameterizedType(ParameterizedType parameterizedType) {
365      Class<?> rawClass = (Class<?>) parameterizedType.getRawType();
366      TypeVariable<?>[] vars = rawClass.getTypeParameters();
367      Type[] typeArgs = parameterizedType.getActualTypeArguments();
368      checkState(vars.length == typeArgs.length);
369      for (int i = 0; i < vars.length; i++) {
370        map(new TypeVariableKey(vars[i]), typeArgs[i]);
371      }
372      visit(rawClass);
373      visit(parameterizedType.getOwnerType());
374    }
375
376    @Override
377    void visitTypeVariable(TypeVariable<?> t) {
378      visit(t.getBounds());
379    }
380
381    @Override
382    void visitWildcardType(WildcardType t) {
383      visit(t.getUpperBounds());
384    }
385
386    private void map(final TypeVariableKey var, final Type arg) {
387      if (mappings.containsKey(var)) {
388        // Mapping already established
389        // This is possible when following both superClass -> enclosingClass
390        // and enclosingclass -> superClass paths.
391        // Since we follow the path of superclass first, enclosing second,
392        // superclass mapping should take precedence.
393        return;
394      }
395      // First, check whether var -> arg forms a cycle
396      for (Type t = arg; t != null; t = mappings.get(TypeVariableKey.forLookup(t))) {
397        if (var.equalsType(t)) {
398          // cycle detected, remove the entire cycle from the mapping so that
399          // each type variable resolves deterministically to itself.
400          // Otherwise, a F -> T cycle will end up resolving both F and T
401          // nondeterministically to either F or T.
402          for (Type x = arg; x != null; x = mappings.remove(TypeVariableKey.forLookup(x))) {}
403          return;
404        }
405      }
406      mappings.put(var, arg);
407    }
408  }
409
410  // This is needed when resolving types against a context with wildcards
411  // For example:
412  // class Holder<T> {
413  //   void set(T data) {...}
414  // }
415  // Holder<List<?>> should *not* resolve the set() method to set(List<?> data).
416  // Instead, it should create a capture of the wildcard so that set() rejects any List<T>.
417  private static class WildcardCapturer {
418
419    private final AtomicInteger id;
420
421    WildcardCapturer() {
422      this(new AtomicInteger());
423    }
424
425    private WildcardCapturer(AtomicInteger id) {
426      this.id = id;
427    }
428
429    final Type capture(Type type) {
430      checkNotNull(type);
431      if (type instanceof Class) {
432        return type;
433      }
434      if (type instanceof TypeVariable) {
435        return type;
436      }
437      if (type instanceof GenericArrayType) {
438        GenericArrayType arrayType = (GenericArrayType) type;
439        return Types.newArrayType(
440            notForTypeVariable().capture(arrayType.getGenericComponentType()));
441      }
442      if (type instanceof ParameterizedType) {
443        ParameterizedType parameterizedType = (ParameterizedType) type;
444        Class<?> rawType = (Class<?>) parameterizedType.getRawType();
445        TypeVariable<?>[] typeVars = rawType.getTypeParameters();
446        Type[] typeArgs = parameterizedType.getActualTypeArguments();
447        for (int i = 0; i < typeArgs.length; i++) {
448          typeArgs[i] = forTypeVariable(typeVars[i]).capture(typeArgs[i]);
449        }
450        return Types.newParameterizedTypeWithOwner(
451            notForTypeVariable().captureNullable(parameterizedType.getOwnerType()),
452            rawType, typeArgs);
453      }
454      if (type instanceof WildcardType) {
455        WildcardType wildcardType = (WildcardType) type;
456        Type[] lowerBounds = wildcardType.getLowerBounds();
457        if (lowerBounds.length == 0) { // ? extends something changes to capture-of
458          return captureAsTypeVariable(wildcardType.getUpperBounds());
459        } else {
460          // TODO(benyu): handle ? super T somehow.
461          return type;
462        }
463      }
464      throw new AssertionError("must have been one of the known types");
465    }
466
467    TypeVariable<?> captureAsTypeVariable(Type[] upperBounds) {
468          String name =
469              "capture#"
470                  + id.incrementAndGet()
471                  + "-of ? extends "
472                  + Joiner.on('&').join(upperBounds);
473      return Types.newArtificialTypeVariable(WildcardCapturer.class, name, upperBounds);
474    }
475
476    private WildcardCapturer forTypeVariable(final TypeVariable<?> typeParam) {
477      return new WildcardCapturer(id) {
478        @Override TypeVariable<?> captureAsTypeVariable(Type[] upperBounds) {
479          Set<Type> combined = new LinkedHashSet<>(asList(upperBounds));
480          // Since this is an artifically generated type variable, we don't bother checking
481          // subtyping between declared type bound and actual type bound. So it's possible that we
482          // may generate something like <capture#1-of ? extends Foo&SubFoo>.
483          // Checking subtype between declared and actual type bounds
484          // adds recursive isSubtypeOf() call and feels complicated.
485          // There is no contract one way or another as long as isSubtypeOf() works as expected.
486          combined.addAll(asList(typeParam.getBounds()));
487          if (combined.size() > 1) { // Object is implicit and only useful if it's the only bound.
488            combined.remove(Object.class);
489          }
490          return super.captureAsTypeVariable(combined.toArray(new Type[0]));
491        }
492      };
493    }
494
495    private WildcardCapturer notForTypeVariable() {
496      return new WildcardCapturer(id);
497    }
498
499    private Type captureNullable(@Nullable Type type) {
500      if (type == null) {
501        return null;
502      }
503      return capture(type);
504    }
505  }
506
507  /**
508   * Wraps around {@code TypeVariable<?>} to ensure that any two type variables are equal as long as
509   * they are declared by the same {@link java.lang.reflect.GenericDeclaration} and have the same
510   * name, even if their bounds differ.
511   *
512   * <p>While resolving a type variable from a {@code var -> type} map, we don't care whether the
513   * type variable's bound has been partially resolved. As long as the type variable "identity"
514   * matches.
515   *
516   * <p>On the other hand, if for example we are resolving {@code List<A extends B>} to {@code
517   * List<A extends String>}, we need to compare that {@code <A extends B>} is unequal to {@code <A
518   * extends String>} in order to decide to use the transformed type instead of the original type.
519   */
520  static final class TypeVariableKey {
521    private final TypeVariable<?> var;
522
523    TypeVariableKey(TypeVariable<?> var) {
524      this.var = checkNotNull(var);
525    }
526
527    @Override
528    public int hashCode() {
529      return Objects.hashCode(var.getGenericDeclaration(), var.getName());
530    }
531
532    @Override
533    public boolean equals(Object obj) {
534      if (obj instanceof TypeVariableKey) {
535        TypeVariableKey that = (TypeVariableKey) obj;
536        return equalsTypeVariable(that.var);
537      } else {
538        return false;
539      }
540    }
541
542    @Override
543    public String toString() {
544      return var.toString();
545    }
546
547    /** Wraps {@code t} in a {@code TypeVariableKey} if it's a type variable. */
548    static TypeVariableKey forLookup(Type t) {
549      if (t instanceof TypeVariable) {
550        return new TypeVariableKey((TypeVariable<?>) t);
551      } else {
552        return null;
553      }
554    }
555
556    /**
557     * Returns true if {@code type} is a {@code TypeVariable} with the same name and declared by the
558     * same {@code GenericDeclaration}.
559     */
560    boolean equalsType(Type type) {
561      if (type instanceof TypeVariable) {
562        return equalsTypeVariable((TypeVariable<?>) type);
563      } else {
564        return false;
565      }
566    }
567
568    private boolean equalsTypeVariable(TypeVariable<?> that) {
569      return var.getGenericDeclaration().equals(that.getGenericDeclaration())
570          && var.getName().equals(that.getName());
571    }
572  }
573}