Attachment #453388 for bug #580696

View | Details | Raw Unified | Return to bug 580696
Collapse All | Expand All




import com.google.common.base.Objects;
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 java.io.Serializable;
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;

   */
  static <D extends GenericDeclaration> TypeVariable<D> newArtificialTypeVariable(
      D declaration, String name, Type... bounds) {
    return newTypeVariableImpl(
        declaration,
        name,
        (bounds.length == 0)

    private static final long serialVersionUID = 0;
  }

  private static <D extends GenericDeclaration> TypeVariable<D> newTypeVariableImpl(
      D genericDeclaration, String name, Type[] bounds) {
    TypeVariableImpl<D> typeVariableImpl =
        new TypeVariableImpl<D>(genericDeclaration, name, bounds);
    @SuppressWarnings("unchecked")
    TypeVariable<D> typeVariable = Reflection.newProxy(
        TypeVariable.class, new TypeVariableInvocationHandler(typeVariableImpl));
    return typeVariable;
  }

  /**
   * Invocation handler to work around a compatibility problem between Java 7 and Java 8.
   *
   * <p>Java 8 introduced a new method {@code getAnnotatedBounds()} in the {@link TypeVariable}
   * interface, whose return type {@code AnnotatedType[]} is also new in Java 8. That means that we
   * cannot implement that interface in source code in a way that will compile on both Java 7 and
   * Java 8. If we include the {@code getAnnotatedBounds()} method then its return type means
   * it won't compile on Java 7, while if we don't include the method then the compiler will
   * complain that an abstract method is unimplemented. So instead we use a dynamic proxy to
   * get an implementation. If the method being called on the {@code TypeVariable} instance has
   * the same name as one of the public methods of {@link TypeVariableImpl}, the proxy calls
   * the same method on its instance of {@code TypeVariableImpl}. Otherwise it throws {@link
   * UnsupportedOperationException}; this should only apply to {@code getAnnotatedBounds()}. This
   * does mean that users on Java 8 who obtain an instance of {@code TypeVariable} from {@link
   * TypeResolver#resolveType} will not be able to call {@code getAnnotatedBounds()} on it, but that
   * should hopefully be rare.
   *
   * <p>This workaround should be removed at a distant future time when we no longer support Java
   * versions earlier than 8.
   */
  private static final class TypeVariableInvocationHandler implements InvocationHandler {
    private static final ImmutableMap<String, Method> typeVariableMethods;
    static {
      ImmutableMap.Builder<String, Method> builder = ImmutableMap.builder();
      for (Method method : TypeVariableImpl.class.getMethods()) {
        if (method.getDeclaringClass().equals(TypeVariableImpl.class)) {
          try {
            method.setAccessible(true);
          } catch (AccessControlException e) {
            // OK: the method is accessible to us anyway. The setAccessible call is only for
            // unusual execution environments where that might not be true.
          }
          builder.put(method.getName(), method);
        }
      }
      typeVariableMethods = builder.build();
    }

    private final TypeVariableImpl<?> typeVariableImpl;

    TypeVariableInvocationHandler(TypeVariableImpl<?> typeVariableImpl) {
      this.typeVariableImpl = typeVariableImpl;
    }

    @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      String methodName = method.getName();
      Method typeVariableMethod = typeVariableMethods.get(methodName);
      if (typeVariableMethod == null) {
        throw new UnsupportedOperationException(methodName);
      } else {
        try {
          return typeVariableMethod.invoke(typeVariableImpl, args);
        } catch (InvocationTargetException e) {
          throw e.getCause();
        }
      }
    }
  }

  private static final class TypeVariableImpl<D extends GenericDeclaration> {

    private final D genericDeclaration;
    private final String name;

      this.bounds = ImmutableList.copyOf(bounds);
    }

    public Type[] getBounds() {
      return toArray(bounds);
    }

    public D getGenericDeclaration() {
      return genericDeclaration;
    }

    public String getName() {
      return name;
    }

    public String getTypeName() {
      return name;
    }


    }

    @Override public boolean equals(Object obj) {
        if (obj != null
            && Proxy.isProxyClass(obj.getClass())
            && Proxy.getInvocationHandler(obj) instanceof TypeVariableInvocationHandler) {
          TypeVariableInvocationHandler typeVariableInvocationHandler =
              (TypeVariableInvocationHandler) Proxy.getInvocationHandler(obj);
          TypeVariableImpl<?> that = typeVariableInvocationHandler.typeVariableImpl;
        return name.equals(that.getName())
            && genericDeclaration.equals(that.getGenericDeclaration());
        }
proactively prevent name shadowing with Java 8. ------------- Created by MOE:
http://code.google.com/p/moe-java MOE_MIGRATED_REVID=57671698
--
.../google/common/base/super/com/google/common/base/Splitter.java | 8 ++++----
guava/src/com/google/common/base/Splitter.java                    | 8 ++++----
2 files changed, 8 insertions(+), 8 deletions(-)





    return new Iterable<String>() {
      @Override public Iterator<String> iterator() {
        return splittingIterator(sequence);
      }
      @Override public String toString() {
        return Joiner.on(", ")

    };
  }

  private Iterator<String> splittingIterator(CharSequence sequence) {
    return strategy.iterator(this, sequence);
  }


    public Map<String, String> split(CharSequence sequence) {
      Map<String, String> map = new LinkedHashMap<String, String>();
      for (String entry : outerSplitter.split(sequence)) {
        Iterator<String> entryFields = entrySplitter.splittingIterator(entry);

        checkArgument(entryFields.hasNext(), INVALID_ENTRY_MESSAGE, entry);
        String key = entryFields.next();

Return to bug 580696

Lines 26-41 Link Here

(-)a/guava/src/com/google/common/reflect/Types.java (-9 / +90 lines)
26	import com.google.common.base.Objects;	26	import com.google.common.base.Objects;
27	import com.google.common.base.Predicates;	27	import com.google.common.base.Predicates;
28	import com.google.common.collect.ImmutableList;	28	import com.google.common.collect.ImmutableList;
		29	import com.google.common.collect.ImmutableMap;
29	import com.google.common.collect.Iterables;	30	import com.google.common.collect.Iterables;
30		31
31	import java.io.Serializable;	32	import java.io.Serializable;
32	import java.lang.reflect.Array;	33	import java.lang.reflect.Array;
33	import java.lang.reflect.GenericArrayType;	34	import java.lang.reflect.GenericArrayType;
34	import java.lang.reflect.GenericDeclaration;	35	import java.lang.reflect.GenericDeclaration;
		36	import java.lang.reflect.InvocationHandler;
		37	import java.lang.reflect.InvocationTargetException;
		38	import java.lang.reflect.Method;
35	import java.lang.reflect.ParameterizedType;	39	import java.lang.reflect.ParameterizedType;
		40	import java.lang.reflect.Proxy;
36	import java.lang.reflect.Type;	41	import java.lang.reflect.Type;
37	import java.lang.reflect.TypeVariable;	42	import java.lang.reflect.TypeVariable;
38	import java.lang.reflect.WildcardType;	43	import java.lang.reflect.WildcardType;
		44	import java.security.AccessControlException;
39	import java.util.Arrays;	45	import java.util.Arrays;
40	import java.util.Collection;	46	import java.util.Collection;
41	import java.util.concurrent.atomic.AtomicReference;	47	import java.util.concurrent.atomic.AtomicReference;
Lines 146-152 private static ClassOwnership detectJvmBehavior() { Link Here
146	*/	152	*/
147	static <D extends GenericDeclaration> TypeVariable<D> newArtificialTypeVariable(	153	static <D extends GenericDeclaration> TypeVariable<D> newArtificialTypeVariable(
148	D declaration, String name, Type... bounds) {	154	D declaration, String name, Type... bounds) {
149	return new TypeVariableImpl<D>(	155	return newTypeVariableImpl(
150	declaration,	156	declaration,
151	name,	157	name,
152	(bounds.length == 0)	158	(bounds.length == 0)
Lines 314-321 static String toString(Type type) { Link Here
314	private static final long serialVersionUID = 0;	320	private static final long serialVersionUID = 0;
315	}	321	}
316		322
317	private static final class TypeVariableImpl<D extends GenericDeclaration>	323	private static <D extends GenericDeclaration> TypeVariable<D> newTypeVariableImpl(
318	implements TypeVariable<D> {	324	D genericDeclaration, String name, Type[] bounds) {
		325	TypeVariableImpl<D> typeVariableImpl =
		326	new TypeVariableImpl<D>(genericDeclaration, name, bounds);
		327	@SuppressWarnings("unchecked")
		328	TypeVariable<D> typeVariable = Reflection.newProxy(
		329	TypeVariable.class, new TypeVariableInvocationHandler(typeVariableImpl));
		330	return typeVariable;
		331	}
		332
		333	/**
		334	* Invocation handler to work around a compatibility problem between Java 7 and Java 8.
		335	*
		336	* <p>Java 8 introduced a new method {@code getAnnotatedBounds()} in the {@link TypeVariable}
		337	* interface, whose return type {@code AnnotatedType[]} is also new in Java 8. That means that we
		338	* cannot implement that interface in source code in a way that will compile on both Java 7 and
		339	* Java 8. If we include the {@code getAnnotatedBounds()} method then its return type means
		340	* it won't compile on Java 7, while if we don't include the method then the compiler will
		341	* complain that an abstract method is unimplemented. So instead we use a dynamic proxy to
		342	* get an implementation. If the method being called on the {@code TypeVariable} instance has
		343	* the same name as one of the public methods of {@link TypeVariableImpl}, the proxy calls
		344	* the same method on its instance of {@code TypeVariableImpl}. Otherwise it throws {@link
		345	* UnsupportedOperationException}; this should only apply to {@code getAnnotatedBounds()}. This
		346	* does mean that users on Java 8 who obtain an instance of {@code TypeVariable} from {@link
		347	* TypeResolver#resolveType} will not be able to call {@code getAnnotatedBounds()} on it, but that
		348	* should hopefully be rare.
		349	*
		350	* <p>This workaround should be removed at a distant future time when we no longer support Java
		351	* versions earlier than 8.
		352	*/
		353	private static final class TypeVariableInvocationHandler implements InvocationHandler {
		354	private static final ImmutableMap<String, Method> typeVariableMethods;
		355	static {
		356	ImmutableMap.Builder<String, Method> builder = ImmutableMap.builder();
		357	for (Method method : TypeVariableImpl.class.getMethods()) {
		358	if (method.getDeclaringClass().equals(TypeVariableImpl.class)) {
		359	try {
		360	method.setAccessible(true);
		361	} catch (AccessControlException e) {
		362	// OK: the method is accessible to us anyway. The setAccessible call is only for
		363	// unusual execution environments where that might not be true.
		364	}
		365	builder.put(method.getName(), method);
		366	}
		367	}
		368	typeVariableMethods = builder.build();
		369	}
		370
		371	private final TypeVariableImpl<?> typeVariableImpl;
		372
		373	TypeVariableInvocationHandler(TypeVariableImpl<?> typeVariableImpl) {
		374	this.typeVariableImpl = typeVariableImpl;
		375	}
		376
		377	@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		378	String methodName = method.getName();
		379	Method typeVariableMethod = typeVariableMethods.get(methodName);
		380	if (typeVariableMethod == null) {
		381	throw new UnsupportedOperationException(methodName);
		382	} else {
		383	try {
		384	return typeVariableMethod.invoke(typeVariableImpl, args);
		385	} catch (InvocationTargetException e) {
		386	throw e.getCause();
		387	}
		388	}
389	}
390	}
391
392	private static final class TypeVariableImpl<D extends GenericDeclaration> {
319		393
320	private final D genericDeclaration;	394	private final D genericDeclaration;
321	private final String name;	395	private final String name;
Lines 328-342 static String toString(Type type) { Link Here
328	this.bounds = ImmutableList.copyOf(bounds);	402	this.bounds = ImmutableList.copyOf(bounds);
329	}	403	}
330		404
331	@Override public Type[] getBounds() {	405	public Type[] getBounds() {
332	return toArray(bounds);	406	return toArray(bounds);
333	}	407	}
334		408
335	@Override public D getGenericDeclaration() {	409	public D getGenericDeclaration() {
336	return genericDeclaration;	410	return genericDeclaration;
337	}	411	}
338		412
339	@Override public String getName() {	413	public String getName() {
		414	return name;
		415	}
		416
		417	public String getTypeName() {
340	return name;	418	return name;
341	}	419	}
342		420
Lines 351-358 static String toString(Type type) { Link Here
351	}	429	}
352		430
353	@Override public boolean equals(Object obj) {	431	@Override public boolean equals(Object obj) {
354	if (obj instanceof TypeVariable) {	432	if (obj != null
355	TypeVariable<?> that = (TypeVariable<?>) obj;	433	&& Proxy.isProxyClass(obj.getClass())
		434	&& Proxy.getInvocationHandler(obj) instanceof TypeVariableInvocationHandler) {
		435	TypeVariableInvocationHandler typeVariableInvocationHandler =
		436	(TypeVariableInvocationHandler) Proxy.getInvocationHandler(obj);
		437	TypeVariableImpl<?> that = typeVariableInvocationHandler.typeVariableImpl;
356	return name.equals(that.getName())	438	return name.equals(that.getName())
357	&& genericDeclaration.equals(that.getGenericDeclaration());	439	&& genericDeclaration.equals(that.getGenericDeclaration());
358	}	440	}
359	proactively prevent name shadowing with Java 8. ------------- Created by MOE:	441	proactively prevent name shadowing with Java 8. ------------- Created by MOE:
360	http://code.google.com/p/moe-java MOE_MIGRATED_REVID=57671698	442	http://code.google.com/p/moe-java MOE_MIGRATED_REVID=57671698
361	--
362	.../google/common/base/super/com/google/common/base/Splitter.java \| 8 ++++----	443	.../google/common/base/super/com/google/common/base/Splitter.java \| 8 ++++----
363	guava/src/com/google/common/base/Splitter.java \| 8 ++++----	444	guava/src/com/google/common/base/Splitter.java \| 8 ++++----
364	2 files changed, 8 insertions(+), 8 deletions(-)	445	2 files changed, 8 insertions(+), 8 deletions(-)

Lines 387-393 public Splitter trimResults(CharMatcher trimmer) { Link Here

(-)a/guava/src/com/google/common/base/Splitter.java (-3 / +3 lines)
387		387
388	return new Iterable<String>() {	388	return new Iterable<String>() {
389	@Override public Iterator<String> iterator() {	389	@Override public Iterator<String> iterator() {
390	return spliterator(sequence);	390	return splittingIterator(sequence);
391	}	391	}
392	@Override public String toString() {	392	@Override public String toString() {
393	return Joiner.on(", ")	393	return Joiner.on(", ")
Lines 398-404 public Splitter trimResults(CharMatcher trimmer) { Link Here
398	};	398	};
399	}	399	}
400		400
401	private Iterator<String> spliterator(CharSequence sequence) {	401	private Iterator<String> splittingIterator(CharSequence sequence) {
402	return strategy.iterator(this, sequence);	402	return strategy.iterator(this, sequence);
403	}	403	}
404		404
Lines 499-505 private MapSplitter(Splitter outerSplitter, Splitter entrySplitter) { Link Here
499	public Map<String, String> split(CharSequence sequence) {	499	public Map<String, String> split(CharSequence sequence) {
500	Map<String, String> map = new LinkedHashMap<String, String>();	500	Map<String, String> map = new LinkedHashMap<String, String>();
501	for (String entry : outerSplitter.split(sequence)) {	501	for (String entry : outerSplitter.split(sequence)) {
502	Iterator<String> entryFields = entrySplitter.spliterator(entry);	502	Iterator<String> entryFields = entrySplitter.splittingIterator(entry);
503		503
504	checkArgument(entryFields.hasNext(), INVALID_ENTRY_MESSAGE, entry);	504	checkArgument(entryFields.hasNext(), INVALID_ENTRY_MESSAGE, entry);
505	String key = entryFields.next();	505	String key = entryFields.next();