Initial commit

sources/com/google/common/reflect/Element.java

@@ -0,0 +1,88 @@
+package com.google.common.reflect;
+
+import com.google.common.base.Preconditions;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Member;
+
+/* loaded from: classes.dex */
+class Element extends AccessibleObject implements Member {
+    private final AccessibleObject a;
+    private final Member b;
+
+    <M extends AccessibleObject & Member> Element(M m) {
+        Preconditions.a(m);
+        this.a = m;
+        this.b = m;
+    }
+
+    public TypeToken<?> a() {
+        return TypeToken.of((Class) getDeclaringClass());
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Element)) {
+            return false;
+        }
+        Element element = (Element) obj;
+        return a().equals(element.a()) && this.b.equals(element.b);
+    }
+
+    @Override // java.lang.reflect.AccessibleObject, java.lang.reflect.AnnotatedElement
+    public final <A extends Annotation> A getAnnotation(Class<A> cls) {
+        return (A) this.a.getAnnotation(cls);
+    }
+
+    @Override // java.lang.reflect.AccessibleObject, java.lang.reflect.AnnotatedElement
+    public final Annotation[] getAnnotations() {
+        return this.a.getAnnotations();
+    }
+
+    @Override // java.lang.reflect.AccessibleObject, java.lang.reflect.AnnotatedElement
+    public final Annotation[] getDeclaredAnnotations() {
+        return this.a.getDeclaredAnnotations();
+    }
+
+    @Override // java.lang.reflect.Member
+    public Class<?> getDeclaringClass() {
+        return this.b.getDeclaringClass();
+    }
+
+    @Override // java.lang.reflect.Member
+    public final int getModifiers() {
+        return this.b.getModifiers();
+    }
+
+    @Override // java.lang.reflect.Member
+    public final String getName() {
+        return this.b.getName();
+    }
+
+    public int hashCode() {
+        return this.b.hashCode();
+    }
+
+    @Override // java.lang.reflect.AccessibleObject
+    public final boolean isAccessible() {
+        return this.a.isAccessible();
+    }
+
+    @Override // java.lang.reflect.AccessibleObject, java.lang.reflect.AnnotatedElement
+    public final boolean isAnnotationPresent(Class<? extends Annotation> cls) {
+        return this.a.isAnnotationPresent(cls);
+    }
+
+    @Override // java.lang.reflect.Member
+    public final boolean isSynthetic() {
+        return this.b.isSynthetic();
+    }
+
+    @Override // java.lang.reflect.AccessibleObject
+    public final void setAccessible(boolean z) throws SecurityException {
+        this.a.setAccessible(z);
+    }
+
+    public String toString() {
+        return this.b.toString();
+    }
+}

sources/com/google/common/reflect/Invokable.java

@@ -0,0 +1,74 @@
+package com.google.common.reflect;
+
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.GenericDeclaration;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.util.Arrays;
+
+/* loaded from: classes.dex */
+public abstract class Invokable<T, R> extends Element implements GenericDeclaration {
+
+    static class ConstructorInvokable<T> extends Invokable<T, T> {
+        final Constructor<?> c;
+
+        ConstructorInvokable(Constructor<?> constructor) {
+            super(constructor);
+            this.c = constructor;
+        }
+
+        private boolean c() {
+            Class<?> declaringClass = this.c.getDeclaringClass();
+            if (declaringClass.getEnclosingConstructor() != null) {
+                return true;
+            }
+            return declaringClass.getEnclosingMethod() != null ? !Modifier.isStatic(r1.getModifiers()) : (declaringClass.getEnclosingClass() == null || Modifier.isStatic(declaringClass.getModifiers())) ? false : true;
+        }
+
+        Type[] b() {
+            Type[] genericParameterTypes = this.c.getGenericParameterTypes();
+            if (genericParameterTypes.length <= 0 || !c()) {
+                return genericParameterTypes;
+            }
+            Class<?>[] parameterTypes = this.c.getParameterTypes();
+            return (genericParameterTypes.length == parameterTypes.length && parameterTypes[0] == getDeclaringClass().getEnclosingClass()) ? (Type[]) Arrays.copyOfRange(genericParameterTypes, 1, genericParameterTypes.length) : genericParameterTypes;
+        }
+
+        @Override // java.lang.reflect.GenericDeclaration
+        public final TypeVariable<?>[] getTypeParameters() {
+            TypeVariable<Class<? super T>>[] typeParameters = getDeclaringClass().getTypeParameters();
+            TypeVariable<Constructor<?>>[] typeParameters2 = this.c.getTypeParameters();
+            TypeVariable<?>[] typeVariableArr = new TypeVariable[typeParameters.length + typeParameters2.length];
+            System.arraycopy(typeParameters, 0, typeVariableArr, 0, typeParameters.length);
+            System.arraycopy(typeParameters2, 0, typeVariableArr, typeParameters.length, typeParameters2.length);
+            return typeVariableArr;
+        }
+    }
+
+    static class MethodInvokable<T> extends Invokable<T, Object> {
+        final Method c;
+
+        MethodInvokable(Method method) {
+            super(method);
+            this.c = method;
+        }
+
+        @Override // java.lang.reflect.GenericDeclaration
+        public final TypeVariable<?>[] getTypeParameters() {
+            return this.c.getTypeParameters();
+        }
+    }
+
+    <M extends AccessibleObject & Member> Invokable(M m) {
+        super(m);
+    }
+
+    @Override // com.google.common.reflect.Element, java.lang.reflect.Member
+    public final Class<? super T> getDeclaringClass() {
+        return (Class<? super T>) super.getDeclaringClass();
+    }
+}

sources/com/google/common/reflect/Reflection.java

@@ -0,0 +1,14 @@
+package com.google.common.reflect;
+
+import com.google.common.base.Preconditions;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+
+/* loaded from: classes.dex */
+public final class Reflection {
+    public static <T> T a(Class<T> cls, InvocationHandler invocationHandler) {
+        Preconditions.a(invocationHandler);
+        Preconditions.a(cls.isInterface(), "%s is not an interface", cls);
+        return cls.cast(Proxy.newProxyInstance(cls.getClassLoader(), new Class[]{cls}, invocationHandler));
+    }
+}

sources/com/google/common/reflect/TypeCapture.java

@@ -0,0 +1,17 @@
+package com.google.common.reflect;
+
+import com.google.common.base.Preconditions;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+/* loaded from: classes.dex */
+abstract class TypeCapture<T> {
+    TypeCapture() {
+    }
+
+    final Type capture() {
+        Type genericSuperclass = getClass().getGenericSuperclass();
+        Preconditions.a(genericSuperclass instanceof ParameterizedType, "%s isn't parameterized", genericSuperclass);
+        return ((ParameterizedType) genericSuperclass).getActualTypeArguments()[0];
+    }
+}

sources/com/google/common/reflect/TypeParameter.java

@@ -0,0 +1,8 @@
+package com.google.common.reflect;
+
+import java.lang.reflect.TypeVariable;
+
+/* loaded from: classes.dex */
+public abstract class TypeParameter<T> extends TypeCapture<T> {
+    final TypeVariable<?> a;
+}

sources/com/google/common/reflect/TypeResolver.java

@@ -0,0 +1,377 @@
+package com.google.common.reflect;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Objects;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+import com.google.common.reflect.Types;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/* loaded from: classes.dex */
+public final class TypeResolver {
+    private final TypeTable a;
+
+    private static class WildcardCapturer {
+        private final AtomicInteger a;
+
+        private Type b(Type type) {
+            if (type == null) {
+                return null;
+            }
+            return a(type);
+        }
+
+        final Type a(Type type) {
+            Preconditions.a(type);
+            if ((type instanceof Class) || (type instanceof TypeVariable)) {
+                return type;
+            }
+            if (type instanceof GenericArrayType) {
+                return Types.b(a().a(((GenericArrayType) type).getGenericComponentType()));
+            }
+            if (!(type instanceof ParameterizedType)) {
+                if (!(type instanceof WildcardType)) {
+                    throw new AssertionError("must have been one of the known types");
+                }
+                WildcardType wildcardType = (WildcardType) type;
+                return wildcardType.getLowerBounds().length == 0 ? a(wildcardType.getUpperBounds()) : type;
+            }
+            ParameterizedType parameterizedType = (ParameterizedType) type;
+            Class cls = (Class) parameterizedType.getRawType();
+            TypeVariable<?>[] typeParameters = cls.getTypeParameters();
+            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+            for (int i = 0; i < actualTypeArguments.length; i++) {
+                actualTypeArguments[i] = a(typeParameters[i]).a(actualTypeArguments[i]);
+            }
+            return Types.a(a().b(parameterizedType.getOwnerType()), (Class<?>) cls, actualTypeArguments);
+        }
+
+        WildcardCapturer() {
+            this(new AtomicInteger());
+        }
+
+        private WildcardCapturer(AtomicInteger atomicInteger) {
+            this.a = atomicInteger;
+        }
+
+        TypeVariable<?> a(Type[] typeArr) {
+            return Types.a(WildcardCapturer.class, "capture#" + this.a.incrementAndGet() + "-of ? extends " + Joiner.a('&').a((Object[]) typeArr), typeArr);
+        }
+
+        private WildcardCapturer a(final TypeVariable<?> typeVariable) {
+            return new WildcardCapturer(this, this.a) { // from class: com.google.common.reflect.TypeResolver.WildcardCapturer.1
+                @Override // com.google.common.reflect.TypeResolver.WildcardCapturer
+                TypeVariable<?> a(Type[] typeArr) {
+                    LinkedHashSet linkedHashSet = new LinkedHashSet(Arrays.asList(typeArr));
+                    linkedHashSet.addAll(Arrays.asList(typeVariable.getBounds()));
+                    if (linkedHashSet.size() > 1) {
+                        linkedHashSet.remove(Object.class);
+                    }
+                    return super.a((Type[]) linkedHashSet.toArray(new Type[0]));
+                }
+            };
+        }
+
+        private WildcardCapturer a() {
+            return new WildcardCapturer(this.a);
+        }
+    }
+
+    static TypeResolver b(Type type) {
+        return new TypeResolver().a(TypeMappingIntrospector.a(type));
+    }
+
+    private static class TypeTable {
+        private final ImmutableMap<TypeVariableKey, Type> a;
+
+        TypeTable() {
+            this.a = ImmutableMap.of();
+        }
+
+        final TypeTable a(Map<TypeVariableKey, ? extends Type> map) {
+            ImmutableMap.Builder builder = ImmutableMap.builder();
+            builder.a(this.a);
+            for (Map.Entry<TypeVariableKey, ? extends Type> entry : map.entrySet()) {
+                TypeVariableKey key = entry.getKey();
+                Type value = entry.getValue();
+                Preconditions.a(!key.a(value), "Type variable %s bound to itself", key);
+                builder.a(key, value);
+            }
+            return new TypeTable(builder.a());
+        }
+
+        private TypeTable(ImmutableMap<TypeVariableKey, Type> immutableMap) {
+            this.a = immutableMap;
+        }
+
+        final Type a(final TypeVariable<?> typeVariable) {
+            return a(typeVariable, new TypeTable(this) { // from class: com.google.common.reflect.TypeResolver.TypeTable.1
+                @Override // com.google.common.reflect.TypeResolver.TypeTable
+                public Type a(TypeVariable<?> typeVariable2, TypeTable typeTable) {
+                    return typeVariable2.getGenericDeclaration().equals(typeVariable.getGenericDeclaration()) ? typeVariable2 : this.a(typeVariable2, typeTable);
+                }
+            });
+        }
+
+        /* JADX WARN: Type inference failed for: r0v4, types: [java.lang.reflect.GenericDeclaration] */
+        Type a(TypeVariable<?> typeVariable, TypeTable typeTable) {
+            Type type = this.a.get(new TypeVariableKey(typeVariable));
+            if (type == null) {
+                Type[] bounds = typeVariable.getBounds();
+                if (bounds.length == 0) {
+                    return typeVariable;
+                }
+                Type[] a = new TypeResolver(typeTable).a(bounds);
+                return (Types.NativeTypeVariableEquals.a && Arrays.equals(bounds, a)) ? typeVariable : Types.a(typeVariable.getGenericDeclaration(), typeVariable.getName(), a);
+            }
+            return new TypeResolver(typeTable).a(type);
+        }
+    }
+
+    static final class TypeVariableKey {
+        private final TypeVariable<?> a;
+
+        TypeVariableKey(TypeVariable<?> typeVariable) {
+            Preconditions.a(typeVariable);
+            this.a = typeVariable;
+        }
+
+        static TypeVariableKey b(Type type) {
+            if (type instanceof TypeVariable) {
+                return new TypeVariableKey((TypeVariable) type);
+            }
+            return null;
+        }
+
+        boolean a(Type type) {
+            if (type instanceof TypeVariable) {
+                return a((TypeVariable<?>) type);
+            }
+            return false;
+        }
+
+        public boolean equals(Object obj) {
+            if (obj instanceof TypeVariableKey) {
+                return a(((TypeVariableKey) obj).a);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return Objects.a(this.a.getGenericDeclaration(), this.a.getName());
+        }
+
+        public String toString() {
+            return this.a.toString();
+        }
+
+        private boolean a(TypeVariable<?> typeVariable) {
+            return this.a.getGenericDeclaration().equals(typeVariable.getGenericDeclaration()) && this.a.getName().equals(typeVariable.getName());
+        }
+    }
+
+    public TypeResolver() {
+        this.a = new TypeTable();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void b(final Map<TypeVariableKey, Type> map, Type type, final Type type2) {
+        if (type.equals(type2)) {
+            return;
+        }
+        new TypeVisitor() { // from class: com.google.common.reflect.TypeResolver.1
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(TypeVariable<?> typeVariable) {
+                map.put(new TypeVariableKey(typeVariable), type2);
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(WildcardType wildcardType) {
+                Type type3 = type2;
+                if (type3 instanceof WildcardType) {
+                    WildcardType wildcardType2 = (WildcardType) type3;
+                    Type[] upperBounds = wildcardType.getUpperBounds();
+                    Type[] upperBounds2 = wildcardType2.getUpperBounds();
+                    Type[] lowerBounds = wildcardType.getLowerBounds();
+                    Type[] lowerBounds2 = wildcardType2.getLowerBounds();
+                    Preconditions.a(upperBounds.length == upperBounds2.length && lowerBounds.length == lowerBounds2.length, "Incompatible type: %s vs. %s", wildcardType, type2);
+                    for (int i = 0; i < upperBounds.length; i++) {
+                        TypeResolver.b(map, upperBounds[i], upperBounds2[i]);
+                    }
+                    for (int i2 = 0; i2 < lowerBounds.length; i2++) {
+                        TypeResolver.b(map, lowerBounds[i2], lowerBounds2[i2]);
+                    }
+                }
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(ParameterizedType parameterizedType) {
+                Type type3 = type2;
+                if (type3 instanceof WildcardType) {
+                    return;
+                }
+                ParameterizedType parameterizedType2 = (ParameterizedType) TypeResolver.b(ParameterizedType.class, type3);
+                if (parameterizedType.getOwnerType() != null && parameterizedType2.getOwnerType() != null) {
+                    TypeResolver.b(map, parameterizedType.getOwnerType(), parameterizedType2.getOwnerType());
+                }
+                Preconditions.a(parameterizedType.getRawType().equals(parameterizedType2.getRawType()), "Inconsistent raw type: %s vs. %s", parameterizedType, type2);
+                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+                Type[] actualTypeArguments2 = parameterizedType2.getActualTypeArguments();
+                Preconditions.a(actualTypeArguments.length == actualTypeArguments2.length, "%s not compatible with %s", parameterizedType, parameterizedType2);
+                for (int i = 0; i < actualTypeArguments.length; i++) {
+                    TypeResolver.b(map, actualTypeArguments[i], actualTypeArguments2[i]);
+                }
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(GenericArrayType genericArrayType) {
+                Type type3 = type2;
+                if (type3 instanceof WildcardType) {
+                    return;
+                }
+                Type a = Types.a(type3);
+                Preconditions.a(a != null, "%s is not an array type.", type2);
+                TypeResolver.b(map, genericArrayType.getGenericComponentType(), a);
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(Class<?> cls) {
+                if (type2 instanceof WildcardType) {
+                    return;
+                }
+                throw new IllegalArgumentException("No type mapping from " + cls + " to " + type2);
+            }
+        }.a(type);
+    }
+
+    private static final class TypeMappingIntrospector extends TypeVisitor {
+        private static final WildcardCapturer c = new WildcardCapturer();
+        private final Map<TypeVariableKey, Type> b = Maps.b();
+
+        private TypeMappingIntrospector() {
+        }
+
+        static ImmutableMap<TypeVariableKey, Type> a(Type type) {
+            TypeMappingIntrospector typeMappingIntrospector = new TypeMappingIntrospector();
+            typeMappingIntrospector.a(c.a(type));
+            return ImmutableMap.copyOf((Map) typeMappingIntrospector.b);
+        }
+
+        @Override // com.google.common.reflect.TypeVisitor
+        void a(Class<?> cls) {
+            a(cls.getGenericSuperclass());
+            a(cls.getGenericInterfaces());
+        }
+
+        @Override // com.google.common.reflect.TypeVisitor
+        void a(ParameterizedType parameterizedType) {
+            Class cls = (Class) parameterizedType.getRawType();
+            TypeVariable[] typeParameters = cls.getTypeParameters();
+            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+            Preconditions.b(typeParameters.length == actualTypeArguments.length);
+            for (int i = 0; i < typeParameters.length; i++) {
+                a(new TypeVariableKey(typeParameters[i]), actualTypeArguments[i]);
+            }
+            a(cls);
+            a(parameterizedType.getOwnerType());
+        }
+
+        @Override // com.google.common.reflect.TypeVisitor
+        void a(TypeVariable<?> typeVariable) {
+            a(typeVariable.getBounds());
+        }
+
+        @Override // com.google.common.reflect.TypeVisitor
+        void a(WildcardType wildcardType) {
+            a(wildcardType.getUpperBounds());
+        }
+
+        private void a(TypeVariableKey typeVariableKey, Type type) {
+            if (this.b.containsKey(typeVariableKey)) {
+                return;
+            }
+            Type type2 = type;
+            while (type2 != null) {
+                if (typeVariableKey.a(type2)) {
+                    while (type != null) {
+                        type = this.b.remove(TypeVariableKey.b(type));
+                    }
+                    return;
+                }
+                type2 = this.b.get(TypeVariableKey.b(type2));
+            }
+            this.b.put(typeVariableKey, type);
+        }
+    }
+
+    private TypeResolver(TypeTable typeTable) {
+        this.a = typeTable;
+    }
+
+    public TypeResolver a(Type type, Type type2) {
+        HashMap b = Maps.b();
+        Preconditions.a(type);
+        Preconditions.a(type2);
+        b(b, type, type2);
+        return a(b);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static <T> T b(Class<T> cls, Object obj) {
+        try {
+            return cls.cast(obj);
+        } catch (ClassCastException unused) {
+            throw new IllegalArgumentException(obj + " is not a " + cls.getSimpleName());
+        }
+    }
+
+    TypeResolver a(Map<TypeVariableKey, ? extends Type> map) {
+        return new TypeResolver(this.a.a(map));
+    }
+
+    public Type a(Type type) {
+        Preconditions.a(type);
+        if (type instanceof TypeVariable) {
+            return this.a.a((TypeVariable<?>) type);
+        }
+        if (type instanceof ParameterizedType) {
+            return a((ParameterizedType) type);
+        }
+        if (type instanceof GenericArrayType) {
+            return a((GenericArrayType) type);
+        }
+        return type instanceof WildcardType ? a((WildcardType) type) : type;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public Type[] a(Type[] typeArr) {
+        Type[] typeArr2 = new Type[typeArr.length];
+        for (int i = 0; i < typeArr.length; i++) {
+            typeArr2[i] = a(typeArr[i]);
+        }
+        return typeArr2;
+    }
+
+    private WildcardType a(WildcardType wildcardType) {
+        return new Types.WildcardTypeImpl(a(wildcardType.getLowerBounds()), a(wildcardType.getUpperBounds()));
+    }
+
+    private Type a(GenericArrayType genericArrayType) {
+        return Types.b(a(genericArrayType.getGenericComponentType()));
+    }
+
+    private ParameterizedType a(ParameterizedType parameterizedType) {
+        Type ownerType = parameterizedType.getOwnerType();
+        return Types.a(ownerType == null ? null : a(ownerType), (Class<?>) a(parameterizedType.getRawType()), a(parameterizedType.getActualTypeArguments()));
+    }
+}

sources/com/google/common/reflect/TypeToken.java

@@ -0,0 +1,820 @@
+package com.google.common.reflect;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Predicate;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ForwardingSet;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Ordering;
+import com.google.common.collect.UnmodifiableIterator;
+import com.google.common.primitives.Primitives;
+import com.google.common.reflect.Invokable;
+import com.google.common.reflect.TypeResolver;
+import com.google.common.reflect.Types;
+import java.io.Serializable;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public abstract class TypeToken<T> extends TypeCapture<T> implements Serializable {
+    private final Type runtimeType;
+    private transient TypeResolver typeResolver;
+
+    private static class Bounds {
+        private final Type[] a;
+        private final boolean b;
+
+        Bounds(Type[] typeArr, boolean z) {
+            this.a = typeArr;
+            this.b = z;
+        }
+
+        boolean a(Type type) {
+            for (Type type2 : this.a) {
+                boolean isSubtypeOf = TypeToken.of(type2).isSubtypeOf(type);
+                boolean z = this.b;
+                if (isSubtypeOf == z) {
+                    return z;
+                }
+            }
+            return !this.b;
+        }
+
+        boolean b(Type type) {
+            TypeToken<?> of = TypeToken.of(type);
+            for (Type type2 : this.a) {
+                boolean isSubtypeOf = of.isSubtypeOf(type2);
+                boolean z = this.b;
+                if (isSubtypeOf == z) {
+                    return z;
+                }
+            }
+            return !this.b;
+        }
+    }
+
+    private static final class SimpleTypeToken<T> extends TypeToken<T> {
+        SimpleTypeToken(Type type) {
+            super(type);
+        }
+    }
+
+    private static abstract class TypeCollector<K> {
+        static final TypeCollector<TypeToken<?>> a = new TypeCollector<TypeToken<?>>() { // from class: com.google.common.reflect.TypeToken.TypeCollector.1
+            /* JADX INFO: Access modifiers changed from: package-private */
+            @Override // com.google.common.reflect.TypeToken.TypeCollector
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public Iterable<? extends TypeToken<?>> b(TypeToken<?> typeToken) {
+                return typeToken.getGenericInterfaces();
+            }
+
+            /* JADX INFO: Access modifiers changed from: package-private */
+            @Override // com.google.common.reflect.TypeToken.TypeCollector
+            /* renamed from: b, reason: avoid collision after fix types in other method and merged with bridge method [inline-methods] */
+            public Class<?> c(TypeToken<?> typeToken) {
+                return typeToken.getRawType();
+            }
+
+            /* JADX INFO: Access modifiers changed from: package-private */
+            @Override // com.google.common.reflect.TypeToken.TypeCollector
+            /* renamed from: c, reason: avoid collision after fix types in other method and merged with bridge method [inline-methods] */
+            public TypeToken<?> d(TypeToken<?> typeToken) {
+                return typeToken.getGenericSuperclass();
+            }
+        };
+        static final TypeCollector<Class<?>> b = new TypeCollector<Class<?>>() { // from class: com.google.common.reflect.TypeToken.TypeCollector.2
+            /* JADX INFO: Access modifiers changed from: package-private */
+            @Override // com.google.common.reflect.TypeToken.TypeCollector
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public Iterable<? extends Class<?>> b(Class<?> cls) {
+                return Arrays.asList(cls.getInterfaces());
+            }
+
+            /* renamed from: b, reason: avoid collision after fix types in other method */
+            Class<?> b2(Class<?> cls) {
+                return cls;
+            }
+
+            @Override // com.google.common.reflect.TypeToken.TypeCollector
+            /* bridge */ /* synthetic */ Class c(Class<?> cls) {
+                Class<?> cls2 = cls;
+                b2(cls2);
+                return cls2;
+            }
+
+            /* JADX INFO: Access modifiers changed from: package-private */
+            @Override // com.google.common.reflect.TypeToken.TypeCollector
+            /* renamed from: c, reason: avoid collision after fix types in other method and merged with bridge method [inline-methods] */
+            public Class<?> d(Class<?> cls) {
+                return cls.getSuperclass();
+            }
+        };
+
+        private static class ForwardingTypeCollector<K> extends TypeCollector<K> {
+            private final TypeCollector<K> c;
+
+            ForwardingTypeCollector(TypeCollector<K> typeCollector) {
+                super();
+                this.c = typeCollector;
+            }
+
+            @Override // com.google.common.reflect.TypeToken.TypeCollector
+            Class<?> c(K k) {
+                return this.c.c(k);
+            }
+
+            @Override // com.google.common.reflect.TypeToken.TypeCollector
+            K d(K k) {
+                return this.c.d(k);
+            }
+        }
+
+        private TypeCollector() {
+        }
+
+        final TypeCollector<K> a() {
+            return new ForwardingTypeCollector<K>(this, this) { // from class: com.google.common.reflect.TypeToken.TypeCollector.3
+                @Override // com.google.common.reflect.TypeToken.TypeCollector
+                ImmutableList<K> a(Iterable<? extends K> iterable) {
+                    ImmutableList.Builder builder = ImmutableList.builder();
+                    for (K k : iterable) {
+                        if (!c(k).isInterface()) {
+                            builder.a((ImmutableList.Builder) k);
+                        }
+                    }
+                    return super.a((Iterable) builder.a());
+                }
+
+                @Override // com.google.common.reflect.TypeToken.TypeCollector
+                Iterable<? extends K> b(K k) {
+                    return ImmutableSet.of();
+                }
+            };
+        }
+
+        abstract Iterable<? extends K> b(K k);
+
+        abstract Class<?> c(K k);
+
+        abstract K d(K k);
+
+        final ImmutableList<K> a(K k) {
+            return a((Iterable) ImmutableList.of(k));
+        }
+
+        ImmutableList<K> a(Iterable<? extends K> iterable) {
+            HashMap b2 = Maps.b();
+            Iterator<? extends K> it = iterable.iterator();
+            while (it.hasNext()) {
+                a((TypeCollector<K>) it.next(), (Map<? super TypeCollector<K>, Integer>) b2);
+            }
+            return a(b2, Ordering.c().b());
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        private int a(K k, Map<? super K, Integer> map) {
+            Integer num = map.get(k);
+            if (num != null) {
+                return num.intValue();
+            }
+            boolean isInterface = c(k).isInterface();
+            Iterator<? extends K> it = b(k).iterator();
+            int i = isInterface;
+            while (it.hasNext()) {
+                i = Math.max(i, a((TypeCollector<K>) it.next(), (Map<? super TypeCollector<K>, Integer>) map));
+            }
+            K d = d(k);
+            int i2 = i;
+            if (d != null) {
+                i2 = Math.max(i, a((TypeCollector<K>) d, (Map<? super TypeCollector<K>, Integer>) map));
+            }
+            int i3 = i2 + 1;
+            map.put(k, Integer.valueOf(i3));
+            return i3;
+        }
+
+        private static <K, V> ImmutableList<K> a(final Map<K, V> map, final Comparator<? super V> comparator) {
+            return (ImmutableList<K>) new Ordering<K>() { // from class: com.google.common.reflect.TypeToken.TypeCollector.4
+                /* JADX WARN: Multi-variable type inference failed */
+                @Override // com.google.common.collect.Ordering, java.util.Comparator
+                public int compare(K k, K k2) {
+                    return comparator.compare(map.get(k), map.get(k2));
+                }
+            }.a(map.keySet());
+        }
+    }
+
+    private enum TypeFilter implements Predicate<TypeToken<?>> {
+        IGNORE_TYPE_VARIABLE_OR_WILDCARD { // from class: com.google.common.reflect.TypeToken.TypeFilter.1
+            @Override // com.google.common.base.Predicate
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public boolean apply(TypeToken<?> typeToken) {
+                return ((((TypeToken) typeToken).runtimeType instanceof TypeVariable) || (((TypeToken) typeToken).runtimeType instanceof WildcardType)) ? false : true;
+            }
+        },
+        INTERFACE_ONLY { // from class: com.google.common.reflect.TypeToken.TypeFilter.2
+            @Override // com.google.common.base.Predicate
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public boolean apply(TypeToken<?> typeToken) {
+                return typeToken.getRawType().isInterface();
+            }
+        }
+    }
+
+    private static Bounds any(Type[] typeArr) {
+        return new Bounds(typeArr, true);
+    }
+
+    private TypeToken<? super T> boundAsSuperclass(Type type) {
+        TypeToken<? super T> typeToken = (TypeToken<? super T>) of(type);
+        if (typeToken.getRawType().isInterface()) {
+            return null;
+        }
+        return typeToken;
+    }
+
+    private ImmutableList<TypeToken<? super T>> boundsAsInterfaces(Type[] typeArr) {
+        ImmutableList.Builder builder = ImmutableList.builder();
+        for (Type type : typeArr) {
+            TypeToken<?> of = of(type);
+            if (of.getRawType().isInterface()) {
+                builder.a((ImmutableList.Builder) of);
+            }
+        }
+        return builder.a();
+    }
+
+    private static Bounds every(Type[] typeArr) {
+        return new Bounds(typeArr, false);
+    }
+
+    private TypeToken<? extends T> getArraySubtype(Class<?> cls) {
+        return (TypeToken<? extends T>) of(newArrayClassOrGenericArrayType(getComponentType().getSubtype(cls.getComponentType()).runtimeType));
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private TypeToken<? super T> getArraySupertype(Class<? super T> cls) {
+        TypeCapture componentType = getComponentType();
+        Preconditions.a(componentType, "%s isn't a super type of %s", cls, this);
+        return (TypeToken<? super T>) of(newArrayClassOrGenericArrayType(((TypeToken) componentType).getSupertype(cls.getComponentType()).runtimeType));
+    }
+
+    private Type getOwnerTypeIfPresent() {
+        Type type = this.runtimeType;
+        if (type instanceof ParameterizedType) {
+            return ((ParameterizedType) type).getOwnerType();
+        }
+        if (type instanceof Class) {
+            return ((Class) type).getEnclosingClass();
+        }
+        return null;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public ImmutableSet<Class<? super T>> getRawTypes() {
+        final ImmutableSet.Builder builder = ImmutableSet.builder();
+        new TypeVisitor(this) { // from class: com.google.common.reflect.TypeToken.4
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(TypeVariable<?> typeVariable) {
+                a(typeVariable.getBounds());
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(WildcardType wildcardType) {
+                a(wildcardType.getUpperBounds());
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(ParameterizedType parameterizedType) {
+                builder.a((ImmutableSet.Builder) parameterizedType.getRawType());
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(Class<?> cls) {
+                builder.a((ImmutableSet.Builder) cls);
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(GenericArrayType genericArrayType) {
+                builder.a((ImmutableSet.Builder) Types.a((Class<?>) TypeToken.of(genericArrayType.getGenericComponentType()).getRawType()));
+            }
+        }.a(this.runtimeType);
+        return builder.a();
+    }
+
+    private TypeToken<? extends T> getSubtypeFromLowerBounds(Class<?> cls, Type[] typeArr) {
+        if (typeArr.length > 0) {
+            return (TypeToken<? extends T>) of(typeArr[0]).getSubtype(cls);
+        }
+        throw new IllegalArgumentException(cls + " isn't a subclass of " + this);
+    }
+
+    private TypeToken<? super T> getSupertypeFromUpperBounds(Class<? super T> cls, Type[] typeArr) {
+        for (Type type : typeArr) {
+            TypeToken<?> of = of(type);
+            if (of.isSubtypeOf(cls)) {
+                return (TypeToken<? super T>) of.getSupertype(cls);
+            }
+        }
+        throw new IllegalArgumentException(cls + " isn't a super type of " + this);
+    }
+
+    private boolean is(Type type) {
+        if (this.runtimeType.equals(type)) {
+            return true;
+        }
+        if (!(type instanceof WildcardType)) {
+            return false;
+        }
+        WildcardType wildcardType = (WildcardType) type;
+        return every(wildcardType.getUpperBounds()).b(this.runtimeType) && every(wildcardType.getLowerBounds()).a(this.runtimeType);
+    }
+
+    private boolean isOwnedBySubtypeOf(Type type) {
+        Iterator<TypeToken<? super T>> it = getTypes().iterator();
+        while (it.hasNext()) {
+            Type ownerTypeIfPresent = it.next().getOwnerTypeIfPresent();
+            if (ownerTypeIfPresent != null && of(ownerTypeIfPresent).isSubtypeOf(type)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isSubtypeOfArrayType(GenericArrayType genericArrayType) {
+        Type type = this.runtimeType;
+        if (!(type instanceof Class)) {
+            if (type instanceof GenericArrayType) {
+                return of(((GenericArrayType) type).getGenericComponentType()).isSubtypeOf(genericArrayType.getGenericComponentType());
+            }
+            return false;
+        }
+        Class cls = (Class) type;
+        if (cls.isArray()) {
+            return of((Class) cls.getComponentType()).isSubtypeOf(genericArrayType.getGenericComponentType());
+        }
+        return false;
+    }
+
+    private boolean isSubtypeOfParameterizedType(ParameterizedType parameterizedType) {
+        Class<? super Object> rawType = of(parameterizedType).getRawType();
+        if (!someRawTypeIsSubclassOf(rawType)) {
+            return false;
+        }
+        TypeVariable<Class<? super Object>>[] typeParameters = rawType.getTypeParameters();
+        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+        for (int i = 0; i < typeParameters.length; i++) {
+            if (!resolveType(typeParameters[i]).is(actualTypeArguments[i])) {
+                return false;
+            }
+        }
+        return Modifier.isStatic(((Class) parameterizedType.getRawType()).getModifiers()) || parameterizedType.getOwnerType() == null || isOwnedBySubtypeOf(parameterizedType.getOwnerType());
+    }
+
+    private boolean isSupertypeOfArray(GenericArrayType genericArrayType) {
+        Type type = this.runtimeType;
+        if (type instanceof Class) {
+            Class cls = (Class) type;
+            return !cls.isArray() ? cls.isAssignableFrom(Object[].class) : of(genericArrayType.getGenericComponentType()).isSubtypeOf(cls.getComponentType());
+        }
+        if (type instanceof GenericArrayType) {
+            return of(genericArrayType.getGenericComponentType()).isSubtypeOf(((GenericArrayType) this.runtimeType).getGenericComponentType());
+        }
+        return false;
+    }
+
+    private boolean isWrapper() {
+        return Primitives.a().contains(this.runtimeType);
+    }
+
+    private static Type newArrayClassOrGenericArrayType(Type type) {
+        return Types.JavaVersion.JAVA7.a(type);
+    }
+
+    public static <T> TypeToken<T> of(Class<T> cls) {
+        return new SimpleTypeToken(cls);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public Type[] resolveInPlace(Type[] typeArr) {
+        for (int i = 0; i < typeArr.length; i++) {
+            typeArr[i] = resolveType(typeArr[i]).getType();
+        }
+        return typeArr;
+    }
+
+    private TypeToken<?> resolveSupertype(Type type) {
+        TypeToken<?> resolveType = resolveType(type);
+        resolveType.typeResolver = this.typeResolver;
+        return resolveType;
+    }
+
+    private Type resolveTypeArgsForSubclass(Class<?> cls) {
+        if ((this.runtimeType instanceof Class) && (cls.getTypeParameters().length == 0 || getRawType().getTypeParameters().length != 0)) {
+            return cls;
+        }
+        TypeToken genericType = toGenericType(cls);
+        return new TypeResolver().a(genericType.getSupertype(getRawType()).runtimeType, this.runtimeType).a(genericType.runtimeType);
+    }
+
+    private boolean someRawTypeIsSubclassOf(Class<?> cls) {
+        UnmodifiableIterator<Class<? super T>> it = getRawTypes().iterator();
+        while (it.hasNext()) {
+            if (cls.isAssignableFrom(it.next())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static <T> TypeToken<? extends T> toGenericType(Class<T> cls) {
+        if (cls.isArray()) {
+            return (TypeToken<? extends T>) of(Types.b(toGenericType(cls.getComponentType()).runtimeType));
+        }
+        TypeVariable<Class<T>>[] typeParameters = cls.getTypeParameters();
+        Type type = (!cls.isMemberClass() || Modifier.isStatic(cls.getModifiers())) ? null : toGenericType(cls.getEnclosingClass()).runtimeType;
+        return (typeParameters.length > 0 || !(type == null || type == cls.getEnclosingClass())) ? (TypeToken<? extends T>) of(Types.a(type, (Class<?>) cls, (Type[]) typeParameters)) : of((Class) cls);
+    }
+
+    public final Invokable<T, T> constructor(Constructor<?> constructor) {
+        Preconditions.a(constructor.getDeclaringClass() == getRawType(), "%s not declared by %s", constructor, getRawType());
+        return new Invokable.ConstructorInvokable<T>(constructor) { // from class: com.google.common.reflect.TypeToken.2
+            @Override // com.google.common.reflect.Element
+            public TypeToken<T> a() {
+                return TypeToken.this;
+            }
+
+            @Override // com.google.common.reflect.Invokable.ConstructorInvokable
+            Type[] b() {
+                return TypeToken.this.resolveInPlace(super.b());
+            }
+
+            @Override // com.google.common.reflect.Element
+            public String toString() {
+                return a() + "(" + Joiner.b(", ").a((Object[]) b()) + ")";
+            }
+        };
+    }
+
+    public boolean equals(Object obj) {
+        if (obj instanceof TypeToken) {
+            return this.runtimeType.equals(((TypeToken) obj).runtimeType);
+        }
+        return false;
+    }
+
+    public final TypeToken<?> getComponentType() {
+        Type a = Types.a(this.runtimeType);
+        if (a == null) {
+            return null;
+        }
+        return of(a);
+    }
+
+    final ImmutableList<TypeToken<? super T>> getGenericInterfaces() {
+        Type type = this.runtimeType;
+        if (type instanceof TypeVariable) {
+            return boundsAsInterfaces(((TypeVariable) type).getBounds());
+        }
+        if (type instanceof WildcardType) {
+            return boundsAsInterfaces(((WildcardType) type).getUpperBounds());
+        }
+        ImmutableList.Builder builder = ImmutableList.builder();
+        for (Type type2 : getRawType().getGenericInterfaces()) {
+            builder.a((ImmutableList.Builder) resolveSupertype(type2));
+        }
+        return builder.a();
+    }
+
+    final TypeToken<? super T> getGenericSuperclass() {
+        Type type = this.runtimeType;
+        if (type instanceof TypeVariable) {
+            return boundAsSuperclass(((TypeVariable) type).getBounds()[0]);
+        }
+        if (type instanceof WildcardType) {
+            return boundAsSuperclass(((WildcardType) type).getUpperBounds()[0]);
+        }
+        Type genericSuperclass = getRawType().getGenericSuperclass();
+        if (genericSuperclass == null) {
+            return null;
+        }
+        return (TypeToken<? super T>) resolveSupertype(genericSuperclass);
+    }
+
+    public final Class<? super T> getRawType() {
+        return getRawTypes().iterator().next();
+    }
+
+    public final TypeToken<? extends T> getSubtype(Class<?> cls) {
+        Preconditions.a(!(this.runtimeType instanceof TypeVariable), "Cannot get subtype of type variable <%s>", this);
+        Type type = this.runtimeType;
+        if (type instanceof WildcardType) {
+            return getSubtypeFromLowerBounds(cls, ((WildcardType) type).getLowerBounds());
+        }
+        if (isArray()) {
+            return getArraySubtype(cls);
+        }
+        Preconditions.a(getRawType().isAssignableFrom(cls), "%s isn't a subclass of %s", cls, this);
+        return (TypeToken<? extends T>) of(resolveTypeArgsForSubclass(cls));
+    }
+
+    public final TypeToken<? super T> getSupertype(Class<? super T> cls) {
+        Preconditions.a(someRawTypeIsSubclassOf(cls), "%s is not a super class of %s", cls, this);
+        Type type = this.runtimeType;
+        return type instanceof TypeVariable ? getSupertypeFromUpperBounds(cls, ((TypeVariable) type).getBounds()) : type instanceof WildcardType ? getSupertypeFromUpperBounds(cls, ((WildcardType) type).getUpperBounds()) : cls.isArray() ? getArraySupertype(cls) : (TypeToken<? super T>) resolveSupertype(toGenericType(cls).runtimeType);
+    }
+
+    public final Type getType() {
+        return this.runtimeType;
+    }
+
+    public final TypeToken<T>.TypeSet getTypes() {
+        return new TypeSet();
+    }
+
+    public int hashCode() {
+        return this.runtimeType.hashCode();
+    }
+
+    public final boolean isArray() {
+        return getComponentType() != null;
+    }
+
+    public final boolean isPrimitive() {
+        Type type = this.runtimeType;
+        return (type instanceof Class) && ((Class) type).isPrimitive();
+    }
+
+    public final boolean isSubtypeOf(TypeToken<?> typeToken) {
+        return isSubtypeOf(typeToken.getType());
+    }
+
+    public final boolean isSupertypeOf(TypeToken<?> typeToken) {
+        return typeToken.isSubtypeOf(getType());
+    }
+
+    public final Invokable<T, Object> method(Method method) {
+        Preconditions.a(someRawTypeIsSubclassOf(method.getDeclaringClass()), "%s not declared by %s", method, this);
+        return new Invokable.MethodInvokable<T>(method) { // from class: com.google.common.reflect.TypeToken.1
+            @Override // com.google.common.reflect.Element
+            public TypeToken<T> a() {
+                return TypeToken.this;
+            }
+
+            @Override // com.google.common.reflect.Element
+            public String toString() {
+                return a() + "." + super.toString();
+            }
+        };
+    }
+
+    final TypeToken<T> rejectTypeVariables() {
+        new TypeVisitor() { // from class: com.google.common.reflect.TypeToken.3
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(TypeVariable<?> typeVariable) {
+                throw new IllegalArgumentException(TypeToken.this.runtimeType + "contains a type variable and is not safe for the operation");
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(WildcardType wildcardType) {
+                a(wildcardType.getLowerBounds());
+                a(wildcardType.getUpperBounds());
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(ParameterizedType parameterizedType) {
+                a(parameterizedType.getActualTypeArguments());
+                a(parameterizedType.getOwnerType());
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(GenericArrayType genericArrayType) {
+                a(genericArrayType.getGenericComponentType());
+            }
+        }.a(this.runtimeType);
+        return this;
+    }
+
+    public final TypeToken<?> resolveType(Type type) {
+        Preconditions.a(type);
+        TypeResolver typeResolver = this.typeResolver;
+        if (typeResolver == null) {
+            typeResolver = TypeResolver.b(this.runtimeType);
+            this.typeResolver = typeResolver;
+        }
+        return of(typeResolver.a(type));
+    }
+
+    public String toString() {
+        return Types.e(this.runtimeType);
+    }
+
+    public final TypeToken<T> unwrap() {
+        return isWrapper() ? of(Primitives.a((Class) this.runtimeType)) : this;
+    }
+
+    public final <X> TypeToken<T> where(TypeParameter<X> typeParameter, TypeToken<X> typeToken) {
+        return new SimpleTypeToken(new TypeResolver().a(ImmutableMap.of(new TypeResolver.TypeVariableKey(typeParameter.a), typeToken.runtimeType)).a(this.runtimeType));
+    }
+
+    public final TypeToken<T> wrap() {
+        return isPrimitive() ? of(Primitives.b((Class) this.runtimeType)) : this;
+    }
+
+    protected Object writeReplace() {
+        return of(new TypeResolver().a(this.runtimeType));
+    }
+
+    private final class ClassSet extends TypeToken<T>.TypeSet {
+        private transient ImmutableSet<TypeToken<? super T>> a;
+
+        private ClassSet() {
+            super();
+        }
+
+        private Object readResolve() {
+            return TypeToken.this.getTypes().classes();
+        }
+
+        @Override // com.google.common.reflect.TypeToken.TypeSet
+        public TypeToken<T>.TypeSet classes() {
+            return this;
+        }
+
+        @Override // com.google.common.reflect.TypeToken.TypeSet
+        public TypeToken<T>.TypeSet interfaces() {
+            throw new UnsupportedOperationException("classes().interfaces() not supported.");
+        }
+
+        @Override // com.google.common.reflect.TypeToken.TypeSet
+        public Set<Class<? super T>> rawTypes() {
+            return ImmutableSet.copyOf((Collection) TypeCollector.b.a().a(TypeToken.this.getRawTypes()));
+        }
+
+        /* JADX INFO: Access modifiers changed from: protected */
+        @Override // com.google.common.reflect.TypeToken.TypeSet, com.google.common.collect.ForwardingSet, com.google.common.collect.ForwardingCollection, com.google.common.collect.ForwardingObject
+        public Set<TypeToken<? super T>> delegate() {
+            ImmutableSet<TypeToken<? super T>> immutableSet = this.a;
+            if (immutableSet != null) {
+                return immutableSet;
+            }
+            ImmutableSet<TypeToken<? super T>> a = FluentIterable.b(TypeCollector.a.a().a((TypeCollector<TypeToken<?>>) TypeToken.this)).a(TypeFilter.IGNORE_TYPE_VARIABLE_OR_WILDCARD).a();
+            this.a = a;
+            return a;
+        }
+    }
+
+    private final class InterfaceSet extends TypeToken<T>.TypeSet {
+        private final transient TypeToken<T>.TypeSet a;
+        private transient ImmutableSet<TypeToken<? super T>> b;
+
+        InterfaceSet(TypeToken<T>.TypeSet typeSet) {
+            super();
+            this.a = typeSet;
+        }
+
+        private Object readResolve() {
+            return TypeToken.this.getTypes().interfaces();
+        }
+
+        @Override // com.google.common.reflect.TypeToken.TypeSet
+        public TypeToken<T>.TypeSet classes() {
+            throw new UnsupportedOperationException("interfaces().classes() not supported.");
+        }
+
+        @Override // com.google.common.reflect.TypeToken.TypeSet
+        public TypeToken<T>.TypeSet interfaces() {
+            return this;
+        }
+
+        @Override // com.google.common.reflect.TypeToken.TypeSet
+        public Set<Class<? super T>> rawTypes() {
+            return FluentIterable.b(TypeCollector.b.a(TypeToken.this.getRawTypes())).a(new Predicate<Class<?>>(this) { // from class: com.google.common.reflect.TypeToken.InterfaceSet.1
+                @Override // com.google.common.base.Predicate
+                /* renamed from: a, reason: merged with bridge method [inline-methods] */
+                public boolean apply(Class<?> cls) {
+                    return cls.isInterface();
+                }
+            }).a();
+        }
+
+        /* JADX INFO: Access modifiers changed from: protected */
+        @Override // com.google.common.reflect.TypeToken.TypeSet, com.google.common.collect.ForwardingSet, com.google.common.collect.ForwardingCollection, com.google.common.collect.ForwardingObject
+        public Set<TypeToken<? super T>> delegate() {
+            ImmutableSet<TypeToken<? super T>> immutableSet = this.b;
+            if (immutableSet != null) {
+                return immutableSet;
+            }
+            ImmutableSet<TypeToken<? super T>> a = FluentIterable.b(this.a).a(TypeFilter.INTERFACE_ONLY).a();
+            this.b = a;
+            return a;
+        }
+    }
+
+    public class TypeSet extends ForwardingSet<TypeToken<? super T>> implements Serializable {
+        private static final long serialVersionUID = 0;
+        private transient ImmutableSet<TypeToken<? super T>> types;
+
+        TypeSet() {
+        }
+
+        public TypeToken<T>.TypeSet classes() {
+            return new ClassSet();
+        }
+
+        public TypeToken<T>.TypeSet interfaces() {
+            return new InterfaceSet(this);
+        }
+
+        public Set<Class<? super T>> rawTypes() {
+            return ImmutableSet.copyOf((Collection) TypeCollector.b.a(TypeToken.this.getRawTypes()));
+        }
+
+        /* JADX INFO: Access modifiers changed from: protected */
+        @Override // com.google.common.collect.ForwardingSet, com.google.common.collect.ForwardingCollection, com.google.common.collect.ForwardingObject
+        public Set<TypeToken<? super T>> delegate() {
+            ImmutableSet<TypeToken<? super T>> immutableSet = this.types;
+            if (immutableSet != null) {
+                return immutableSet;
+            }
+            ImmutableSet<TypeToken<? super T>> a = FluentIterable.b(TypeCollector.a.a((TypeCollector<TypeToken<?>>) TypeToken.this)).a(TypeFilter.IGNORE_TYPE_VARIABLE_OR_WILDCARD).a();
+            this.types = a;
+            return a;
+        }
+    }
+
+    protected TypeToken() {
+        this.runtimeType = capture();
+        Preconditions.b(!(r0 instanceof TypeVariable), "Cannot construct a TypeToken for a type variable.\nYou probably meant to call new TypeToken<%s>(getClass()) that can resolve the type variable for you.\nIf you do need to create a TypeToken of a type variable, please use TypeToken.of() instead.", this.runtimeType);
+    }
+
+    public static TypeToken<?> of(Type type) {
+        return new SimpleTypeToken(type);
+    }
+
+    public final boolean isSubtypeOf(Type type) {
+        Preconditions.a(type);
+        if (type instanceof WildcardType) {
+            return any(((WildcardType) type).getLowerBounds()).b(this.runtimeType);
+        }
+        Type type2 = this.runtimeType;
+        if (type2 instanceof WildcardType) {
+            return any(((WildcardType) type2).getUpperBounds()).a(type);
+        }
+        if (type2 instanceof TypeVariable) {
+            return type2.equals(type) || any(((TypeVariable) this.runtimeType).getBounds()).a(type);
+        }
+        if (type2 instanceof GenericArrayType) {
+            return of(type).isSupertypeOfArray((GenericArrayType) this.runtimeType);
+        }
+        if (type instanceof Class) {
+            return someRawTypeIsSubclassOf((Class) type);
+        }
+        if (type instanceof ParameterizedType) {
+            return isSubtypeOfParameterizedType((ParameterizedType) type);
+        }
+        if (type instanceof GenericArrayType) {
+            return isSubtypeOfArrayType((GenericArrayType) type);
+        }
+        return false;
+    }
+
+    public final boolean isSupertypeOf(Type type) {
+        return of(type).isSubtypeOf(getType());
+    }
+
+    protected TypeToken(Class<?> cls) {
+        Type capture = super.capture();
+        if (capture instanceof Class) {
+            this.runtimeType = capture;
+        } else {
+            this.runtimeType = of((Class) cls).resolveType(capture).runtimeType;
+        }
+    }
+
+    public final <X> TypeToken<T> where(TypeParameter<X> typeParameter, Class<X> cls) {
+        return where(typeParameter, of((Class) cls));
+    }
+
+    private TypeToken(Type type) {
+        Preconditions.a(type);
+        this.runtimeType = type;
+    }
+}

sources/com/google/common/reflect/TypeVisitor.java

@@ -0,0 +1,56 @@
+package com.google.common.reflect;
+
+import com.google.common.collect.Sets;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+abstract class TypeVisitor {
+    private final Set<Type> a = Sets.a();
+
+    TypeVisitor() {
+    }
+
+    void a(Class<?> cls) {
+    }
+
+    void a(GenericArrayType genericArrayType) {
+    }
+
+    void a(ParameterizedType parameterizedType) {
+    }
+
+    abstract void a(TypeVariable<?> typeVariable);
+
+    abstract void a(WildcardType wildcardType);
+
+    public final void a(Type... typeArr) {
+        for (Type type : typeArr) {
+            if (type != null && this.a.add(type)) {
+                try {
+                    if (type instanceof TypeVariable) {
+                        a((TypeVariable<?>) type);
+                    } else if (type instanceof WildcardType) {
+                        a((WildcardType) type);
+                    } else if (type instanceof ParameterizedType) {
+                        a((ParameterizedType) type);
+                    } else if (type instanceof Class) {
+                        a((Class<?>) type);
+                    } else {
+                        if (!(type instanceof GenericArrayType)) {
+                            throw new AssertionError("Unknown type: " + type);
+                        }
+                        a((GenericArrayType) type);
+                    }
+                } catch (Throwable th) {
+                    this.a.remove(type);
+                    throw th;
+                }
+            }
+        }
+    }
+}

sources/com/google/common/reflect/Types.java

@@ -0,0 +1,501 @@
+package com.google.common.reflect;
+
+import com.google.common.base.Function;
+import com.google.common.base.Joiner;
+import com.google.common.base.Objects;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Predicates;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.UnmodifiableIterator;
+import java.io.Serializable;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.GenericDeclaration;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.security.AccessControlException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes.dex */
+final class Types {
+    private static final Function<Type, String> a = new Function<Type, String>() { // from class: com.google.common.reflect.Types.1
+        @Override // com.google.common.base.Function
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public String apply(Type type) {
+            return JavaVersion.d.b(type);
+        }
+    };
+    private static final Joiner b = Joiner.b(", ").a("null");
+
+    private enum ClassOwnership {
+        OWNED_BY_ENCLOSING_CLASS { // from class: com.google.common.reflect.Types.ClassOwnership.1
+            @Override // com.google.common.reflect.Types.ClassOwnership
+            Class<?> a(Class<?> cls) {
+                return cls.getEnclosingClass();
+            }
+        },
+        LOCAL_CLASS_HAS_NO_OWNER { // from class: com.google.common.reflect.Types.ClassOwnership.2
+            @Override // com.google.common.reflect.Types.ClassOwnership
+            Class<?> a(Class<?> cls) {
+                if (cls.isLocalClass()) {
+                    return null;
+                }
+                return cls.getEnclosingClass();
+            }
+        };
+
+        static final ClassOwnership c = c();
+
+        private static ClassOwnership c() {
+            new C1LocalClass<String>() { // from class: com.google.common.reflect.Types.ClassOwnership.3
+            };
+            ParameterizedType parameterizedType = (ParameterizedType) AnonymousClass3.class.getGenericSuperclass();
+            for (ClassOwnership classOwnership : values()) {
+                if (classOwnership.a(C1LocalClass.class) == parameterizedType.getOwnerType()) {
+                    return classOwnership;
+                }
+            }
+            throw new AssertionError();
+        }
+
+        abstract Class<?> a(Class<?> cls);
+    }
+
+    private static final class GenericArrayTypeImpl implements GenericArrayType, Serializable {
+        private final Type a;
+
+        GenericArrayTypeImpl(Type type) {
+            this.a = JavaVersion.d.c(type);
+        }
+
+        public boolean equals(Object obj) {
+            if (obj instanceof GenericArrayType) {
+                return Objects.a(getGenericComponentType(), ((GenericArrayType) obj).getGenericComponentType());
+            }
+            return false;
+        }
+
+        @Override // java.lang.reflect.GenericArrayType
+        public Type getGenericComponentType() {
+            return this.a;
+        }
+
+        public int hashCode() {
+            return this.a.hashCode();
+        }
+
+        public String toString() {
+            return Types.e(this.a) + "[]";
+        }
+    }
+
+    enum JavaVersion {
+        JAVA6 { // from class: com.google.common.reflect.Types.JavaVersion.1
+            @Override // com.google.common.reflect.Types.JavaVersion
+            Type c(Type type) {
+                Preconditions.a(type);
+                if (!(type instanceof Class)) {
+                    return type;
+                }
+                Class cls = (Class) type;
+                return cls.isArray() ? new GenericArrayTypeImpl(cls.getComponentType()) : type;
+            }
+
+            /* JADX INFO: Access modifiers changed from: package-private */
+            @Override // com.google.common.reflect.Types.JavaVersion
+            public GenericArrayType a(Type type) {
+                return new GenericArrayTypeImpl(type);
+            }
+        },
+        JAVA7 { // from class: com.google.common.reflect.Types.JavaVersion.2
+            @Override // com.google.common.reflect.Types.JavaVersion
+            Type a(Type type) {
+                return type instanceof Class ? Types.a((Class<?>) type) : new GenericArrayTypeImpl(type);
+            }
+
+            @Override // com.google.common.reflect.Types.JavaVersion
+            Type c(Type type) {
+                Preconditions.a(type);
+                return type;
+            }
+        },
+        JAVA8 { // from class: com.google.common.reflect.Types.JavaVersion.3
+            @Override // com.google.common.reflect.Types.JavaVersion
+            Type a(Type type) {
+                return JavaVersion.JAVA7.a(type);
+            }
+
+            @Override // com.google.common.reflect.Types.JavaVersion
+            String b(Type type) {
+                try {
+                    return (String) Type.class.getMethod("getTypeName", new Class[0]).invoke(type, new Object[0]);
+                } catch (IllegalAccessException e) {
+                    throw new RuntimeException(e);
+                } catch (NoSuchMethodException unused) {
+                    throw new AssertionError("Type.getTypeName should be available in Java 8");
+                } catch (InvocationTargetException e2) {
+                    throw new RuntimeException(e2);
+                }
+            }
+
+            @Override // com.google.common.reflect.Types.JavaVersion
+            Type c(Type type) {
+                return JavaVersion.JAVA7.c(type);
+            }
+        };
+
+        static final JavaVersion d;
+
+        static {
+            if (AnnotatedElement.class.isAssignableFrom(TypeVariable.class)) {
+                d = JAVA8;
+            } else if (new TypeCapture<int[]>() { // from class: com.google.common.reflect.Types.JavaVersion.4
+            }.capture() instanceof Class) {
+                d = JAVA7;
+            } else {
+                d = JAVA6;
+            }
+        }
+
+        final ImmutableList<Type> a(Type[] typeArr) {
+            ImmutableList.Builder builder = ImmutableList.builder();
+            for (Type type : typeArr) {
+                builder.a((ImmutableList.Builder) c(type));
+            }
+            return builder.a();
+        }
+
+        abstract Type a(Type type);
+
+        String b(Type type) {
+            return Types.e(type);
+        }
+
+        abstract Type c(Type type);
+    }
+
+    static final class NativeTypeVariableEquals<X> {
+        static final boolean a = !NativeTypeVariableEquals.class.getTypeParameters()[0].equals(Types.a(NativeTypeVariableEquals.class, "X", new Type[0]));
+
+        NativeTypeVariableEquals() {
+        }
+    }
+
+    private static final class ParameterizedTypeImpl implements ParameterizedType, Serializable {
+        private final Type a;
+        private final ImmutableList<Type> b;
+        private final Class<?> c;
+
+        ParameterizedTypeImpl(Type type, Class<?> cls, Type[] typeArr) {
+            Preconditions.a(cls);
+            Preconditions.a(typeArr.length == cls.getTypeParameters().length);
+            Types.b(typeArr, "type parameter");
+            this.a = type;
+            this.c = cls;
+            this.b = JavaVersion.d.a(typeArr);
+        }
+
+        public boolean equals(Object obj) {
+            if (!(obj instanceof ParameterizedType)) {
+                return false;
+            }
+            ParameterizedType parameterizedType = (ParameterizedType) obj;
+            return getRawType().equals(parameterizedType.getRawType()) && Objects.a(getOwnerType(), parameterizedType.getOwnerType()) && Arrays.equals(getActualTypeArguments(), parameterizedType.getActualTypeArguments());
+        }
+
+        @Override // java.lang.reflect.ParameterizedType
+        public Type[] getActualTypeArguments() {
+            return Types.b((Collection<Type>) this.b);
+        }
+
+        @Override // java.lang.reflect.ParameterizedType
+        public Type getOwnerType() {
+            return this.a;
+        }
+
+        @Override // java.lang.reflect.ParameterizedType
+        public Type getRawType() {
+            return this.c;
+        }
+
+        public int hashCode() {
+            Type type = this.a;
+            return ((type == null ? 0 : type.hashCode()) ^ this.b.hashCode()) ^ this.c.hashCode();
+        }
+
+        public String toString() {
+            StringBuilder sb = new StringBuilder();
+            Type type = this.a;
+            if (type != null) {
+                sb.append(JavaVersion.d.b(type));
+                sb.append('.');
+            }
+            sb.append(this.c.getName());
+            sb.append('<');
+            sb.append(Types.b.a(Iterables.a((Iterable) this.b, Types.a)));
+            sb.append('>');
+            return sb.toString();
+        }
+    }
+
+    private static final class TypeVariableImpl<D extends GenericDeclaration> {
+        private final D a;
+        private final String b;
+        private final ImmutableList<Type> c;
+
+        TypeVariableImpl(D d, String str, Type[] typeArr) {
+            Types.b(typeArr, "bound for type variable");
+            Preconditions.a(d);
+            this.a = d;
+            Preconditions.a(str);
+            this.b = str;
+            this.c = ImmutableList.copyOf(typeArr);
+        }
+
+        public D a() {
+            return this.a;
+        }
+
+        public String b() {
+            return this.b;
+        }
+
+        public boolean equals(Object obj) {
+            if (!NativeTypeVariableEquals.a) {
+                if (!(obj instanceof TypeVariable)) {
+                    return false;
+                }
+                TypeVariable typeVariable = (TypeVariable) obj;
+                return this.b.equals(typeVariable.getName()) && this.a.equals(typeVariable.getGenericDeclaration());
+            }
+            if (obj == null || !Proxy.isProxyClass(obj.getClass()) || !(Proxy.getInvocationHandler(obj) instanceof TypeVariableInvocationHandler)) {
+                return false;
+            }
+            TypeVariableImpl typeVariableImpl = ((TypeVariableInvocationHandler) Proxy.getInvocationHandler(obj)).a;
+            return this.b.equals(typeVariableImpl.b()) && this.a.equals(typeVariableImpl.a()) && this.c.equals(typeVariableImpl.c);
+        }
+
+        public int hashCode() {
+            return this.a.hashCode() ^ this.b.hashCode();
+        }
+
+        public String toString() {
+            return this.b;
+        }
+    }
+
+    private static final class TypeVariableInvocationHandler implements InvocationHandler {
+        private static final ImmutableMap<String, Method> b;
+        private final TypeVariableImpl<?> a;
+
+        static {
+            ImmutableMap.Builder builder = ImmutableMap.builder();
+            for (Method method : TypeVariableImpl.class.getMethods()) {
+                if (method.getDeclaringClass().equals(TypeVariableImpl.class)) {
+                    try {
+                        method.setAccessible(true);
+                    } catch (AccessControlException unused) {
+                    }
+                    builder.a(method.getName(), method);
+                }
+            }
+            b = builder.a();
+        }
+
+        TypeVariableInvocationHandler(TypeVariableImpl<?> typeVariableImpl) {
+            this.a = typeVariableImpl;
+        }
+
+        @Override // java.lang.reflect.InvocationHandler
+        public Object invoke(Object obj, Method method, Object[] objArr) throws Throwable {
+            String name = method.getName();
+            Method method2 = b.get(name);
+            if (method2 == null) {
+                throw new UnsupportedOperationException(name);
+            }
+            try {
+                return method2.invoke(this.a, objArr);
+            } catch (InvocationTargetException e) {
+                throw e.getCause();
+            }
+        }
+    }
+
+    static final class WildcardTypeImpl implements WildcardType, Serializable {
+        private final ImmutableList<Type> a;
+        private final ImmutableList<Type> b;
+
+        WildcardTypeImpl(Type[] typeArr, Type[] typeArr2) {
+            Types.b(typeArr, "lower bound for wildcard");
+            Types.b(typeArr2, "upper bound for wildcard");
+            this.a = JavaVersion.d.a(typeArr);
+            this.b = JavaVersion.d.a(typeArr2);
+        }
+
+        public boolean equals(Object obj) {
+            if (!(obj instanceof WildcardType)) {
+                return false;
+            }
+            WildcardType wildcardType = (WildcardType) obj;
+            return this.a.equals(Arrays.asList(wildcardType.getLowerBounds())) && this.b.equals(Arrays.asList(wildcardType.getUpperBounds()));
+        }
+
+        @Override // java.lang.reflect.WildcardType
+        public Type[] getLowerBounds() {
+            return Types.b((Collection<Type>) this.a);
+        }
+
+        @Override // java.lang.reflect.WildcardType
+        public Type[] getUpperBounds() {
+            return Types.b((Collection<Type>) this.b);
+        }
+
+        public int hashCode() {
+            return this.a.hashCode() ^ this.b.hashCode();
+        }
+
+        public String toString() {
+            StringBuilder sb = new StringBuilder("?");
+            UnmodifiableIterator<Type> it = this.a.iterator();
+            while (it.hasNext()) {
+                Type next = it.next();
+                sb.append(" super ");
+                sb.append(JavaVersion.d.b(next));
+            }
+            for (Type type : Types.b((Iterable<Type>) this.b)) {
+                sb.append(" extends ");
+                sb.append(JavaVersion.d.b(type));
+            }
+            return sb.toString();
+        }
+    }
+
+    static WildcardType c(Type type) {
+        return new WildcardTypeImpl(new Type[0], new Type[]{type});
+    }
+
+    static WildcardType d(Type type) {
+        return new WildcardTypeImpl(new Type[]{type}, new Type[]{Object.class});
+    }
+
+    static String e(Type type) {
+        return type instanceof Class ? ((Class) type).getName() : type.toString();
+    }
+
+    static Type b(Type type) {
+        if (!(type instanceof WildcardType)) {
+            return JavaVersion.d.a(type);
+        }
+        WildcardType wildcardType = (WildcardType) type;
+        Type[] lowerBounds = wildcardType.getLowerBounds();
+        Preconditions.a(lowerBounds.length <= 1, "Wildcard cannot have more than one lower bounds.");
+        if (lowerBounds.length == 1) {
+            return d(b(lowerBounds[0]));
+        }
+        Type[] upperBounds = wildcardType.getUpperBounds();
+        Preconditions.a(upperBounds.length == 1, "Wildcard should have only one upper bound.");
+        return c(b(upperBounds[0]));
+    }
+
+    static ParameterizedType a(Type type, Class<?> cls, Type... typeArr) {
+        if (type == null) {
+            return a(cls, typeArr);
+        }
+        Preconditions.a(typeArr);
+        Preconditions.a(cls.getEnclosingClass() != null, "Owner type for unenclosed %s", cls);
+        return new ParameterizedTypeImpl(type, cls, typeArr);
+    }
+
+    static ParameterizedType a(Class<?> cls, Type... typeArr) {
+        return new ParameterizedTypeImpl(ClassOwnership.c.a(cls), cls, typeArr);
+    }
+
+    static <D extends GenericDeclaration> TypeVariable<D> a(D d, String str, Type... typeArr) {
+        if (typeArr.length == 0) {
+            typeArr = new Type[]{Object.class};
+        }
+        return b(d, str, typeArr);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static Type b(Type[] typeArr) {
+        for (Type type : typeArr) {
+            Type a2 = a(type);
+            if (a2 != null) {
+                if (a2 instanceof Class) {
+                    Class cls = (Class) a2;
+                    if (cls.isPrimitive()) {
+                        return cls;
+                    }
+                }
+                return c(a2);
+            }
+        }
+        return null;
+    }
+
+    static Type a(Type type) {
+        Preconditions.a(type);
+        final AtomicReference atomicReference = new AtomicReference();
+        new TypeVisitor() { // from class: com.google.common.reflect.Types.2
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(TypeVariable<?> typeVariable) {
+                atomicReference.set(Types.b(typeVariable.getBounds()));
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(WildcardType wildcardType) {
+                atomicReference.set(Types.b(wildcardType.getUpperBounds()));
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(GenericArrayType genericArrayType) {
+                atomicReference.set(genericArrayType.getGenericComponentType());
+            }
+
+            @Override // com.google.common.reflect.TypeVisitor
+            void a(Class<?> cls) {
+                atomicReference.set(cls.getComponentType());
+            }
+        }.a(type);
+        return (Type) atomicReference.get();
+    }
+
+    static Class<?> a(Class<?> cls) {
+        return Array.newInstance(cls, 0).getClass();
+    }
+
+    private static <D extends GenericDeclaration> TypeVariable<D> b(D d, String str, Type[] typeArr) {
+        return (TypeVariable) Reflection.a(TypeVariable.class, new TypeVariableInvocationHandler(new TypeVariableImpl(d, str, typeArr)));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static Type[] b(Collection<Type> collection) {
+        return (Type[]) collection.toArray(new Type[collection.size()]);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static Iterable<Type> b(Iterable<Type> iterable) {
+        return Iterables.b(iterable, Predicates.a(Predicates.a(Object.class)));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void b(Type[] typeArr, String str) {
+        for (Type type : typeArr) {
+            if (type instanceof Class) {
+                Preconditions.a(!r2.isPrimitive(), "Primitive type '%s' used as %s", (Class) type, str);
+            }
+        }
+    }
+}