--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000-2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.compiler.lookup;
+
+import java.util.Map;
+import org.eclipse.jdt.core.compiler.CharOperation;
+import org.eclipse.jdt.internal.compiler.ast.Wildcard;
+
+/*
+ * A wildcard acts as an argument for parameterized types, allowing to
+ * abstract parameterized types, e.g. List<String> is not compatible with List<Object>,
+ * but compatible with List<?>.
+ */
+public class WildcardBinding extends ReferenceBinding {
+
+ ReferenceBinding genericType;
+ int rank;
+ public TypeBinding bound; // when unbound denotes the corresponding type variable (so as to retrieve its bound lazily)
+ char[] genericSignature;
+ public int kind;
+ ReferenceBinding superclass;
+ ReferenceBinding[] superInterfaces;
+ TypeVariableBinding typeVariable; // corresponding variable
+ LookupEnvironment environment;
+
+ /**
+ * When unbound, the bound denotes the corresponding type variable (so as to retrieve its bound lazily)
+ */
+ public WildcardBinding(ReferenceBinding genericType, int rank, TypeBinding bound, int kind, LookupEnvironment environment) {
+ this.genericType = genericType;
+ this.rank = rank;
+ this.kind = kind;
+ this.modifiers = AccPublic | AccGenericSignature; // treat wildcard as public
+ this.environment = environment;
+ initialize(genericType, bound);
+
+ if (genericType instanceof UnresolvedReferenceBinding)
+ ((UnresolvedReferenceBinding) genericType).addWrapper(this);
+ if (bound instanceof UnresolvedReferenceBinding)
+ ((UnresolvedReferenceBinding) bound).addWrapper(this);
+ }
+
+ public int kind() {
+ return WILDCARD_TYPE;
+ }
+
+ /**
+ * Returns true if the argument type satisfies all bounds of the type parameter
+ */
+ public boolean boundCheck(TypeBinding argumentType) {
+ switch (this.kind) {
+ case Wildcard.UNBOUND :
+ return true;
+ case Wildcard.EXTENDS :
+ return argumentType.isCompatibleWith(this.bound);
+ default: // SUPER
+ // allowed as long as one is compatible with other (either way)
+ // ? super Exception ok for: IOException, since it would be ok for (Exception)ioException
+ return this.bound.isCompatibleWith(argumentType)
+ || argumentType.isCompatibleWith(this.bound);
+ }
+ }
+ /**
+ * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#canBeInstantiated()
+ */
+ public boolean canBeInstantiated() {
+ // cannot be asked per construction
+ return false;
+ }
+ /**
+ * Collect the substitutes into a map for certain type variables inside the receiver type
+ * e.g. Collection<T>.findSubstitute(T, Collection<List<X>>): T --> List<X>
+ */
+ public void collectSubstitutes(TypeBinding otherType, Map substitutes) {
+
+ if (this.bound == null)
+ return;
+ if (otherType.isWildcard()) {
+ WildcardBinding otherWildcard = (WildcardBinding) otherType;
+ if (otherWildcard.bound != null) {
+ this.bound.collectSubstitutes(otherWildcard.bound, substitutes);
+ }
+ } else {
+ this.bound.collectSubstitutes(otherType, substitutes);
+ }
+ }
+
+ /**
+ * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#debugName()
+ */
+ public String debugName() {
+ return toString();
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#erasure()
+ */
+ public TypeBinding erasure() {
+ if (this.kind == Wildcard.EXTENDS)
+ return this.bound.erasure();
+ return typeVariable().erasure();
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#signature()
+ */
+ public char[] genericTypeSignature() {
+ if (this.genericSignature == null) {
+ switch (this.kind) {
+ case Wildcard.UNBOUND :
+ this.genericSignature = WILDCARD_STAR;
+ break;
+ case Wildcard.EXTENDS :
+ this.genericSignature = CharOperation.concat(WILDCARD_PLUS, this.bound.genericTypeSignature());
+ break;
+ default: // SUPER
+ this.genericSignature = CharOperation.concat(WILDCARD_MINUS, this.bound.genericTypeSignature());
+ }
+ }
+ return this.genericSignature;
+ }
+
+ public int hashCode() {
+ return this.genericType.hashCode();
+ }
+
+ void initialize(ReferenceBinding someGenericType, TypeBinding someBound) {
+ this.genericType = someGenericType;
+ this.bound = someBound;
+ if (someGenericType != null) {
+ this.fPackage = someGenericType.getPackage();
+ }
+ if (someBound != null) {
+ if (someBound.isTypeVariable())
+ this.tagBits |= HasTypeVariable;
+ }
+ }
+
+ /**
+ * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#isSuperclassOf(org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding)
+ */
+ public boolean isSuperclassOf(ReferenceBinding otherType) {
+ if (this.kind == Wildcard.SUPER) {
+ if (this.bound instanceof ReferenceBinding) {
+ return ((ReferenceBinding) this.bound).isSuperclassOf(otherType);
+ } else { // array bound
+ return otherType.id == T_JavaLangObject;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Returns true if the type is a wildcard
+ */
+ public boolean isUnboundWildcard() {
+ return this.kind == Wildcard.UNBOUND;
+ }
+
+ /**
+ * Returns true if the type is a wildcard
+ */
+ public boolean isWildcard() {
+ return true;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.compiler.lookup.Binding#readableName()
+ */
+ public char[] readableName() {
+ switch (this.kind) {
+ case Wildcard.UNBOUND :
+ return WILDCARD_NAME;
+ case Wildcard.EXTENDS :
+ return CharOperation.concat(WILDCARD_NAME, WILDCARD_EXTENDS, this.bound.readableName());
+ default: // SUPER
+ return CharOperation.concat(WILDCARD_NAME, WILDCARD_SUPER, this.bound.readableName());
+ }
+ }
+
+ ReferenceBinding resolve() {
+ BinaryTypeBinding.resolveType(this.genericType, this.environment, null, 0);
+ switch(this.kind) {
+ case Wildcard.EXTENDS :
+ case Wildcard.SUPER :
+ BinaryTypeBinding.resolveType(this.bound, this.environment, null, 0);
+ break;
+ case Wildcard.UNBOUND :
+ }
+ return this;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.compiler.lookup.Binding#shortReadableName()
+ */
+ public char[] shortReadableName() {
+ switch (this.kind) {
+ case Wildcard.UNBOUND :
+ return WILDCARD_NAME;
+ case Wildcard.EXTENDS :
+ return CharOperation.concat(WILDCARD_NAME, WILDCARD_EXTENDS, this.bound.shortReadableName());
+ default: // SUPER
+ return CharOperation.concat(WILDCARD_NAME, WILDCARD_SUPER, this.bound.shortReadableName());
+ }
+ }
+
+ /**
+ * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#signature()
+ */
+ public char[] signature() {
+ // should not be called directly on a wildcard; signature should only be asked on
+ // original methods or type erasures (which cannot denote wildcards at first level)
+ if (this.signature == null) {
+ switch (this.kind) {
+ case Wildcard.EXTENDS :
+ return this.bound.signature();
+ default: // SUPER | UNBOUND
+ return this.typeVariable().signature();
+ }
+ }
+ return this.signature;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#sourceName()
+ */
+ public char[] sourceName() {
+ switch (this.kind) {
+ case Wildcard.UNBOUND :
+ return WILDCARD_NAME;
+ case Wildcard.EXTENDS :
+ return CharOperation.concat(WILDCARD_NAME, WILDCARD_EXTENDS, this.bound.sourceName());
+ default: // SUPER
+ return CharOperation.concat(WILDCARD_NAME, WILDCARD_SUPER, this.bound.sourceName());
+ }
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding#superclass()
+ */
+ public ReferenceBinding superclass() {
+ if (this.superclass == null) {
+ TypeBinding superType = this.typeVariable().firstBound;
+ if (this.kind == Wildcard.EXTENDS) {
+ if (this.bound.isClass()) {
+ superType = this.bound;
+ }
+ }
+ this.superclass = superType != null && superType.isClass()
+ ? (ReferenceBinding) superType
+ : environment.getType(JAVA_LANG_OBJECT);
+ }
+
+ return this.superclass;
+ }
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#superInterfaces()
+ */
+ public ReferenceBinding[] superInterfaces() {
+ if (this.superInterfaces == null) {
+ if (this.typeVariable() != null) {
+ this.superInterfaces = this.typeVariable.superInterfaces();
+ } else {
+ this.superInterfaces = NoSuperInterfaces;
+ }
+ if (this.kind == Wildcard.EXTENDS) {
+ if (this.bound.isInterface()) {
+ // augment super interfaces with the wildcard bound
+ int length = this.superInterfaces.length;
+ System.arraycopy(this.superInterfaces, 0, this.superInterfaces = new ReferenceBinding[length+1], 1, length);
+ this.superInterfaces[0] = (ReferenceBinding) this.bound; // make bound first
+ }
+ }
+ }
+ return this.superInterfaces;
+ }
+
+ public void swapUnresolved(UnresolvedReferenceBinding unresolvedType, ReferenceBinding resolvedType, LookupEnvironment env) {
+ boolean affected = false;
+ if (this.genericType == unresolvedType) {
+ this.genericType = resolvedType; // no raw conversion
+ affected = true;
+ } else if (this.bound == unresolvedType) {
+ this.bound = resolvedType.isGenericType() ? env.createRawType(resolvedType, resolvedType.enclosingType()) : resolvedType;
+ affected = true;
+ }
+ if (affected)
+ initialize(this.genericType, this.bound);
+ }
+
+ /**
+ * @see java.lang.Object#toString()
+ */
+ public String toString() {
+ switch (this.kind) {
+ case Wildcard.UNBOUND :
+ return new String(WILDCARD_NAME);
+ case Wildcard.EXTENDS :
+ return new String(CharOperation.concat(WILDCARD_NAME, WILDCARD_EXTENDS, this.bound.debugName().toCharArray()));
+ default: // SUPER
+ return new String(CharOperation.concat(WILDCARD_NAME, WILDCARD_SUPER, this.bound.debugName().toCharArray()));
+ }
+ }
+ /**
+ * Returns associated type variable, or null in case of inconsistency
+ */
+ public TypeVariableBinding typeVariable() {
+ if (this.typeVariable == null) {
+ TypeVariableBinding[] typeVariables = this.genericType.typeVariables();
+ if (this.rank < typeVariables.length)
+ this.typeVariable = typeVariables[this.rank];
+ }
+ return this.typeVariable;
+ }
+}
projects / org.ibex.tool.git / blobdiff