| /******************************************************************************* |
| * 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(); |
| return typeVariable().erasure(); |
| } |
| // 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; |
| } |
| } |
