This patch updates JTypeParameter.getBounds(), JWildcardType.getUpperBounds() and JWildcardType.getLowerBounds() to simply return the array of type bounds directly without having to use the intermediate JBounds type. The wildcard type bounds follows the model used by the reflection API.
Review by: spoon
git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@2090 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/HasBounds.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/HasBounds.java
deleted file mode 100644
index b5fd866..0000000
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/HasBounds.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright 2007 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.google.gwt.core.ext.typeinfo;
-
-/**
- * Interface implemented by elements that can have can have have bounds, namely
- * type parameters and wildcards.
- */
-public interface HasBounds {
-
- /**
- * Returns the bounds on this element.
- *
- * @return the bounds of this element; cannot be null
- */
- JBound getBounds();
-
- /**
- * Returns the first bound of this element.
- *
- * @return the first bound of this element; cannot be null
- */
- JClassType getFirstBound();
-}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JBound.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JBound.java
deleted file mode 100644
index 36b8224..0000000
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JBound.java
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright 2007 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.google.gwt.core.ext.typeinfo;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * Represents a bound for a {@link JTypeParameter} or a {@link JWildcardType}.
- */
-public abstract class JBound {
- /**
- * Types which make up this bound.
- */
- private final List<JClassType> bounds = new ArrayList<JClassType>();
-
- JBound(JClassType[] bounds) {
- this.bounds.addAll(Arrays.asList(bounds));
- }
-
- public JClassType[] getBounds() {
- return bounds.toArray(TypeOracle.NO_JCLASSES);
- }
-
- public JClassType getFirstBound() {
- assert (!bounds.isEmpty());
-
- return bounds.get(0);
- }
-
- public String getQualifiedSourceName() {
- return toString(true);
- }
-
- public String getSimpleSourceName() {
- return toString(false);
- }
-
- public abstract JLowerBound isLowerBound();
-
- public abstract JUpperBound isUpperBound();
-
- @Override
- public String toString() {
- return getQualifiedSourceName();
- }
-
- abstract JClassType[] getSubtypes();
-
- abstract boolean isAssignableFrom(JClassType otherType);
-
- abstract boolean isAssignableTo(JClassType otherType);
-
- private String toString(boolean useQualifiedNames) {
- StringBuffer sb = new StringBuffer();
-
- if (isUpperBound() != null) {
- sb.append(" extends ");
- } else {
- sb.append(" super ");
- }
-
- boolean needsAmpersand = false;
- for (JClassType bound : bounds) {
-
- if (needsAmpersand) {
- sb.append(" & ");
- } else {
- needsAmpersand = true;
- }
-
- String name;
- if (useQualifiedNames) {
- name = bound.getParameterizedQualifiedSourceName();
- } else {
- name = bound.getSimpleSourceName();
- }
-
- sb.append(name);
- }
-
- return sb.toString();
- }
-}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JClassType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JClassType.java
index 80fc3de..82760f3 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JClassType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JClassType.java
@@ -124,8 +124,7 @@
JTypeParameter lhsTypeParam = lhsType.isTypeParameter();
JTypeParameter rhsTypeParam = rhsType.isTypeParameter();
if (lhsTypeParam != null) {
- JBound bounds = lhsTypeParam.getBounds();
- JClassType[] lhsTypeBounds = bounds.getBounds();
+ JClassType[] lhsTypeBounds = lhsTypeParam.getBounds();
for (JClassType lhsTypeBound : lhsTypeBounds) {
if (!areClassTypesAssignable(lhsTypeBound, rhsType)) {
// Done, the rhsType was not assignable to one of the bounds.
@@ -136,7 +135,7 @@
// Done, the rhsType was assignable to all of the bounds.
return true;
} else if (rhsTypeParam != null) {
- JClassType[] possibleSubtypeBounds = rhsTypeParam.getBounds().getBounds();
+ JClassType[] possibleSubtypeBounds = rhsTypeParam.getBounds();
for (JClassType possibleSubtypeBound : possibleSubtypeBounds) {
if (areClassTypesAssignable(lhsType, possibleSubtypeBound)) {
// Done, at least one bound is assignable to this type.
@@ -159,12 +158,12 @@
} else if (lhsWildcard != null) {
// The lhs type is a wildcard but the rhs is not.
// ? extends T, U OR ? super T, U
- JBound lhsBound = lhsWildcard.getBounds();
- if (lhsBound.isUpperBound() != null) {
- return areClassTypesAssignable(lhsBound.getFirstBound(), rhsType);
- } else {
+ JClassType[] lowerBounds = lhsWildcard.getLowerBounds();
+ if (lowerBounds.length > 0) {
// ? super T will reach object no matter what the rhs type is
return true;
+ } else {
+ return areClassTypesAssignable(lhsWildcard.getFirstBound(), rhsType);
}
}
@@ -248,18 +247,18 @@
assert (lhsWildcard != rhsWildcard);
assert (lhsWildcard != null && rhsWildcard != null);
- JBound lhsBound = lhsWildcard.getBounds();
- JBound rhsBound = rhsWildcard.getBounds();
-
- if (lhsBound.isUpperBound() != null && rhsBound.isUpperBound() != null) {
- // lhsType: ? extends T, rhsType: ? extends U
- return areClassTypesAssignable(lhsBound.getFirstBound(),
- rhsBound.getFirstBound());
- } else if (lhsBound.isLowerBound() != null
- && rhsBound.isLowerBound() != null) {
+ if (lhsWildcard.getLowerBounds().length > 0
+ && rhsWildcard.getLowerBounds().length > 0) {
// lhsType: ? super T, rhsType ? super U
- return areClassTypesAssignable(rhsBound.getFirstBound(),
- lhsBound.getFirstBound());
+ return areClassTypesAssignable(rhsWildcard.getFirstBound(),
+ lhsWildcard.getFirstBound());
+ } else if (lhsWildcard.getUpperBounds().length > 0
+ && lhsWildcard.getLowerBounds().length == 0
+ && rhsWildcard.getUpperBounds().length > 0
+ && rhsWildcard.getLowerBounds().length == 0) {
+ // lhsType: ? extends T, rhsType: ? extends U
+ return areClassTypesAssignable(lhsWildcard.getFirstBound(),
+ rhsWildcard.getFirstBound());
}
return false;
@@ -285,11 +284,12 @@
return areWildcardsAssignable(lhsWildcard, rhsWildcard);
} else {
// LHS is a wildcard but the RHS is not.
- JBound lhsBound = lhsWildcard.getBounds();
- if (lhsBound.isLowerBound() == null) {
- return areClassTypesAssignable(lhsBound.getFirstBound(), rhsTypeArg);
+ if (lhsWildcard.getLowerBounds().length > 0) {
+ return areClassTypesAssignable(rhsTypeArg,
+ lhsWildcard.getFirstBound());
} else {
- return areClassTypesAssignable(rhsTypeArg, lhsBound.getFirstBound());
+ return areClassTypesAssignable(lhsWildcard.getFirstBound(),
+ rhsTypeArg);
}
}
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JLowerBound.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JLowerBound.java
deleted file mode 100644
index f4231ce..0000000
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JLowerBound.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright 2007 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.google.gwt.core.ext.typeinfo;
-
-/**
- * Represents the super bound used in {@link JWildcardType}s.
- */
-public class JLowerBound extends JBound {
- /**
- *
- */
- public JLowerBound(JClassType lowerBound) {
- this(new JClassType[] {lowerBound});
- }
-
- /**
- *
- */
- public JLowerBound(JClassType[] lowerBounds) {
- super(lowerBounds);
- }
-
- @Override
- public JLowerBound isLowerBound() {
- return this;
- }
-
- @Override
- public JUpperBound isUpperBound() {
- return null;
- }
-
- @Override
- JClassType[] getSubtypes() {
- return TypeOracle.NO_JCLASSES;
- }
-
- @Override
- boolean isAssignableFrom(JClassType otherType) {
- JWildcardType wildcard = otherType.isWildcard();
- if (wildcard != null) {
- JBound otherBounds = wildcard.getBounds();
- if (otherBounds.isUpperBound() != null) {
- // A lower bound cannot be assigned from an upper bound wildcard type.
- return false;
- }
-
- otherType = otherBounds.getFirstBound();
- }
-
- /*
- * Only check the first bound since a lower bound cannot specify multiple
- * types.
- */
- return getFirstBound().isAssignableTo(otherType);
- }
-
- @Override
- boolean isAssignableTo(JClassType otherType) {
- JWildcardType wildcard = otherType.isWildcard();
- if (wildcard != null) {
- JBound otherBounds = wildcard.getBounds();
- if (otherBounds.isUpperBound() != null) {
- // A lower bound cannot be assigned from an upper bound wildcard type.
- return false;
- }
-
- otherType = otherBounds.getFirstBound();
- }
-
- return getFirstBound().isAssignableFrom(otherType);
- }
-}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameterizedType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameterizedType.java
index ec7ae54..5fb3d07 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameterizedType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameterizedType.java
@@ -51,10 +51,8 @@
for (int i = 0; i < newTypeArgs.length; ++i) {
JClassType newTypeArg = substitutionMap.get(typeParameters[i]);
if (newTypeArg == null) {
- JBound typeParamBounds = typeParameters[i].getBounds();
- JUpperBound newTypeArgBounds = new JUpperBound(
- typeParamBounds.getFirstBound());
- newTypeArg = oracle.getWildcardType(newTypeArgBounds);
+ newTypeArg = oracle.getWildcardType(true,
+ typeParameters[i].getFirstBound());
}
newTypeArgs[i] = newTypeArg;
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JTypeParameter.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JTypeParameter.java
index 874e4c4..b6ab8e7 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JTypeParameter.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JTypeParameter.java
@@ -21,8 +21,8 @@
/**
* Represents one of the type parameters in a generic type.
*/
-public class JTypeParameter extends JDelegatingClassType implements HasBounds {
- private JBound bounds;
+public class JTypeParameter extends JDelegatingClassType {
+ private JClassType[] bounds;
private final int ordinal;
private final String typeName;
@@ -41,7 +41,7 @@
return getBaseType().findMethod(name, paramTypes);
}
- public JBound getBounds() {
+ public JClassType[] getBounds() {
return bounds;
}
@@ -88,32 +88,33 @@
@Override
public String getQualifiedSourceName() {
- return typeName + bounds.getQualifiedSourceName();
+ return toString(false);
}
@Override
public String getSimpleSourceName() {
- return typeName + bounds.getSimpleSourceName();
+ return toString(true);
}
-
- @Override
+
+ @Override
public JClassType[] getSubtypes() {
JClassType[] subtypes = super.getSubtypes();
List<JClassType> intersectionTypes = new ArrayList<JClassType>();
-
- if (getFirstBound().isInterface() == null && isAssignableFrom(getFirstBound())) {
+
+ if (getFirstBound().isInterface() == null
+ && isAssignableFrom(getFirstBound())) {
// Include the first bound as a subtype if it is not an interface and it
// is assignable to all of our bounds.
intersectionTypes.add(getFirstBound());
}
-
+
for (JClassType subtype : subtypes) {
if (isAssignableFrom(subtype)) {
intersectionTypes.add(subtype);
}
}
-
- // Only types that intersect with all our bounds make it here.
+
+ // Only types that intersect with all our bounds make it here.
return intersectionTypes.toArray(TypeOracle.NO_JCLASSES);
}
@@ -142,9 +143,9 @@
return null;
}
- public void setBounds(JBound bounds) {
+ public void setBounds(JClassType[] bounds) {
this.bounds = bounds;
- super.setBaseType(bounds.getFirstBound());
+ super.setBaseType(bounds[0]);
}
@Override
@@ -164,4 +165,25 @@
JClassType getSubstitutedType(JParameterizedType parameterizedType) {
return parameterizedType.getTypeParameterSubstitution(this);
}
+
+ private String toString(boolean simpleName) {
+ StringBuffer sb = new StringBuffer();
+ sb.append(typeName);
+ sb.append(" extends ");
+ for (int i = 0; i < bounds.length; ++i) {
+ if (i != 0) {
+ sb.append(" & ");
+ }
+
+ String boundName;
+ if (simpleName) {
+ boundName = bounds[i].getSimpleSourceName();
+ } else {
+ boundName = bounds[i].getParameterizedQualifiedSourceName();
+ }
+ sb.append(boundName);
+ }
+
+ return sb.toString();
+ }
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JUpperBound.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JUpperBound.java
deleted file mode 100644
index 2fbf9cf..0000000
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JUpperBound.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright 2007 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.google.gwt.core.ext.typeinfo;
-
-/**
- * Represents the extends bound used in {@link JTypeParameter}s and
- * {@link JWildcardType}s.
- */
-public class JUpperBound extends JBound {
- public JUpperBound(JClassType upperBound) {
- this(new JClassType[] {upperBound});
- }
-
- /**
- *
- */
- public JUpperBound(JClassType[] upperBounds) {
- super(upperBounds);
- }
-
- @Override
- public JLowerBound isLowerBound() {
- return null;
- }
-
- @Override
- public JUpperBound isUpperBound() {
- return this;
- }
-
- @Override
- JClassType[] getSubtypes() {
- return getFirstBound().getSubtypes();
- }
-
- @Override
- boolean isAssignableFrom(JClassType otherType) {
- JWildcardType wildcard = otherType.isWildcard();
- if (wildcard != null) {
- if (wildcard.getBounds().isLowerBound() != null) {
- /*
- * Upper bounds can be assigned from lower bounds if both of their
- * bounding types are Object.
- */
- JClassType firstBound = getFirstBound();
- JClassType javaLangObject = firstBound.getOracle().getJavaLangObject();
- return firstBound == javaLangObject && wildcard.getFirstBound() == javaLangObject;
- }
-
- return getFirstBound().isAssignableFrom(wildcard.getFirstBound());
- } else {
- /*
- * This bound can be assigned from another type if each of the bounding
- * types is assignable from the other type.
- */
- JClassType[] bounds = getBounds();
- for (JClassType bound : bounds) {
- if (!bound.isAssignableFrom(otherType)) {
- return false;
- }
- }
- }
-
- return true;
- }
-
- @Override
- boolean isAssignableTo(JClassType otherType) {
- JClassType[] bounds = getBounds();
- for (JClassType bound : bounds) {
- if (bound.isAssignableTo(otherType)) {
- return true;
- }
- }
-
- return false;
- }
-}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JWildcardType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JWildcardType.java
index 71ef4ef..b25cf49 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JWildcardType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JWildcardType.java
@@ -18,12 +18,15 @@
/**
* Represents a wildcard type argument to a parameterized type.
*/
-public class JWildcardType extends JDelegatingClassType implements HasBounds {
- private final JBound bounds;
+public class JWildcardType extends JDelegatingClassType {
+ private boolean isUpperBound;
- public JWildcardType(JBound bounds) {
- super.setBaseType(bounds.getFirstBound());
- this.bounds = bounds;
+ private JClassType[] lazyLowerBounds;
+ private JClassType[] lazyUpperBounds;
+
+ public JWildcardType(boolean isUpperBound, JClassType typeBound) {
+ this.isUpperBound = isUpperBound;
+ super.setBaseType(typeBound);
}
@Override
@@ -36,19 +39,15 @@
return getBaseType().findMethod(name, paramTypes);
}
- public JBound getBounds() {
- return bounds;
- }
-
@Override
public JClassType getErasedType() {
- if (bounds.isLowerBound() != null) {
- // ? super T erases to Object
- return getOracle().getJavaLangObject();
+ if (isUpperBound) {
+ // ? extends T erases to T
+ return getFirstBound().getErasedType();
}
-
- // ? extends T erases to T
- return getFirstBound().getErasedType();
+
+ // ? super T erases to Object
+ return getOracle().getJavaLangObject();
}
@Override
@@ -62,7 +61,24 @@
}
public JClassType getFirstBound() {
- return getBounds().getFirstBound();
+ return getBaseType();
+ }
+
+ /**
+ * Returns the lower bounds of this wildcard type. If no lower bounds were
+ * declared, an empty array is returned.
+ *
+ * @return the lower bounds of this wildcard type
+ */
+ public JClassType[] getLowerBounds() {
+ if (lazyLowerBounds == null) {
+ if (isUpperBound) {
+ lazyLowerBounds = TypeOracle.NO_JCLASSES;
+ } else {
+ lazyLowerBounds = new JClassType[] {getFirstBound()};
+ }
+ }
+ return lazyLowerBounds;
}
@Override
@@ -78,34 +94,57 @@
@Override
public String getQualifiedSourceName() {
- return "?" + bounds.getQualifiedSourceName();
+ return toString(false);
}
@Override
public String getSimpleSourceName() {
- return "?" + bounds.getSimpleSourceName();
+ return toString(true);
}
-
+
@Override
public JClassType[] getSubtypes() {
+ if (isUpperBound) {
+ return getFirstBound().getSubtypes();
+ }
+
// We are not sure what the correct behavior should be for lower bound
- // wildcards. ? super Number contains ? super T for all T extends Number,
- // but it also includes T for Number extends T. For example, Object is a
+ // wildcards. ? super Number contains ? super T for all T extends Number,
+ // but it also includes T for Number extends T. For example, Object is a
// subtype.
- return bounds.getSubtypes();
+ return TypeOracle.NO_JCLASSES;
}
-
+
@Override
public JClassType getSuperclass() {
- if (bounds.isLowerBound() != null) {
- // The only safe superclass for a ? super T is Object.
- return getOracle().getJavaLangObject();
+ if (isUpperBound) {
+ // The superclass of an upper bound is the upper bound.
+ return getFirstBound();
}
-
- // The superclass of an upper bound is the upper bound.
- return getFirstBound();
+
+ // The only safe superclass for a ? super T is Object.
+ return getOracle().getJavaLangObject();
}
-
+
+ /**
+ * Returns the upper bounds of this wildcard type. If no upper bounds were
+ * declared, an array containing {@link Object} is returned.
+ *
+ * @return the upper bounds of this wildcard type
+ */
+ public JClassType[] getUpperBounds() {
+ if (lazyUpperBounds == null) {
+ if (isUpperBound) {
+ lazyUpperBounds = new JClassType[] {getFirstBound()};
+ } else {
+ // Object is the default upper bound.
+ lazyUpperBounds = new JClassType[] {getOracle().getJavaLangObject()};
+ }
+ }
+
+ return lazyUpperBounds;
+ }
+
@Override
public JGenericType isGenericType() {
return null;
@@ -126,45 +165,31 @@
return this;
}
- @Override
- JClassType getSubstitutedType(JParameterizedType parameterizedType) {
- JClassType[] currentBounds = bounds.getBounds();
- JClassType[] newBounds = new JClassType[currentBounds.length];
- for (int i = 0; i < currentBounds.length; ++i) {
- newBounds[i] = currentBounds[i].getSubstitutedType(parameterizedType);
- }
-
- JBound newBound = bounds.isLowerBound() != null
- ? new JLowerBound(newBounds) : new JUpperBound(newBounds);
- return getOracle().getWildcardType(newBound);
- }
-
/**
* Returns <code>true</code> if this instance has the same bounds that are
* requested.
*
- * @param otherBounds
+ * @param otherWildcard
* @return <code>true</code> if this instance has the same bounds that are
* requested
*/
- boolean hasBounds(JBound otherBounds) {
- if ((bounds.isUpperBound() != null && otherBounds.isLowerBound() != null)
- || (bounds.isLowerBound() != null && otherBounds.isUpperBound() != null)) {
- return false;
- }
+ boolean boundsMatch(JWildcardType otherWildcard) {
+ return isUpperBound == otherWildcard.isUpperBound
+ && getFirstBound() == otherWildcard.getFirstBound();
+ }
- JClassType[] boundTypes = bounds.getBounds();
- JClassType[] otherBoundTypes = otherBounds.getBounds();
+ @Override
+ JClassType getSubstitutedType(JParameterizedType parameterizedType) {
+ return getOracle().getWildcardType(isUpperBound,
+ getFirstBound().getSubstitutedType(parameterizedType));
+ }
- if (boundTypes.length != otherBoundTypes.length) {
- return false;
+ private String toString(boolean simpleName) {
+ String str = "?" + (isUpperBound ? " super " : " extends ");
+ if (simpleName) {
+ return str + getFirstBound().getSimpleSourceName();
+ } else {
+ return str + getFirstBound().getParameterizedQualifiedSourceName();
}
-
- for (int i = 0; i < boundTypes.length; ++i) {
- if (boundTypes[i] != otherBoundTypes[i]) {
- return false;
- }
- }
- return true;
}
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracle.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracle.java
index 29d08a7..8eac005 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracle.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracle.java
@@ -467,8 +467,9 @@
}
}
- public JWildcardType getWildcardType(JBound bounds) {
- JWildcardType wildcardType = new JWildcardType(bounds);
+ public JWildcardType getWildcardType(boolean isUpperBound,
+ JClassType typeBound) {
+ JWildcardType wildcardType = new JWildcardType(isUpperBound, typeBound);
String sig = wildcardType.getQualifiedSourceName();
List<JWildcardType> candidates = wildcardTypes.get(sig);
if (candidates == null) {
@@ -476,7 +477,7 @@
wildcardTypes.put(sig, candidates);
} else {
for (JWildcardType candidate : candidates) {
- if (candidate.hasBounds(bounds)) {
+ if (candidate.boundsMatch(wildcardType)) {
return candidate;
}
}
@@ -583,7 +584,7 @@
/**
* Note, this method is called reflectively from the
- * {@link CacheManager#invalidateOnRefresh(TypeOracle)}.
+ * {@link com.google.gwt.dev.jdt.CacheManager#invalidateOnRefresh(TypeOracle)}.
*
* @param cup compilation unit whose types will be invalidated
*/
@@ -721,7 +722,7 @@
+ " for field " + field.getName() + "; Please use "
+ resultingType.getParameterizedQualifiedSourceName()
+ " as the field's type", null);
-
+
field.setType(resultingType);
} catch (UnableToCompleteException e) {
// Continue; the problem will have been logged.
diff --git a/dev/core/src/com/google/gwt/dev/jdt/TypeOracleBuilder.java b/dev/core/src/com/google/gwt/dev/jdt/TypeOracleBuilder.java
index 087982c..6726d88 100644
--- a/dev/core/src/com/google/gwt/dev/jdt/TypeOracleBuilder.java
+++ b/dev/core/src/com/google/gwt/dev/jdt/TypeOracleBuilder.java
@@ -24,14 +24,12 @@
import com.google.gwt.core.ext.typeinfo.JAnnotationMethod;
import com.google.gwt.core.ext.typeinfo.JAnnotationType;
import com.google.gwt.core.ext.typeinfo.JArrayType;
-import com.google.gwt.core.ext.typeinfo.JBound;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JConstructor;
import com.google.gwt.core.ext.typeinfo.JEnumConstant;
import com.google.gwt.core.ext.typeinfo.JEnumType;
import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.core.ext.typeinfo.JGenericType;
-import com.google.gwt.core.ext.typeinfo.JLowerBound;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JPackage;
import com.google.gwt.core.ext.typeinfo.JParameter;
@@ -40,7 +38,6 @@
import com.google.gwt.core.ext.typeinfo.JRealClassType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.JTypeParameter;
-import com.google.gwt.core.ext.typeinfo.JUpperBound;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.dev.jdt.CacheManager.Mapper;
import com.google.gwt.dev.util.Empty;
@@ -670,7 +667,7 @@
identifierToValue);
}
- private JUpperBound createTypeParameterBounds(TreeLogger logger,
+ private JClassType[] createTypeParameterBounds(TreeLogger logger,
TypeVariableBinding tvBinding) {
TypeBinding firstBound = tvBinding.firstBound;
if (firstBound == null) {
@@ -689,7 +686,7 @@
tvBinding.superclass);
if (Object.class.getName().equals(jupperBound.getQualifiedSourceName())) {
- return new JUpperBound(jupperBound);
+ return new JClassType[] {jupperBound};
} else {
return null;
}
@@ -715,13 +712,13 @@
} else {
/*
* If the first bound was an interface JDT will still include it in the
- * set of superinterfaces. So, we ignore it since we have already added
+ * set of superinterfaces. So, we ignore it since we have already added
* it to the bounds.
*/
}
}
- return new JUpperBound(bounds.toArray(NO_JCLASSES));
+ return bounds.toArray(NO_JCLASSES);
}
/**
@@ -1089,8 +1086,8 @@
private boolean resolveBoundForTypeParameter(TreeLogger logger,
HasTypeParameters genericElement, TypeParameter typeParameter, int ordinal) {
- JBound jbounds = createTypeParameterBounds(logger, typeParameter.binding);
-
+ JClassType[] jbounds = createTypeParameterBounds(logger,
+ typeParameter.binding);
if (jbounds == null) {
return false;
}
@@ -1530,26 +1527,25 @@
assert (wcBinding.otherBounds == null);
- JBound bounds;
+ boolean isUpperBound;
+ JClassType typeBound;
+
switch (wcBinding.boundKind) {
case Wildcard.EXTENDS: {
assert (wcBinding.bound != null);
- JClassType upperBound = (JClassType) resolveType(logger,
- wcBinding.bound);
- bounds = new JUpperBound(new JClassType[] {upperBound});
+ isUpperBound = true;
+ typeBound = (JClassType) resolveType(logger, wcBinding.bound);
}
break;
case Wildcard.SUPER: {
assert (wcBinding.bound != null);
- JClassType lowerBound = (JClassType) resolveType(logger,
- wcBinding.bound);
- bounds = new JLowerBound(new JClassType[] {lowerBound});
+ isUpperBound = false;
+ typeBound = (JClassType) resolveType(logger, wcBinding.bound);
}
break;
case Wildcard.UNBOUND: {
- JClassType upperBound = (JClassType) resolveType(logger,
- wcBinding.erasure());
- bounds = new JUpperBound(new JClassType[] {upperBound});
+ isUpperBound = true;
+ typeBound = (JClassType) resolveType(logger, wcBinding.erasure());
}
break;
default:
@@ -1557,7 +1553,7 @@
return null;
}
- return oracle.getWildcardType(bounds);
+ return oracle.getWildcardType(isUpperBound, typeBound);
}
// Log other cases we know about that don't make sense.
diff --git a/dev/core/test/com/google/gwt/core/ext/typeinfo/JAbstractMethodTest.java b/dev/core/test/com/google/gwt/core/ext/typeinfo/JAbstractMethodTest.java
index 25c5139..8e09fc9 100644
--- a/dev/core/test/com/google/gwt/core/ext/typeinfo/JAbstractMethodTest.java
+++ b/dev/core/test/com/google/gwt/core/ext/typeinfo/JAbstractMethodTest.java
@@ -80,10 +80,7 @@
// Check the bound of the first type parameter. It should be a single
// upper bound.
-
- JBound genericTypeBound = typeParameter.getBounds();
- assertNotNull(genericTypeBound.isUpperBound());
- JClassType [] genericTypeBounds = genericTypeBound.getBounds();
+ JClassType [] genericTypeBounds = typeParameter.getBounds();
assertEquals(1, genericTypeBounds.length);
// Check to see that the upper bound is a parameterized type.
@@ -119,10 +116,7 @@
// Check the bound of the type parameter. It should have a single upper
// bound.
-
- JBound typeArgBound = typeArgTypeParameter.getBounds();
- assertNotNull(typeArgBound.isUpperBound());
- JClassType [] typeArgBounds = typeArgBound.getBounds();
+ JClassType [] typeArgBounds = typeArgTypeParameter.getBounds();
assertEquals(1, typeArgBounds.length);
// Verify that the bound type is actually a reference to java.io.Serializable.
diff --git a/dev/core/test/com/google/gwt/core/ext/typeinfo/JGenericTypeTest.java b/dev/core/test/com/google/gwt/core/ext/typeinfo/JGenericTypeTest.java
index d3e9ef3..daa6fad 100644
--- a/dev/core/test/com/google/gwt/core/ext/typeinfo/JGenericTypeTest.java
+++ b/dev/core/test/com/google/gwt/core/ext/typeinfo/JGenericTypeTest.java
@@ -77,10 +77,7 @@
// Check the bound of the first type parameter. It should be a single
// upper bound.
-
- JBound genericTypeBound = typeParameter.getBounds();
- assertNotNull(genericTypeBound.isUpperBound());
- JClassType [] genericTypeBounds = genericTypeBound.getBounds();
+ JClassType [] genericTypeBounds = typeParameter.getBounds();
assertEquals(1, genericTypeBounds.length);
// Check to see that the upper bound is a parameterized type.
@@ -116,10 +113,7 @@
// Check the bound of the type parameter. It should have a single upper
// bound.
-
- JBound typeArgBound = typeArgTypeParameter.getBounds();
- assertNotNull(typeArgBound.isUpperBound());
- JClassType [] typeArgBounds = typeArgBound.getBounds();
+ JClassType [] typeArgBounds = typeArgTypeParameter.getBounds();
assertEquals(1, typeArgBounds.length);
// Verify that the bound type is actually a reference to java.io.Serializable.
@@ -179,10 +173,7 @@
JTypeParameter typeParameter = typeParameters[0];
assertEquals("T", typeParameter.getName());
- JBound bound = typeParameter.getBounds();
- assertNotNull(bound.isUpperBound());
-
- JClassType[] bounds = bound.getBounds();
+ JClassType[] bounds = typeParameter.getBounds();
assertEquals(1, bounds.length);
assertEquals(moduleContext.getOracle().getType(Serializable.class.getName()),
bounds[0]);
diff --git a/dev/core/test/com/google/gwt/core/ext/typeinfo/JParameterizedTypeTest.java b/dev/core/test/com/google/gwt/core/ext/typeinfo/JParameterizedTypeTest.java
index 0b23f6b..6c10840 100644
--- a/dev/core/test/com/google/gwt/core/ext/typeinfo/JParameterizedTypeTest.java
+++ b/dev/core/test/com/google/gwt/core/ext/typeinfo/JParameterizedTypeTest.java
@@ -89,8 +89,8 @@
public void testGenericClass_LowerBoundWildcard() throws NotFoundException {
TypeOracle oracle = moduleContext.getOracle();
JGenericType genericType = getGenericTestType();
- JWildcardType lowerBoundWildcard = oracle.getWildcardType(new JLowerBound(
- new JClassType[] {integerType}));
+ JWildcardType lowerBoundWildcard = oracle.getWildcardType(false,
+ integerType);
JClassType type = oracle.getParameterizedType(genericType,
new JClassType[] {lowerBoundWildcard});
@@ -103,8 +103,8 @@
public void testGenericClass_UnboundWildcard() throws NotFoundException {
TypeOracle oracle = moduleContext.getOracle();
JGenericType genericType = getGenericTestType();
- JWildcardType upperBoundWildcard = oracle.getWildcardType(new JUpperBound(
- new JClassType[] {oracle.getJavaLangObject()}));
+ JWildcardType upperBoundWildcard = oracle.getWildcardType(true,
+ oracle.getJavaLangObject());
JClassType type = oracle.getParameterizedType(genericType,
new JClassType[] {upperBoundWildcard});
@@ -117,8 +117,7 @@
public void testGenericClass_UpperBoundWildcard() throws NotFoundException {
TypeOracle oracle = moduleContext.getOracle();
JGenericType genericType = getGenericTestType();
- JWildcardType upperBoundWildcard = oracle.getWildcardType(new JUpperBound(
- new JClassType[] {integerType}));
+ JWildcardType upperBoundWildcard = oracle.getWildcardType(true, integerType);
JClassType type = oracle.getParameterizedType(genericType,
new JClassType[] {upperBoundWildcard});
@@ -206,8 +205,8 @@
JGenericType myCustomListType = oracle.getType(MyCustomList.class.getName()).isGenericType();
JParameterizedType parameterizedMyCustomList = oracle.getParameterizedType(
myCustomListType, new JClassType[] {
- oracle.getWildcardType(new JUpperBound(
- oracle.getType(Serializable.class.getName()))), integerType});
+ oracle.getWildcardType(true,
+ oracle.getType(Serializable.class.getName())), integerType});
JClassType[] expected = {
oracle.getType(MyIntegerList.class.getName()),
parameterizedMyCustomList};
@@ -231,21 +230,21 @@
JGenericType genericList = (JGenericType) oracle.getType(List.class.getName());
// ?
- JWildcardType unboundWildcard = oracle.getWildcardType(new JUpperBound(
- oracle.getJavaLangObject()));
-
+ JWildcardType unboundWildcard = oracle.getWildcardType(true,
+ oracle.getJavaLangObject());
+
// ? extends Number
- JWildcardType numUpperBoundWildcard = oracle.getWildcardType(new JUpperBound(
- oracle.getType(Number.class.getName())));
+ JWildcardType numUpperBoundWildcard = oracle.getWildcardType(true,
+ oracle.getType(Number.class.getName()));
// List<?>
JParameterizedType unboundList = oracle.getParameterizedType(genericList,
new JClassType[] {unboundWildcard});
-
+
// List<? extends Number>
JParameterizedType listOfExtendsNumber = oracle.getParameterizedType(
genericList, new JClassType[] {numUpperBoundWildcard});
-
+
// List<?> should be assignable from List<? extends Number>
assertTrue(unboundList.isAssignableFrom(listOfExtendsNumber));
assertFalse(unboundList.isAssignableTo(listOfExtendsNumber));
@@ -254,8 +253,8 @@
assertTrue(listOfExtendsNumber.isAssignableTo(unboundList));
// ? extends Integer
- JWildcardType intUpperBoundWildcard = oracle.getWildcardType(new JUpperBound(
- integerType));
+ JWildcardType intUpperBoundWildcard = oracle.getWildcardType(true,
+ integerType);
// List<? extends Integer>
JParameterizedType listOfExtendsInteger = oracle.getParameterizedType(
@@ -269,15 +268,15 @@
assertTrue(listOfExtendsInteger.isAssignableTo(listOfExtendsNumber));
// List<? super Integer> should be assignable from List<? super Number>
- JWildcardType numLowerBoundWildcard = oracle.getWildcardType(new JLowerBound(
- oracle.getType(Number.class.getName())));
- JWildcardType intLowerBoundWildcard = oracle.getWildcardType(new JLowerBound(
- integerType));
+ JWildcardType numLowerBoundWildcard = oracle.getWildcardType(false,
+ oracle.getType(Number.class.getName()));
+ JWildcardType intLowerBoundWildcard = oracle.getWildcardType(false,
+ integerType);
// List<? super Number>
JParameterizedType listOfSuperNumber = oracle.getParameterizedType(
genericList, new JClassType[] {numLowerBoundWildcard});
-
+
// List<? super Interger>
JParameterizedType listOfSuperInteger = oracle.getParameterizedType(
genericList, new JClassType[] {intLowerBoundWildcard});
@@ -303,47 +302,54 @@
// List<List<String>> is not assignable from List<Vector<String>>
JParameterizedType listOfListOfString = oracle.getParameterizedType(
genericList, new JClassType[] {listOfString});
-
+
JGenericType genericVector = oracle.getType(Vector.class.getName()).isGenericType();
- JParameterizedType vectorOfString = oracle.getParameterizedType(genericVector, new JClassType[] {stringType});
- JParameterizedType listOfVectorOfString = oracle.getParameterizedType(genericList, new JClassType[] {vectorOfString});
-
+ JParameterizedType vectorOfString = oracle.getParameterizedType(
+ genericVector, new JClassType[] {stringType});
+ JParameterizedType listOfVectorOfString = oracle.getParameterizedType(
+ genericList, new JClassType[] {vectorOfString});
+
assertFalse(listOfListOfString.isAssignableFrom(listOfVectorOfString));
assertFalse(listOfVectorOfString.isAssignableFrom(listOfListOfString));
-
+
// List<List> is not assignable from List<List<String>>
- JClassType listOfRawList = oracle.getParameterizedType(genericList, new JClassType[] {genericList.getRawType()});
+ JClassType listOfRawList = oracle.getParameterizedType(genericList,
+ new JClassType[] {genericList.getRawType()});
assertFalse(listOfRawList.isAssignableFrom(listOfListOfString));
assertFalse(listOfListOfString.isAssignableFrom(listOfRawList));
-
+
JGenericType genericClass = oracle.getType(GenericClass.class.getName()).isGenericType();
- JParameterizedType parameterizedGenericClass = oracle.getParameterizedType(genericClass, new JClassType[] {stringType});
+ JParameterizedType parameterizedGenericClass = oracle.getParameterizedType(
+ genericClass, new JClassType[] {stringType});
JClassType extendsRawGenericClass = oracle.getType(ExtendsRawGenericClass.class.getName());
- // GenericClass<String> is assignable from ExtendsRawGenericClass
+ // GenericClass<String> is assignable from ExtendsRawGenericClass
assertTrue(parameterizedGenericClass.isAssignableFrom(extendsRawGenericClass));
-
+
// ExtendsRawGenericClass is not assignable from GenericClass<String>
assertFalse(extendsRawGenericClass.isAssignableFrom(parameterizedGenericClass));
// List<List<? extends Number>>
- JClassType listOfListOfExtendsNumber = oracle.getParameterizedType(genericList, new JClassType[] {listOfExtendsNumber});
+ JClassType listOfListOfExtendsNumber = oracle.getParameterizedType(
+ genericList, new JClassType[] {listOfExtendsNumber});
// List<List<? extends Integer>>
- JClassType listOfListOfExtendsInteger = oracle.getParameterizedType(genericList, new JClassType[] {listOfExtendsInteger});
-
+ JClassType listOfListOfExtendsInteger = oracle.getParameterizedType(
+ genericList, new JClassType[] {listOfExtendsInteger});
+
assertFalse(listOfListOfExtendsNumber.isAssignableFrom(listOfListOfExtendsInteger));
-
+
// List<Integer>
- JClassType listOfInteger = oracle.getParameterizedType(genericList, new JClassType[] {integerType});
-
+ JClassType listOfInteger = oracle.getParameterizedType(genericList,
+ new JClassType[] {integerType});
+
// List<? extends Number> is assignable from List<Integer>
assertTrue(listOfExtendsNumber.isAssignableFrom(listOfInteger));
assertFalse(listOfExtendsNumber.isAssignableFrom(listOfObject));
-
+
// List<? super Number> is not assignable from List<Integer>
assertFalse(listOfSuperNumber.isAssignableFrom(listOfInteger));
-
+
// List<? super Number> is assignable from List<Object>
assertTrue(listOfSuperNumber.isAssignableFrom(listOfObject));
}
diff --git a/dev/core/test/com/google/gwt/core/ext/typeinfo/JTypeParameterTest.java b/dev/core/test/com/google/gwt/core/ext/typeinfo/JTypeParameterTest.java
index 55d4724..e3e8905 100644
--- a/dev/core/test/com/google/gwt/core/ext/typeinfo/JTypeParameterTest.java
+++ b/dev/core/test/com/google/gwt/core/ext/typeinfo/JTypeParameterTest.java
@@ -144,7 +144,7 @@
assertTrue(testType.isAssignableTo(moduleContext.getOracle().getJavaLangObject()));
// Check that each bound is assignable to this type parameter.
- JClassType[] typeBounds = testType.getBounds().getBounds();
+ JClassType[] typeBounds = testType.getBounds();
for (JClassType typeBound : typeBounds) {
// Test that the type parameter is assignable to the type bound.
assertTrue(testType.isAssignableTo(typeBound));
diff --git a/dev/core/test/com/google/gwt/core/ext/typeinfo/JWildcardTypeTest.java b/dev/core/test/com/google/gwt/core/ext/typeinfo/JWildcardTypeTest.java
index fa6c004..5fdce28 100644
--- a/dev/core/test/com/google/gwt/core/ext/typeinfo/JWildcardTypeTest.java
+++ b/dev/core/test/com/google/gwt/core/ext/typeinfo/JWildcardTypeTest.java
@@ -24,7 +24,6 @@
import java.util.Arrays;
import java.util.HashSet;
-import java.util.List;
import java.util.Set;
/**
@@ -62,13 +61,13 @@
public void testGetErasedType() throws NotFoundException {
TypeOracle oracle = moduleContext.getOracle();
JClassType numberType = oracle.getType(Number.class.getCanonicalName());
-
+
// Tests that ? extends Number erases to number.
- JWildcardType upperBoundWildcard = oracle.getWildcardType(new JUpperBound(numberType));
+ JWildcardType upperBoundWildcard = oracle.getWildcardType(true, numberType);
assertEquals(numberType, upperBoundWildcard.getErasedType());
-
+
// Tests that ? super Number erases to Object
- JWildcardType lowerBoundWildcard = oracle.getWildcardType(new JLowerBound(numberType));
+ JWildcardType lowerBoundWildcard = oracle.getWildcardType(false, numberType);
assertEquals(oracle.getJavaLangObject(), lowerBoundWildcard.getErasedType());
}
@@ -99,8 +98,8 @@
public void testGetSubtypes_LowerBound() throws NotFoundException {
TypeOracle oracle = moduleContext.getOracle();
// <? super Number>
- JWildcardType lowerBoundWildcard = oracle.getWildcardType(new JLowerBound(
- oracle.getType(Number.class.getName())));
+ JWildcardType lowerBoundWildcard = oracle.getWildcardType(false,
+ oracle.getType(Number.class.getName()));
JClassType[] subtypes = lowerBoundWildcard.getSubtypes();
assertEquals(0, subtypes.length);
// assertEquals(oracle.getJavaLangObject(), subtypes[0]);
@@ -109,8 +108,8 @@
public void testGetSubtypes_UpperBound() throws NotFoundException {
TypeOracle oracle = moduleContext.getOracle();
// <? extends CA>
- JWildcardType upperBoundWildcard = oracle.getWildcardType(new JUpperBound(
- oracle.getType(CA.class.getName())));
+ JWildcardType upperBoundWildcard = oracle.getWildcardType(true,
+ oracle.getType(CA.class.getName()));
JClassType[] expected = new JClassType[] {
oracle.getType(CB.class.getName()), oracle.getType(CC.class.getName())};
@@ -130,40 +129,39 @@
public void testIsAssignableFrom() throws NotFoundException {
// Covered by the different testIsAssignableFrom*() variants below.
TypeOracle oracle = moduleContext.getOracle();
-
-
+
JClassType integerType = oracle.getType(Integer.class.getName());
JClassType numberType = oracle.getType(Number.class.getName());
// ? extends Number
- JClassType extendsNumber = oracle.getWildcardType(new JUpperBound(numberType));
-
+ JClassType extendsNumber = oracle.getWildcardType(true, numberType);
+
// ? extends Integer
- JClassType extendsInteger = oracle.getWildcardType(new JUpperBound(integerType));
-
+ JClassType extendsInteger = oracle.getWildcardType(true, integerType);
+
// Integer is not assignable from ? extends Number
assertFalse(integerType.isAssignableFrom(extendsNumber));
-
+
// Integer is assignable from ? extends Integer
assertTrue(integerType.isAssignableFrom(extendsInteger));
-
+
// Number is assignable from ? extends Integer
assertTrue(numberType.isAssignableFrom(extendsInteger));
-
+
// ? super Integer
- JClassType superInteger = oracle.getWildcardType(new JLowerBound(integerType));
-
+ JClassType superInteger = oracle.getWildcardType(false, integerType);
+
// Integer is assignable from ? super Integer
assertFalse(integerType.isAssignableFrom(superInteger));
// ? super Integer is assignable from Number
assertTrue(superInteger.isAssignableFrom(numberType));
- JClassType superNumber = oracle.getWildcardType(new JLowerBound(numberType));
-
+ JClassType superNumber = oracle.getWildcardType(false, numberType);
+
// ? super Number is assignable from Integer
assertTrue(superNumber.isAssignableFrom(integerType));
-
+
// ? super Number is assignable from Character
JClassType characterType = oracle.getType(Character.class.getName());
assertTrue(superNumber.isAssignableFrom(characterType));
@@ -179,11 +177,8 @@
JClassType numberType = oracle.getType(Number.class.getName());
JClassType integerType = oracle.getType(Integer.class.getName());
- JUpperBound numberBound = new JUpperBound(numberType);
- JUpperBound integerBound = new JUpperBound(integerType);
-
- JWildcardType numberWildcard = oracle.getWildcardType(numberBound);
- JWildcardType integerWildcard = oracle.getWildcardType(integerBound);
+ JWildcardType numberWildcard = oracle.getWildcardType(true, numberType);
+ JWildcardType integerWildcard = oracle.getWildcardType(true, integerType);
assertTrue(numberWildcard.isAssignableFrom(integerWildcard));
assertFalse(integerWildcard.isAssignableFrom(numberWildcard));
@@ -196,18 +191,16 @@
TypeOracle oracle = moduleContext.getOracle();
JClassType javaLangObject = oracle.getJavaLangObject();
- JLowerBound lowerBound = new JLowerBound(javaLangObject);
- JUpperBound upperBound = new JUpperBound(javaLangObject);
// ? super Object
- JWildcardType lowerWildcard = oracle.getWildcardType(lowerBound);
-
+ JWildcardType lowerWildcard = oracle.getWildcardType(false, javaLangObject);
+
// ? extends Object
- JWildcardType upperWildcard = oracle.getWildcardType(upperBound);
+ JWildcardType upperWildcard = oracle.getWildcardType(true, javaLangObject);
// ? extends Object assignable from ? super Object
assertTrue(upperWildcard.isAssignableFrom(lowerWildcard));
-
+
// ? super Object assignable from ? extends Object
assertTrue(lowerWildcard.isAssignableFrom(upperWildcard));
}
@@ -221,11 +214,8 @@
JClassType numberType = oracle.getType(Number.class.getName());
JClassType integerType = oracle.getType(Integer.class.getName());
- JLowerBound numberBound = new JLowerBound(numberType);
- JLowerBound integerBound = new JLowerBound(integerType);
-
- JWildcardType numberWildcard = oracle.getWildcardType(numberBound);
- JWildcardType integerWildcard = oracle.getWildcardType(integerBound);
+ JWildcardType numberWildcard = oracle.getWildcardType(false, numberType);
+ JWildcardType integerWildcard = oracle.getWildcardType(false, integerType);
assertTrue(numberWildcard.isAssignableFrom(integerWildcard));
assertTrue(numberWildcard.isAssignableTo(integerWildcard));
@@ -242,11 +232,8 @@
JClassType numberType = oracle.getType(Number.class.getName());
JClassType integerType = oracle.getType(Integer.class.getName());
- JLowerBound numberBound = new JLowerBound(numberType);
- JLowerBound integerBound = new JLowerBound(integerType);
-
- JWildcardType numberWildcard = oracle.getWildcardType(numberBound);
- JWildcardType integerWildcard = oracle.getWildcardType(integerBound);
+ JWildcardType numberWildcard = oracle.getWildcardType(false, numberType);
+ JWildcardType integerWildcard = oracle.getWildcardType(false, integerType);
assertTrue(numberWildcard.isAssignableTo(integerWildcard));
assertTrue(integerWildcard.isAssignableTo(numberWildcard));
@@ -267,11 +254,8 @@
JClassType numberType = oracle.getType(Number.class.getName());
JClassType integerType = oracle.getType(Integer.class.getName());
- JUpperBound numberBound = new JUpperBound(numberType);
- JUpperBound integerBound = new JUpperBound(integerType);
-
- JWildcardType numberWildcard = oracle.getWildcardType(numberBound);
- JWildcardType integerWildcard = oracle.getWildcardType(integerBound);
+ JWildcardType numberWildcard = oracle.getWildcardType(true, numberType);
+ JWildcardType integerWildcard = oracle.getWildcardType(true, integerType);
assertTrue(integerWildcard.isAssignableTo(numberWildcard));
assertFalse(numberWildcard.isAssignableTo(integerWildcard));
@@ -286,11 +270,8 @@
JClassType numberType = oracle.getType(Number.class.getName());
JClassType integerType = oracle.getType(Integer.class.getName());
- JLowerBound numberBound = new JLowerBound(numberType);
- JLowerBound integerBound = new JLowerBound(integerType);
-
- JWildcardType numberWildcard = oracle.getWildcardType(numberBound);
- JWildcardType integerWildcard = oracle.getWildcardType(integerBound);
+ JWildcardType numberWildcard = oracle.getWildcardType(false, numberType);
+ JWildcardType integerWildcard = oracle.getWildcardType(false, integerType);
assertTrue(integerWildcard.isAssignableTo(numberWildcard));
assertTrue(numberWildcard.isAssignableTo(integerWildcard));
@@ -308,7 +289,6 @@
@Override
protected JWildcardType getTestType() throws NotFoundException {
TypeOracle oracle = moduleContext.getOracle();
- return oracle.getWildcardType(new JUpperBound(
- oracle.getType(Number.class.getName())));
+ return oracle.getWildcardType(true, oracle.getType(Number.class.getName()));
}
}
diff --git a/user/src/com/google/gwt/user/rebind/rpc/SerializableTypeOracleBuilder.java b/user/src/com/google/gwt/user/rebind/rpc/SerializableTypeOracleBuilder.java
index 0117e58..e5bc705 100644
--- a/user/src/com/google/gwt/user/rebind/rpc/SerializableTypeOracleBuilder.java
+++ b/user/src/com/google/gwt/user/rebind/rpc/SerializableTypeOracleBuilder.java
@@ -20,7 +20,6 @@
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.TreeLogger.Type;
import com.google.gwt.core.ext.typeinfo.JArrayType;
-import com.google.gwt.core.ext.typeinfo.JBound;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.core.ext.typeinfo.JMethod;
@@ -1064,9 +1063,9 @@
private boolean checkWildcardInstantiable(TreeLogger logger,
JWildcardType wildcard, TypeInfoComputed tic, boolean isSpeculative) {
- JBound bounds = wildcard.getBounds();
+
boolean success;
- if (bounds.isLowerBound() != null) {
+ if (wildcard.getLowerBounds().length > 0) {
// Fail since ? super T for any T implies object also
markAsUninstantiableAndLog(logger, isSpeculative,
"In order to produce smaller client-side code, 'Object' is not allowed; '"
@@ -1074,7 +1073,7 @@
success = false;
} else {
- JClassType firstBound = bounds.getFirstBound();
+ JClassType firstBound = wildcard.getFirstBound();
success = checkTypeInstantiable(logger, firstBound, isSpeculative);
}
