/projects/eclipse_SDK-3.7.1/plugins/org.eclipse.jdt.core.source_3.7.1.v_B76_R37x/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java
Java | 689 lines | 499 code | 38 blank | 152 comment | 120 complexity | 7e1cb1136cd4416a1611b6b50b6d366e MD5 | raw file
- /*******************************************************************************
- * Copyright (c) 2005, 2009 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * IBM Corporation - initial API and implementation
- *******************************************************************************/
- package org.eclipse.jdt.internal.compiler.lookup;
- import java.util.List;
- import org.eclipse.jdt.core.compiler.CharOperation;
- import org.eclipse.jdt.internal.compiler.ast.Wildcard;
- import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
- /*
- * 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 {
- public ReferenceBinding genericType;
- public int rank;
- public TypeBinding bound; // when unbound denotes the corresponding type variable (so as to retrieve its bound lazily)
- public TypeBinding[] otherBounds; // only positionned by lub computations (if so, #bound is also set) and associated to EXTENDS mode
- char[] genericSignature;
- public int boundKind;
- 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, TypeBinding[] otherBounds, int boundKind, LookupEnvironment environment) {
- this.rank = rank;
- this.boundKind = boundKind;
- this.modifiers = ClassFileConstants.AccPublic | ExtraCompilerModifiers.AccGenericSignature; // treat wildcard as public
- this.environment = environment;
- initialize(genericType, bound, otherBounds);
- // if (!genericType.isGenericType() && !(genericType instanceof UnresolvedReferenceBinding)) {
- // RuntimeException e = new RuntimeException("WILDCARD with NON GENERIC");
- // e.printStackTrace();
- // throw e;
- // }
- if (genericType instanceof UnresolvedReferenceBinding)
- ((UnresolvedReferenceBinding) genericType).addWrapper(this, environment);
- if (bound instanceof UnresolvedReferenceBinding)
- ((UnresolvedReferenceBinding) bound).addWrapper(this, environment);
- this.tagBits |= TagBits.HasUnresolvedTypeVariables; // cleared in resolve()
- }
- public int kind() {
- return this.otherBounds == null ? Binding.WILDCARD_TYPE : Binding.INTERSECTION_TYPE;
- }
- /**
- * Returns true if the argument type satisfies the wildcard bound(s)
- */
- public boolean boundCheck(TypeBinding argumentType) {
- switch (this.boundKind) {
- case Wildcard.UNBOUND :
- return true;
- case Wildcard.EXTENDS :
- if (!argumentType.isCompatibleWith(this.bound)) return false;
- // check other bounds (lub scenario)
- for (int i = 0, length = this.otherBounds == null ? 0 : this.otherBounds.length; i < length; i++) {
- if (!argumentType.isCompatibleWith(this.otherBounds[i])) return false;
- }
- return true;
- default: // SUPER
- // ? super Exception ok for: IOException, since it would be ok for (Exception)ioException
- return argumentType.isCompatibleWith(this.bound);
- }
- }
- /**
- * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#canBeInstantiated()
- */
- public boolean canBeInstantiated() {
- // cannot be asked per construction
- return false;
- }
- /**
- * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#collectMissingTypes(java.util.List)
- */
- public List collectMissingTypes(List missingTypes) {
- if ((this.tagBits & TagBits.HasMissingType) != 0) {
- missingTypes = this.bound.collectMissingTypes(missingTypes);
- }
- return missingTypes;
- }
- /**
- * Collect the substitutes into a map for certain type variables inside the receiver type
- * e.g. Collection<T>.collectSubstitutes(Collection<List<X>>, Map), will populate Map with: T --> List<X>
- * Constraints:
- * A << F corresponds to: F.collectSubstitutes(..., A, ..., CONSTRAINT_EXTENDS (1))
- * A = F corresponds to: F.collectSubstitutes(..., A, ..., CONSTRAINT_EQUAL (0))
- * A >> F corresponds to: F.collectSubstitutes(..., A, ..., CONSTRAINT_SUPER (2))
- */
- public void collectSubstitutes(Scope scope, TypeBinding actualType, InferenceContext inferenceContext, int constraint) {
- if ((this.tagBits & TagBits.HasTypeVariable) == 0) return;
- if (actualType == TypeBinding.NULL) return;
- if (actualType.isCapture()) {
- CaptureBinding capture = (CaptureBinding) actualType;
- actualType = capture.wildcard;
- }
- switch (constraint) {
- case TypeConstants.CONSTRAINT_EXTENDS : // A << F
- switch (this.boundKind) {
- case Wildcard.UNBOUND: // F={?}
- // switch (actualType.kind()) {
- // case Binding.WILDCARD_TYPE :
- // WildcardBinding actualWildcard = (WildcardBinding) actualType;
- // switch(actualWildcard.kind) {
- // case Wildcard.UNBOUND: // A={?} << F={?} --> 0
- // break;
- // case Wildcard.EXTENDS: // A={? extends V} << F={?} ---> 0
- // break;
- // case Wildcard.SUPER: // A={? super V} << F={?} ---> 0
- // break;
- // }
- // break;
- // case Binding.INTERSECTION_TYPE :// A={? extends V1&...&Vn} << F={?} ---> 0
- // break;
- // default :// A=V << F={?} ---> 0
- // break;
- // }
- break;
- case Wildcard.EXTENDS: // F={? extends U}
- switch(actualType.kind()) {
- case Binding.WILDCARD_TYPE :
- WildcardBinding actualWildcard = (WildcardBinding) actualType;
- switch(actualWildcard.boundKind) {
- case Wildcard.UNBOUND: // A={?} << F={? extends U} --> 0
- break;
- case Wildcard.EXTENDS: // A={? extends V} << F={? extends U} ---> V << U
- this.bound.collectSubstitutes(scope, actualWildcard.bound, inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
- break;
- case Wildcard.SUPER: // A={? super V} << F={? extends U} ---> 0
- break;
- }
- break;
- case Binding.INTERSECTION_TYPE : // A={? extends V1&...&Vn} << F={? extends U} ---> V1 << U, ..., Vn << U
- WildcardBinding actualIntersection = (WildcardBinding) actualType;
- this.bound.collectSubstitutes(scope, actualIntersection.bound, inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
- for (int i = 0, length = actualIntersection.otherBounds.length; i < length; i++) {
- this.bound.collectSubstitutes(scope, actualIntersection.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
- }
- break;
- default : // A=V << F={? extends U} ---> V << U
- this.bound.collectSubstitutes(scope, actualType, inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
- break;
- }
- break;
- case Wildcard.SUPER: // F={? super U}
- switch (actualType.kind()) {
- case Binding.WILDCARD_TYPE :
- WildcardBinding actualWildcard = (WildcardBinding) actualType;
- switch(actualWildcard.boundKind) {
- case Wildcard.UNBOUND: // A={?} << F={? super U} --> 0
- break;
- case Wildcard.EXTENDS: // A={? extends V} << F={? super U} ---> 0
- break;
- case Wildcard.SUPER: // A={? super V} << F={? super U} ---> 0
- this.bound.collectSubstitutes(scope, actualWildcard.bound, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
- for (int i = 0, length = actualWildcard.otherBounds == null ? 0 : actualWildcard.otherBounds.length; i < length; i++) {
- this.bound.collectSubstitutes(scope, actualWildcard.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_SUPER);
- }
- break;
- }
- break;
- case Binding.INTERSECTION_TYPE : // A={? extends V1&...&Vn} << F={? super U} ---> 0
- break;
- default :// A=V << F={? super U} ---> V >> U
- this.bound.collectSubstitutes(scope, actualType, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
- break;
- }
- break;
- }
- break;
- case TypeConstants.CONSTRAINT_EQUAL : // A == F
- switch (this.boundKind) {
- case Wildcard.UNBOUND: // F={?}
- // switch (actualType.kind()) {
- // case Binding.WILDCARD_TYPE :
- // WildcardBinding actualWildcard = (WildcardBinding) actualType;
- // switch(actualWildcard.kind) {
- // case Wildcard.UNBOUND: // A={?} == F={?} --> 0
- // break;
- // case Wildcard.EXTENDS: // A={? extends V} == F={?} ---> 0
- // break;
- // case Wildcard.SUPER: // A={? super V} == F={?} ---> 0
- // break;
- // }
- // break;
- // case Binding.INTERSECTION_TYPE :// A={? extends V1&...&Vn} == F={?} ---> 0
- // break;
- // default :// A=V == F={?} ---> 0
- // break;
- // }
- break;
- case Wildcard.EXTENDS: // F={? extends U}
- switch (actualType.kind()) {
- case Binding.WILDCARD_TYPE :
- WildcardBinding actualWildcard = (WildcardBinding) actualType;
- switch(actualWildcard.boundKind) {
- case Wildcard.UNBOUND: // A={?} == F={? extends U} --> 0
- break;
- case Wildcard.EXTENDS: // A={? extends V} == F={? extends U} ---> V == U
- this.bound.collectSubstitutes(scope, actualWildcard.bound, inferenceContext, TypeConstants.CONSTRAINT_EQUAL);
- for (int i = 0, length = actualWildcard.otherBounds == null ? 0 : actualWildcard.otherBounds.length; i < length; i++) {
- this.bound.collectSubstitutes(scope, actualWildcard.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_EQUAL);
- }
- break;
- case Wildcard.SUPER: // A={? super V} == F={? extends U} ---> 0
- break;
- }
- break;
- case Binding.INTERSECTION_TYPE : // A={? extends V1&...&Vn} == F={? extends U} ---> V1 == U, ..., Vn == U
- WildcardBinding actuaIntersection = (WildcardBinding) actualType;
- this.bound.collectSubstitutes(scope, actuaIntersection.bound, inferenceContext, TypeConstants.CONSTRAINT_EQUAL);
- for (int i = 0, length = actuaIntersection.otherBounds == null ? 0 : actuaIntersection.otherBounds.length; i < length; i++) {
- this.bound.collectSubstitutes(scope, actuaIntersection.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_EQUAL);
- }
- break;
- default : // A=V == F={? extends U} ---> 0
- break;
- }
- break;
- case Wildcard.SUPER: // F={? super U}
- switch (actualType.kind()) {
- case Binding.WILDCARD_TYPE :
- WildcardBinding actualWildcard = (WildcardBinding) actualType;
- switch(actualWildcard.boundKind) {
- case Wildcard.UNBOUND: // A={?} == F={? super U} --> 0
- break;
- case Wildcard.EXTENDS: // A={? extends V} == F={? super U} ---> 0
- break;
- case Wildcard.SUPER: // A={? super V} == F={? super U} ---> 0
- this.bound.collectSubstitutes(scope, actualWildcard.bound, inferenceContext, TypeConstants.CONSTRAINT_EQUAL);
- for (int i = 0, length = actualWildcard.otherBounds == null ? 0 : actualWildcard.otherBounds.length; i < length; i++) {
- this.bound.collectSubstitutes(scope, actualWildcard.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_EQUAL);
- }
- break;
- }
- break;
- case Binding.INTERSECTION_TYPE : // A={? extends V1&...&Vn} == F={? super U} ---> 0
- break;
- default : // A=V == F={? super U} ---> 0
- break;
- }
- break;
- }
- break;
- case TypeConstants.CONSTRAINT_SUPER : // A >> F
- switch (this.boundKind) {
- case Wildcard.UNBOUND: // F={?}
- // switch (actualType.kind()) {
- // case Binding.WILDCARD_TYPE :
- // WildcardBinding actualWildcard = (WildcardBinding) actualType;
- // switch(actualWildcard.kind) {
- // case Wildcard.UNBOUND: // A={?} >> F={?} --> 0
- // break;
- // case Wildcard.EXTENDS: // A={? extends V} >> F={?} ---> 0
- // break;
- // case Wildcard.SUPER: // A={? super V} >> F={?} ---> 0
- // break;
- // }
- // break;
- // case Binding.INTERSECTION_TYPE :// A={? extends V1&...&Vn} >> F={?} ---> 0
- // break;
- // default :// A=V >> F={?} ---> 0
- // break;
- // }
- break;
- case Wildcard.EXTENDS: // F={? extends U}
- switch (actualType.kind()) {
- case Binding.WILDCARD_TYPE :
- WildcardBinding actualWildcard = (WildcardBinding) actualType;
- switch(actualWildcard.boundKind) {
- case Wildcard.UNBOUND: // A={?} >> F={? extends U} --> 0
- break;
- case Wildcard.EXTENDS: // A={? extends V} >> F={? extends U} ---> V >> U
- this.bound.collectSubstitutes(scope, actualWildcard.bound, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
- for (int i = 0, length = actualWildcard.otherBounds == null ? 0 : actualWildcard.otherBounds.length; i < length; i++) {
- this.bound.collectSubstitutes(scope, actualWildcard.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_SUPER);
- }
- break;
- case Wildcard.SUPER: // A={? super V} >> F={? extends U} ---> 0
- break;
- }
- break;
- case Binding.INTERSECTION_TYPE : // A={? extends V1&...&Vn} >> F={? extends U} ---> V1 >> U, ..., Vn >> U
- WildcardBinding actualIntersection = (WildcardBinding) actualType;
- this.bound.collectSubstitutes(scope, actualIntersection.bound, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
- for (int i = 0, length = actualIntersection.otherBounds == null ? 0 : actualIntersection.otherBounds.length; i < length; i++) {
- this.bound.collectSubstitutes(scope, actualIntersection.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_SUPER);
- }
- break;
- default : // A=V == F={? extends U} ---> 0
- break;
- }
- break;
- case Wildcard.SUPER: // F={? super U}
- switch (actualType.kind()) {
- case Binding.WILDCARD_TYPE :
- WildcardBinding actualWildcard = (WildcardBinding) actualType;
- switch(actualWildcard.boundKind) {
- case Wildcard.UNBOUND: // A={?} >> F={? super U} --> 0
- break;
- case Wildcard.EXTENDS: // A={? extends V} >> F={? super U} ---> 0
- break;
- case Wildcard.SUPER: // A={? super V} >> F={? super U} ---> V >> U
- this.bound.collectSubstitutes(scope, actualWildcard.bound, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
- for (int i = 0, length = actualWildcard.otherBounds == null ? 0 : actualWildcard.otherBounds.length; i < length; i++) {
- this.bound.collectSubstitutes(scope, actualWildcard.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_SUPER);
- }
- break;
- }
- break;
- case Binding.INTERSECTION_TYPE : // A={? extends V1&...&Vn} >> F={? super U} ---> 0
- break;
- default : // A=V >> F={? super U} ---> 0
- break;
- }
- break;
- }
- break;
- }
- }
- /*
- * genericTypeKey {rank}*|+|- [boundKey]
- * p.X<T> { X<?> ... } --> Lp/X<TT;>;{0}*
- */
- public char[] computeUniqueKey(boolean isLeaf) {
- char[] genericTypeKey = this.genericType.computeUniqueKey(false/*not a leaf*/);
- char[] wildCardKey;
- // We now encode the rank also in the binding key - https://bugs.eclipse.org/bugs/show_bug.cgi?id=234609
- char[] rankComponent = ('{' + String.valueOf(this.rank) + '}').toCharArray();
- switch (this.boundKind) {
- case Wildcard.UNBOUND :
- wildCardKey = TypeConstants.WILDCARD_STAR;
- break;
- case Wildcard.EXTENDS :
- wildCardKey = CharOperation.concat(TypeConstants.WILDCARD_PLUS, this.bound.computeUniqueKey(false/*not a leaf*/));
- break;
- default: // SUPER
- wildCardKey = CharOperation.concat(TypeConstants.WILDCARD_MINUS, this.bound.computeUniqueKey(false/*not a leaf*/));
- break;
- }
- return CharOperation.concat(genericTypeKey, rankComponent, wildCardKey);
- }
- /**
- * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#constantPoolName()
- */
- public char[] constantPoolName() {
- return erasure().constantPoolName();
- }
- /**
- * @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.otherBounds == null) {
- if (this.boundKind == Wildcard.EXTENDS)
- return this.bound.erasure();
- TypeVariableBinding var = typeVariable();
- if (var != null)
- return var.erasure();
- return this.genericType; // if typeVariable() == null, then its inconsistent & return this.genericType to avoid NPE case
- }
- // intersection type
- return this.bound.id == TypeIds.T_JavaLangObject
- ? this.otherBounds[0].erasure() // use first explicit bound to improve stackmap
- : this.bound.erasure();
- }
- /* (non-Javadoc)
- * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#signature()
- */
- public char[] genericTypeSignature() {
- if (this.genericSignature == null) {
- switch (this.boundKind) {
- case Wildcard.UNBOUND :
- this.genericSignature = TypeConstants.WILDCARD_STAR;
- break;
- case Wildcard.EXTENDS :
- this.genericSignature = CharOperation.concat(TypeConstants.WILDCARD_PLUS, this.bound.genericTypeSignature());
- break;
- default: // SUPER
- this.genericSignature = CharOperation.concat(TypeConstants.WILDCARD_MINUS, this.bound.genericTypeSignature());
- }
- }
- return this.genericSignature;
- }
- public int hashCode() {
- return this.genericType.hashCode();
- }
- void initialize(ReferenceBinding someGenericType, TypeBinding someBound, TypeBinding[] someOtherBounds) {
- this.genericType = someGenericType;
- this.bound = someBound;
- this.otherBounds = someOtherBounds;
- if (someGenericType != null) {
- this.fPackage = someGenericType.getPackage();
- }
- if (someBound != null) {
- this.tagBits |= someBound.tagBits & (TagBits.HasTypeVariable | TagBits.HasMissingType | TagBits.ContainsNestedTypeReferences);
- }
- if (someOtherBounds != null) {
- for (int i = 0, max = someOtherBounds.length; i < max; i++) {
- TypeBinding someOtherBound = someOtherBounds[i];
- this.tagBits |= someOtherBound.tagBits & TagBits.ContainsNestedTypeReferences;
- }
- }
- }
- /**
- * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#isSuperclassOf(org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding)
- */
- public boolean isSuperclassOf(ReferenceBinding otherType) {
- if (this.boundKind == Wildcard.SUPER) {
- if (this.bound instanceof ReferenceBinding) {
- return ((ReferenceBinding) this.bound).isSuperclassOf(otherType);
- } else { // array bound
- return otherType.id == TypeIds.T_JavaLangObject;
- }
- }
- return false;
- }
- /**
- * Returns true if the current type denotes an intersection type: Number & Comparable<?>
- */
- public boolean isIntersectionType() {
- return this.otherBounds != null;
- }
- public boolean isHierarchyConnected() {
- return this.superclass != null && this.superInterfaces != null;
- }
- /**
- * Returns true if the type is a wildcard
- */
- public boolean isUnboundWildcard() {
- return this.boundKind == 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.boundKind) {
- case Wildcard.UNBOUND :
- return TypeConstants.WILDCARD_NAME;
- case Wildcard.EXTENDS :
- if (this.otherBounds == null)
- return CharOperation.concat(TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_EXTENDS, this.bound.readableName());
- StringBuffer buffer = new StringBuffer(10);
- buffer.append(this.bound.readableName());
- for (int i = 0, length = this.otherBounds.length; i < length; i++) {
- buffer.append('&').append(this.otherBounds[i].readableName());
- }
- int length;
- char[] result = new char[length = buffer.length()];
- buffer.getChars(0, length, result, 0);
- return result;
- default: // SUPER
- return CharOperation.concat(TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_SUPER, this.bound.readableName());
- }
- }
- ReferenceBinding resolve() {
- if ((this.tagBits & TagBits.HasUnresolvedTypeVariables) == 0)
- return this;
- this.tagBits &= ~TagBits.HasUnresolvedTypeVariables;
- BinaryTypeBinding.resolveType(this.genericType, this.environment, false /* no raw conversion */);
- switch(this.boundKind) {
- case Wildcard.EXTENDS :
- TypeBinding resolveType = BinaryTypeBinding.resolveType(this.bound, this.environment, true /* raw conversion */);
- this.bound = resolveType;
- this.tagBits |= resolveType.tagBits & TagBits.ContainsNestedTypeReferences;
- for (int i = 0, length = this.otherBounds == null ? 0 : this.otherBounds.length; i < length; i++) {
- resolveType = BinaryTypeBinding.resolveType(this.otherBounds[i], this.environment, true /* raw conversion */);
- this.otherBounds[i]= resolveType;
- this.tagBits |= resolveType.tagBits & TagBits.ContainsNestedTypeReferences;
- }
- break;
- case Wildcard.SUPER :
- resolveType = BinaryTypeBinding.resolveType(this.bound, this.environment, true /* raw conversion */);
- this.bound = resolveType;
- this.tagBits |= resolveType.tagBits & TagBits.ContainsNestedTypeReferences;
- break;
- case Wildcard.UNBOUND :
- }
- return this;
- }
- /* (non-Javadoc)
- * @see org.eclipse.jdt.internal.compiler.lookup.Binding#shortReadableName()
- */
- public char[] shortReadableName() {
- switch (this.boundKind) {
- case Wildcard.UNBOUND :
- return TypeConstants.WILDCARD_NAME;
- case Wildcard.EXTENDS :
- if (this.otherBounds == null)
- return CharOperation.concat(TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_EXTENDS, this.bound.shortReadableName());
- StringBuffer buffer = new StringBuffer(10);
- buffer.append(this.bound.shortReadableName());
- for (int i = 0, length = this.otherBounds.length; i < length; i++) {
- buffer.append('&').append(this.otherBounds[i].shortReadableName());
- }
- int length;
- char[] result = new char[length = buffer.length()];
- buffer.getChars(0, length, result, 0);
- return result;
- default: // SUPER
- return CharOperation.concat(TypeConstants.WILDCARD_NAME, TypeConstants.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.boundKind) {
- case Wildcard.EXTENDS :
- return this.bound.signature();
- default: // SUPER | UNBOUND
- return typeVariable().signature();
- }
- }
- return this.signature;
- }
- /* (non-Javadoc)
- * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#sourceName()
- */
- public char[] sourceName() {
- switch (this.boundKind) {
- case Wildcard.UNBOUND :
- return TypeConstants.WILDCARD_NAME;
- case Wildcard.EXTENDS :
- return CharOperation.concat(TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_EXTENDS, this.bound.sourceName());
- default: // SUPER
- return CharOperation.concat(TypeConstants.WILDCARD_NAME, TypeConstants.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 = null;
- if (this.boundKind == Wildcard.EXTENDS && !this.bound.isInterface()) {
- superType = this.bound;
- } else {
- TypeVariableBinding variable = typeVariable();
- if (variable != null) superType = variable.firstBound;
- }
- this.superclass = superType instanceof ReferenceBinding && !superType.isInterface()
- ? (ReferenceBinding) superType
- : this.environment.getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null);
- }
- return this.superclass;
- }
- /* (non-Javadoc)
- * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#superInterfaces()
- */
- public ReferenceBinding[] superInterfaces() {
- if (this.superInterfaces == null) {
- if (typeVariable() != null) {
- this.superInterfaces = this.typeVariable.superInterfaces();
- } else {
- this.superInterfaces = Binding.NO_SUPERINTERFACES;
- }
- if (this.boundKind == 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
- }
- if (this.otherBounds != null) {
- // augment super interfaces with the wildcard otherBounds (interfaces per construction)
- int length = this.superInterfaces.length;
- int otherLength = this.otherBounds.length;
- System.arraycopy(this.superInterfaces, 0, this.superInterfaces = new ReferenceBinding[length+otherLength], 0, length);
- for (int i = 0; i < otherLength; i++) {
- this.superInterfaces[length+i] = (ReferenceBinding) this.otherBounds[i];
- }
- }
- }
- }
- 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;
- }
- if (this.bound == unresolvedType) {
- this.bound = env.convertUnresolvedBinaryToRawType(resolvedType);
- affected = true;
- }
- if (this.otherBounds != null) {
- for (int i = 0, length = this.otherBounds.length; i < length; i++) {
- if (this.otherBounds[i] == unresolvedType) {
- this.otherBounds[i] = env.convertUnresolvedBinaryToRawType(resolvedType);
- affected = true;
- }
- }
- }
- if (affected)
- initialize(this.genericType, this.bound, this.otherBounds);
- }
- /**
- * @see java.lang.Object#toString()
- */
- public String toString() {
- switch (this.boundKind) {
- case Wildcard.UNBOUND :
- return new String(TypeConstants.WILDCARD_NAME);
- case Wildcard.EXTENDS :
- if (this.otherBounds == null)
- return new String(CharOperation.concat(TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_EXTENDS, this.bound.debugName().toCharArray()));
- StringBuffer buffer = new StringBuffer(this.bound.debugName());
- for (int i = 0, length = this.otherBounds.length; i < length; i++) {
- buffer.append('&').append(this.otherBounds[i].debugName());
- }
- return buffer.toString();
- default: // SUPER
- return new String(CharOperation.concat(TypeConstants.WILDCARD_NAME, TypeConstants.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;
- }
- }