Java 类org.eclipse.jdt.internal.compiler.ast.Wildcard 实例源码

protected TypeReference cloneParamType(int index, List<TypeReference> typeArgs, EclipseNode builderType) {
    if (typeArgs != null && typeArgs.size() > index) {
        TypeReference originalType = typeArgs.get(index);
        if (originalType instanceof Wildcard) {
            Wildcard wOriginalType = (Wildcard) originalType;
            if (wOriginalType.kind == Wildcard.EXTENDS) {
                try {
                    return copyType(wOriginalType.bound);
                } catch (Exception e) {
                    // fallthrough
                }
            }
        } else {
            return copyType(originalType);
        }
    }

    return new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, NULL_POSS);
}

protected TypeReference cloneParamType(int index, List<TypeReference> typeArgs, EclipseNode builderType) {
    if (typeArgs != null && typeArgs.size() > index) {
        TypeReference originalType = typeArgs.get(index);
        if (originalType instanceof Wildcard) {
            Wildcard wOriginalType = (Wildcard) originalType;
            if (wOriginalType.kind == Wildcard.EXTENDS) {
                try {
                    return copyType(wOriginalType.bound);
                } catch (Exception e) {
                    // fallthrough
                }
            }
        } else {
            return copyType(originalType);
        }
    }

    return new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, NULL_POSS);
}

public boolean visit(Wildcard wildcard, BlockScope scope) {
    if (wildcard.annotations != null) {
        if (formatInlineAnnotations(wildcard.annotations[0], false)) this.scribe.space();
    }
    this.scribe.printNextToken(TerminalTokens.TokenNameQUESTION, this.preferences.insert_space_before_question_in_wilcard);
    switch(wildcard.kind) {
        case Wildcard.SUPER :
            this.scribe.printNextToken(TerminalTokens.TokenNamesuper, true);
            this.scribe.space();
            wildcard.bound.traverse(this, scope);
            break;
        case Wildcard.EXTENDS :
            this.scribe.printNextToken(TerminalTokens.TokenNameextends, true);
            this.scribe.space();
            wildcard.bound.traverse(this, scope);
            break;
        case Wildcard.UNBOUND :
            if (this.preferences.insert_space_after_question_in_wilcard) {
                this.scribe.space();
            }
    }
    return false;
}

public boolean visit(Wildcard wildcard, ClassScope scope) {
    if (wildcard.annotations != null) {
        if (formatInlineAnnotations(wildcard.annotations[0], false)) this.scribe.space();
    }
    this.scribe.printNextToken(TerminalTokens.TokenNameQUESTION, this.preferences.insert_space_before_question_in_wilcard);
    switch(wildcard.kind) {
        case Wildcard.SUPER :
            this.scribe.printNextToken(TerminalTokens.TokenNamesuper, true);
            this.scribe.space();
            wildcard.bound.traverse(this, scope);
            break;
        case Wildcard.EXTENDS :
            this.scribe.printNextToken(TerminalTokens.TokenNameextends, true);
            this.scribe.space();
            wildcard.bound.traverse(this, scope);
            break;
        case Wildcard.UNBOUND :
            if (this.preferences.insert_space_after_question_in_wilcard) {
                this.scribe.space();
            }
    }
    return false;
}

public void consumeWildCard(int wildCardKind) {
    // don't put generic type in signature
    this.signature = new StringBuffer();
    switch (wildCardKind) {
        case Wildcard.UNBOUND:
            this.signature.append('*');
            break;
        case Wildcard.EXTENDS:
            this.signature.append('+');
            this.signature.append(((KeyToSignature) this.arguments.get(0)).signature);
            break;
        case Wildcard.SUPER:
            this.signature.append('-');
            this.signature.append(((KeyToSignature) this.arguments.get(0)).signature);
            break;
        default:
            // malformed
            return;
    }
}

public void consumeWildCard(int kind) {
    switch (kind) {
        case Wildcard.EXTENDS:
        case Wildcard.SUPER:
            BindingKeyResolver boundResolver = (BindingKeyResolver) this.types.get(0);
            // https://bugs.eclipse.org/bugs/show_bug.cgi?id=157847, do not allow creation of
            // internally inconsistent wildcards of the form '? super <null>' or '? extends <null>'
            final Binding boundBinding = boundResolver.compilerBinding;
            if (boundBinding instanceof TypeBinding) {
                this.typeBinding = this.environment.createWildcard((ReferenceBinding) this.typeBinding, this.wildcardRank, (TypeBinding) boundBinding, null /*no extra bound*/, kind);
            } else {
                this.typeBinding = null;
            }
            break;
        case Wildcard.UNBOUND:
            this.typeBinding = this.environment.createWildcard((ReferenceBinding) this.typeBinding, this.wildcardRank, null/*no bound*/, null /*no extra bound*/, kind);
            break;
    }
}

protected void annotateTypeReference(Wildcard ref) {
    int length;
    if ((length = this.typeAnnotationLengthStack[this.typeAnnotationLengthPtr--]) != 0) {
        if (ref.annotations == null)
            ref.annotations = new Annotation[ref.getAnnotatableLevels()][];
        System.arraycopy(
                this.typeAnnotationStack,
                (this.typeAnnotationPtr -= length) + 1,
                ref.annotations[0] = new Annotation[length],
                0,
                length);
        if (ref.sourceStart > ref.annotations[0][0].sourceStart) {
            ref.sourceStart = ref.annotations[0][0].sourceStart;
        }
        ref.bits |= ASTNode.HasTypeAnnotations;
    }
    if (ref.bound != null) {
        ref.bits |= (ref.bound.bits & ASTNode.HasTypeAnnotations);
    }
}

/**
 * The type of x.getClass() is substituted from 'Class<? extends Object>' into: 'Class<? extends raw(X)>
 */
public static ParameterizedMethodBinding instantiateGetClass(TypeBinding receiverType, MethodBinding originalMethod, Scope scope) {
    ParameterizedMethodBinding method = new ParameterizedMethodBinding();
    method.modifiers = originalMethod.modifiers;
    method.selector = originalMethod.selector;
    method.declaringClass = originalMethod.declaringClass;
    method.typeVariables = Binding.NO_TYPE_VARIABLES;
    method.originalMethod = originalMethod;
    method.parameters = originalMethod.parameters;
    method.thrownExceptions = originalMethod.thrownExceptions;
    method.tagBits = originalMethod.tagBits;
    ReferenceBinding genericClassType = scope.getJavaLangClass();
    LookupEnvironment environment = scope.environment();
    TypeBinding rawType = environment.convertToRawType(receiverType.erasure(), false /*do not force conversion of enclosing types*/);
    method.returnType = environment.createParameterizedType(
        genericClassType,
        new TypeBinding[] {  environment.createWildcard(genericClassType, 0, rawType, null /*no extra bound*/, Wildcard.EXTENDS) },
        null);
    if ((method.returnType.tagBits & TagBits.HasMissingType) != 0) {
        method.tagBits |=  TagBits.HasMissingType;
    }
    return method;
}

/**
 * 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);
    }
   }

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);
  }

public String annotatedDebugName() {
    StringBuffer buffer = new StringBuffer(16);
    AnnotationBinding [] annotations = getTypeAnnotations();
    for (int i = 0, length = annotations == null ? 0 : annotations.length; i < length; i++) {
        buffer.append(annotations[i]);
        buffer.append(' ');
    }
    switch (this.boundKind) {
           case Wildcard.UNBOUND :
               return buffer.append(TypeConstants.WILDCARD_NAME).toString();
           case Wildcard.EXTENDS :
            if (this.otherBounds == null)
                return buffer.append(CharOperation.concat(TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_EXTENDS, this.bound.annotatedDebugName().toCharArray())).toString();
            buffer.append(this.bound.annotatedDebugName());
            for (int i = 0, length = this.otherBounds.length; i < length; i++) {
                buffer.append(" & ").append(this.otherBounds[i].annotatedDebugName()); //$NON-NLS-1$
            }
            return buffer.toString();
        default: // SUPER
            return buffer.append(CharOperation.concat(TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_SUPER, this.bound.annotatedDebugName().toCharArray())).toString();
       }
}

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;
  }

/**
 * @see java.lang.Object#toString()
 */
public String toString() {
    if (this.hasTypeAnnotations())
        return annotatedDebugName();
       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()));
       }
}

public boolean visit(Wildcard wildcard, BlockScope scope) {
    this.scribe.printNextToken(TerminalTokens.TokenNameQUESTION, this.preferences.insert_space_before_question_in_wilcard);
    switch(wildcard.kind) {
        case Wildcard.SUPER :
            this.scribe.printNextToken(TerminalTokens.TokenNamesuper, true);
            this.scribe.space();
            wildcard.bound.traverse(this, scope);
            break;
        case Wildcard.EXTENDS :
            this.scribe.printNextToken(TerminalTokens.TokenNameextends, true);
            this.scribe.space();
            wildcard.bound.traverse(this, scope);
            break;
        case Wildcard.UNBOUND :
            if (this.preferences.insert_space_after_question_in_wilcard) {
                this.scribe.space();
            }
    }
    return false;
}

public boolean visit(Wildcard wildcard, ClassScope scope) {
    this.scribe.printNextToken(TerminalTokens.TokenNameQUESTION, this.preferences.insert_space_before_question_in_wilcard);
    switch(wildcard.kind) {
        case Wildcard.SUPER :
            this.scribe.printNextToken(TerminalTokens.TokenNamesuper, true);
            this.scribe.space();
            wildcard.bound.traverse(this, scope);
            break;
        case Wildcard.EXTENDS :
            this.scribe.printNextToken(TerminalTokens.TokenNameextends, true);
            this.scribe.space();
            wildcard.bound.traverse(this, scope);
            break;
        case Wildcard.UNBOUND :
            if (this.preferences.insert_space_after_question_in_wilcard) {
                this.scribe.space();
            }
    }
    return false;
}

public void consumeWildCard(int wildCardKind) {
    // don't put generic type in signature
    this.signature = new StringBuffer();
    switch (wildCardKind) {
        case Wildcard.UNBOUND:
            this.signature.append('*');
            break;
        case Wildcard.EXTENDS:
            this.signature.append('+');
            this.signature.append(((KeyToSignature) this.arguments.get(0)).signature);
            break;
        case Wildcard.SUPER:
            this.signature.append('-');
            this.signature.append(((KeyToSignature) this.arguments.get(0)).signature);
            break;
        default:
            // malformed
            return;
    }
}

public void consumeWildCard(int kind) {
    switch (kind) {
        case Wildcard.EXTENDS:
        case Wildcard.SUPER:
            BindingKeyResolver boundResolver = (BindingKeyResolver) this.types.get(0);
            // https://bugs.eclipse.org/bugs/show_bug.cgi?id=157847, do not allow creation of
            // internally inconsistent wildcards of the form '? super <null>' or '? extends <null>'
            final Binding boundBinding = boundResolver.compilerBinding;
            if (boundBinding instanceof TypeBinding) {
                this.typeBinding = this.environment.createWildcard((ReferenceBinding) this.typeBinding, this.wildcardRank, (TypeBinding) boundBinding, null /*no extra bound*/, kind);
            } else {
                this.typeBinding = null;
            }
            break;
        case Wildcard.UNBOUND:
            this.typeBinding = this.environment.createWildcard((ReferenceBinding) this.typeBinding, this.wildcardRank, null/*no bound*/, null /*no extra bound*/, kind);
            break;
    }
}

/**
 * The type of x.getClass() is substituted from 'Class<? extends Object>' into: 'Class<? extends raw(X)>
 */
public static ParameterizedMethodBinding instantiateGetClass(TypeBinding receiverType, MethodBinding originalMethod, Scope scope) {
    ParameterizedMethodBinding method = new ParameterizedMethodBinding();
    method.modifiers = originalMethod.modifiers;
    method.selector = originalMethod.selector;
    method.declaringClass = originalMethod.declaringClass;
    method.typeVariables = Binding.NO_TYPE_VARIABLES;
    method.originalMethod = originalMethod;
    method.parameters = originalMethod.parameters;
    method.thrownExceptions = originalMethod.thrownExceptions;
    method.tagBits = originalMethod.tagBits;
    ReferenceBinding genericClassType = scope.getJavaLangClass();
    LookupEnvironment environment = scope.environment();
    TypeBinding rawType = environment.convertToRawType(receiverType.erasure(), false /*do not force conversion of enclosing types*/);
    method.returnType = environment.createParameterizedType(
        genericClassType,
        new TypeBinding[] {  environment.createWildcard(genericClassType, 0, rawType, null /*no extra bound*/, Wildcard.EXTENDS) },
        null);
    if ((method.returnType.tagBits & TagBits.HasMissingType) != 0) {
        method.tagBits |=  TagBits.HasMissingType;
    }
    return method;
}

/**
 * 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);
    }
   }

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);
  }

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;
  }

/**
 * @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()));
       }
}

@Override
public TypeMirror getExtendsBound() {
    WildcardBinding wildcardBinding = (WildcardBinding) this._binding;
    if (wildcardBinding.boundKind != Wildcard.EXTENDS) return null;
    TypeBinding bound = wildcardBinding.bound;
    if (bound == null) return null;
    return _env.getFactory().newTypeMirror(bound);
}

@Override
public TypeMirror getSuperBound() {
    WildcardBinding wildcardBinding = (WildcardBinding) this._binding;
    if (wildcardBinding.boundKind != Wildcard.SUPER) return null;
    TypeBinding bound = wildcardBinding.bound;
    if (bound == null) return null;
    return _env.getFactory().newTypeMirror(bound);
}

@Override
public TypeBinding resolveType(BlockScope scope) {

    final CompilerOptions compilerOptions = scope.compilerOptions();
    TypeBinding lhsType;
    boolean typeArgumentsHaveErrors;

    this.constant = Constant.NotAConstant;
    lhsType = this.lhs.resolveType(scope);
    if (this.typeArguments != null) {
        int length = this.typeArguments.length;
        typeArgumentsHaveErrors = compilerOptions.sourceLevel < ClassFileConstants.JDK1_5;
        this.resolvedTypeArguments = new TypeBinding[length];
        for (int i = 0; i < length; i++) {
            TypeReference typeReference = this.typeArguments[i];
            if ((this.resolvedTypeArguments[i] = typeReference.resolveType(scope, true /* check bounds*/)) == null) {
                typeArgumentsHaveErrors = true;
            }
            if (typeArgumentsHaveErrors && typeReference instanceof Wildcard) { // resolveType on wildcard always return null above, resolveTypeArgument is the real workhorse.
                scope.problemReporter().illegalUsageOfWildcard(typeReference);
            }
        }
        if (typeArgumentsHaveErrors || lhsType == null)
            throw new CompletionNodeFound();
    }

    if (lhsType != null && lhsType.isValidBinding())
        throw new CompletionNodeFound(this, lhsType, scope);
    throw new CompletionNodeFound();
}

private void parseWildcard() {
    parseWildcardRank();
    if (this.scanner.nextToken() != Scanner.WILDCARD) return;
    char[] source = this.scanner.getTokenSource();
    if (source.length == 0) {
        malformedKey();
        return;
    }
    int kind = -1;
    switch (source[0]) {
        case '*':
            kind = Wildcard.UNBOUND;
            break;
        case '+':
            kind = Wildcard.EXTENDS;
            break;
        case '-':
            kind = Wildcard.SUPER;
            break;
    }
    if (kind == -1) {
        malformedKey();
        return;
    }
    if (kind != Wildcard.UNBOUND)
        parseWildcardBound();
    consumeWildCard(kind);
}

public boolean isUpperbound() {
    switch (this.binding.kind()) {
        case Binding.WILDCARD_TYPE :
            return ((WildcardBinding) this.binding).boundKind == Wildcard.EXTENDS;
        case Binding.INTERSECTION_TYPE :
            return true;
    }
    return false;
}

protected void consumeWildcard() {
    final Wildcard wildcard = new Wildcard(Wildcard.UNBOUND);
    wildcard.sourceEnd = this.intStack[this.intPtr--];
    wildcard.sourceStart = this.intStack[this.intPtr--];
    annotateTypeReference(wildcard);
    pushOnGenericsStack(wildcard);
}

protected void consumeWildcard1() {
    final Wildcard wildcard = new Wildcard(Wildcard.UNBOUND);
    wildcard.sourceEnd = this.intStack[this.intPtr--];
    wildcard.sourceStart = this.intStack[this.intPtr--];
    annotateTypeReference(wildcard);
    pushOnGenericsStack(wildcard);
}

protected void consumeWildcard2() {
    final Wildcard wildcard = new Wildcard(Wildcard.UNBOUND);
    wildcard.sourceEnd = this.intStack[this.intPtr--];
    wildcard.sourceStart = this.intStack[this.intPtr--];
    annotateTypeReference(wildcard);
    pushOnGenericsStack(wildcard);
}

protected void consumeWildcard3() {
    final Wildcard wildcard = new Wildcard(Wildcard.UNBOUND);
    wildcard.sourceEnd = this.intStack[this.intPtr--];
    wildcard.sourceStart = this.intStack[this.intPtr--];
    annotateTypeReference(wildcard);
    pushOnGenericsStack(wildcard);
}

protected void consumeWildcardBounds1Extends() {
    Wildcard wildcard = new Wildcard(Wildcard.EXTENDS);
    wildcard.bound = (TypeReference) this.genericsStack[this.genericsPtr];
    wildcard.sourceEnd = wildcard.bound.sourceEnd;
    this.intPtr--; // remove end position of the '?'
    wildcard.sourceStart = this.intStack[this.intPtr--];
    annotateTypeReference(wildcard);
    this.genericsStack[this.genericsPtr] = wildcard;
}

protected void consumeWildcardBounds1Super() {
    Wildcard wildcard = new Wildcard(Wildcard.SUPER);
    wildcard.bound = (TypeReference) this.genericsStack[this.genericsPtr];
    this.intPtr--; // remove the starting position of the super keyword
    wildcard.sourceEnd = wildcard.bound.sourceEnd;
    this.intPtr--; // remove end position of the '?'
    wildcard.sourceStart = this.intStack[this.intPtr--];
    annotateTypeReference(wildcard);
    this.genericsStack[this.genericsPtr] = wildcard;
}

protected void consumeWildcardBounds2Extends() {
    Wildcard wildcard = new Wildcard(Wildcard.EXTENDS);
    wildcard.bound = (TypeReference) this.genericsStack[this.genericsPtr];
    wildcard.sourceEnd = wildcard.bound.sourceEnd;
    this.intPtr--; // remove end position of the '?'
    wildcard.sourceStart = this.intStack[this.intPtr--];
    annotateTypeReference(wildcard);
    this.genericsStack[this.genericsPtr] = wildcard;
}

protected void consumeWildcardBounds2Super() {
    Wildcard wildcard = new Wildcard(Wildcard.SUPER);
    wildcard.bound = (TypeReference) this.genericsStack[this.genericsPtr];
    this.intPtr--; // remove the starting position of the super keyword
    wildcard.sourceEnd = wildcard.bound.sourceEnd;
    this.intPtr--; // remove end position of the '?'
    wildcard.sourceStart = this.intStack[this.intPtr--];
    annotateTypeReference(wildcard);
    this.genericsStack[this.genericsPtr] = wildcard;
}

protected void consumeWildcardBounds3Extends() {
    Wildcard wildcard = new Wildcard(Wildcard.EXTENDS);
    wildcard.bound = (TypeReference) this.genericsStack[this.genericsPtr];
    wildcard.sourceEnd = wildcard.bound.sourceEnd;
    this.intPtr--; // remove end position of the '?'
    wildcard.sourceStart = this.intStack[this.intPtr--];
    annotateTypeReference(wildcard);
    this.genericsStack[this.genericsPtr] = wildcard;
}

protected void consumeWildcardBounds3Super() {
    Wildcard wildcard = new Wildcard(Wildcard.SUPER);
    wildcard.bound = (TypeReference) this.genericsStack[this.genericsPtr];
    this.intPtr--; // remove the starting position of the super keyword
    wildcard.sourceEnd = wildcard.bound.sourceEnd;
    this.intPtr--; // remove end position of the '?'
    wildcard.sourceStart = this.intStack[this.intPtr--];
    annotateTypeReference(wildcard);
    this.genericsStack[this.genericsPtr] = wildcard;
}

protected void consumeWildcardBoundsExtends() {
    Wildcard wildcard = new Wildcard(Wildcard.EXTENDS);
    wildcard.bound = getTypeReference(this.intStack[this.intPtr--]);
    wildcard.sourceEnd = wildcard.bound.sourceEnd;
    this.intPtr--; // remove end position of the '?'
    wildcard.sourceStart = this.intStack[this.intPtr--];
    annotateTypeReference(wildcard);
    pushOnGenericsStack(wildcard);
}

protected void consumeWildcardBoundsSuper() {
    Wildcard wildcard = new Wildcard(Wildcard.SUPER);
    wildcard.bound = getTypeReference(this.intStack[this.intPtr--]);
    this.intPtr--; // remove the starting position of the super keyword
    wildcard.sourceEnd = wildcard.bound.sourceEnd;
    this.intPtr--; // remove end position of the '?'
    wildcard.sourceStart = this.intStack[this.intPtr--];
    annotateTypeReference(wildcard);
    pushOnGenericsStack(wildcard);
}

void addTypeBoundsFromWildcardBound(InferenceContext18 context, InferenceSubstitution theta, int boundKind, TypeBinding t,
        TypeBinding r, TypeBinding bi) throws InferenceFailureException {
    ConstraintFormula formula = null;
    if (boundKind == Wildcard.EXTENDS) {
        if (bi.id == TypeIds.T_JavaLangObject)
            formula = ConstraintTypeFormula.create(t, r, ReductionResult.SUBTYPE);
        if (t.id == TypeIds.T_JavaLangObject)
            formula = ConstraintTypeFormula.create(theta.substitute(theta, bi), r, ReductionResult.SUBTYPE);
    } else {
        formula = ConstraintTypeFormula.create(theta.substitute(theta, bi), r, ReductionResult.SUBTYPE);
    }
    if (formula != null)
        reduceOneConstraint(context, formula);
}