<s> 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 . TypeReference ; import org . eclipse . jdt . internal . compiler . ast . Wildcard ; public class ParameterizedTypeBinding extends ReferenceBinding implements Substitution { private ReferenceBinding type ; public TypeBinding [ ] arguments ; public LookupEnvironment environment ; public char [ ] genericTypeSignature ; public ReferenceBinding superclass ; public ReferenceBinding [ ] superInterfaces ; public FieldBinding [ ] fields ; public ReferenceBinding [ ] memberTypes ; public MethodBinding [ ] methods ; private ReferenceBinding enclosingType ; public ParameterizedTypeBinding ( ReferenceBinding type , TypeBinding [ ] arguments , ReferenceBinding enclosingType , LookupEnvironment environment ) { this . environment = environment ; this . enclosingType = enclosingType ; initialize ( type , arguments ) ; if ( type instanceof UnresolvedReferenceBinding ) ( ( UnresolvedReferenceBinding ) type ) . addWrapper ( this , environment ) ; if ( arguments != null ) { for ( int i = 0 , l = arguments . length ; i < l ; i ++ ) if ( arguments [ i ] instanceof UnresolvedReferenceBinding ) ( ( UnresolvedReferenceBinding ) arguments [ i ] ) . addWrapper ( this , environment ) ; } this . tagBits |= TagBits . HasUnresolvedTypeVariables ; } protected ReferenceBinding actualType ( ) { return this . type ; } public void boundCheck ( Scope scope , TypeReference [ ] argumentReferences ) { if ( ( this . tagBits & TagBits . PassedBoundCheck ) == 0 ) { boolean hasErrors = false ; TypeVariableBinding [ ] typeVariables = this . type . typeVariables ( ) ; if ( this . arguments != null && typeVariables != null ) { for ( int i = 0 , length = typeVariables . length ; i < length ; i ++ ) { if ( typeVariables [ i ] . boundCheck ( this , this . arguments [ i ] ) != TypeConstants . OK ) { hasErrors = true ; if ( ( this . arguments [ i ] . tagBits & TagBits . HasMissingType ) == 0 ) { scope . problemReporter ( ) . typeMismatchError ( this . arguments [ i ] , typeVariables [ i ] , this . type , argumentReferences [ i ] ) ; } } } } if ( ! hasErrors ) this . tagBits |= TagBits . PassedBoundCheck ; } } public boolean canBeInstantiated ( ) { return ( ( this . tagBits & TagBits . HasDirectWildcard ) == 0 ) && super . canBeInstantiated ( ) ; } public TypeBinding capture ( Scope scope , int position ) { if ( ( this . tagBits & TagBits . HasDirectWildcard ) == 0 ) return this ; TypeBinding [ ] originalArguments = this . arguments ; int length = originalArguments . length ; TypeBinding [ ] capturedArguments = new TypeBinding [ length ] ; ReferenceBinding contextType = scope . enclosingSourceType ( ) ; if ( contextType != null ) contextType = contextType . outermostEnclosingType ( ) ; for ( int i = 0 ; i < length ; i ++ ) { TypeBinding argument = originalArguments [ i ] ; if ( argument . kind ( ) == Binding . WILDCARD_TYPE ) { capturedArguments [ i ] = new CaptureBinding ( ( WildcardBinding ) argument , contextType , position , scope . compilationUnitScope ( ) . nextCaptureID ( ) ) ; } else { capturedArguments [ i ] = argument ; } } ParameterizedTypeBinding capturedParameterizedType = this . environment . createParameterizedType ( this . type , capturedArguments , enclosingType ( ) ) ; for ( int i = 0 ; i < length ; i ++ ) { TypeBinding argument = capturedArguments [ i ] ; if ( argument . isCapture ( ) ) { ( ( CaptureBinding ) argument ) . initializeBounds ( scope , capturedParameterizedType ) ; } } return capturedParameterizedType ; } public List collectMissingTypes ( List missingTypes ) { if ( ( this . tagBits & TagBits . HasMissingType ) != 0 ) { if ( this . enclosingType != null ) { missingTypes = this . enclosingType . collectMissingTypes ( missingTypes ) ; } missingTypes = genericType ( ) . collectMissingTypes ( missingTypes ) ; if ( this . arguments != null ) { for ( int i = 0 , max = this . arguments . length ; i < max ; i ++ ) { missingTypes = this . arguments [ i ] . collectMissingTypes ( missingTypes ) ; } } } return missingTypes ; } public void collectSubstitutes ( Scope scope , TypeBinding actualType , InferenceContext inferenceContext , int constraint ) { if ( ( this . tagBits & TagBits . HasTypeVariable ) == 0 ) { TypeBinding actualEquivalent = actualType . findSuperTypeOriginatingFrom ( this . type ) ; if ( actualEquivalent != null && actualEquivalent . isRawType ( ) ) { inferenceContext . isUnchecked = true ; } return ; } if ( actualType == TypeBinding . NULL ) return ; if ( ! ( actualType instanceof ReferenceBinding ) ) return ; TypeBinding formalEquivalent , actualEquivalent ; switch ( constraint ) { case TypeConstants . CONSTRAINT_EQUAL : case TypeConstants . CONSTRAINT_EXTENDS : formalEquivalent = this ; actualEquivalent = actualType . findSuperTypeOriginatingFrom ( this . type ) ; if ( actualEquivalent == null ) return ; break ; case TypeConstants . CONSTRAINT_SUPER : default : formalEquivalent = this . findSuperTypeOriginatingFrom ( actualType ) ; if ( formalEquivalent == null ) return ; actualEquivalent = actualType ; break ; } ReferenceBinding formalEnclosingType = formalEquivalent . enclosingType ( ) ; if ( formalEnclosingType != null ) { formalEnclosingType . collectSubstitutes ( scope , actualEquivalent . enclosingType ( ) , inferenceContext , constraint ) ; } if ( this . arguments == null ) return ; TypeBinding [ ] formalArguments ; switch ( formalEquivalent . kind ( ) ) { case Binding . GENERIC_TYPE : formalArguments = formalEquivalent . typeVariables ( ) ; break ; case Binding . PARAMETERIZED_TYPE : formalArguments = ( ( ParameterizedTypeBinding ) formalEquivalent ) . arguments ; break ; case Binding . RAW_TYPE : if ( inferenceContext . depth > 0 ) { inferenceContext . status = InferenceContext . FAILED ; } return ; default : return ; } TypeBinding [ ] actualArguments ; switch ( actualEquivalent . kind ( ) ) { case Binding . GENERIC_TYPE : actualArguments = actualEquivalent . typeVariables ( ) ; break ; case Binding . PARAMETERIZED_TYPE : actualArguments = ( ( ParameterizedTypeBinding ) actualEquivalent ) . arguments ; break ; case Binding . RAW_TYPE : if ( inferenceContext . depth > 0 ) { inferenceContext . status = InferenceContext . FAILED ; } else { inferenceContext . isUnchecked = true ; } return ; default : return ; } inferenceContext . depth ++ ; for ( int i = 0 , length = formalArguments . length ; i < length ; i ++ ) { TypeBinding formalArgument = formalArguments [ i ] ; TypeBinding actualArgument = actualArguments [ i ] ; if ( formalArgument . isWildcard ( ) ) { formalArgument . collectSubstitutes ( scope , actualArgument , inferenceContext , constraint ) ; continue ; } else if ( actualArgument . isWildcard ( ) ) { WildcardBinding actualWildcardArgument = ( WildcardBinding ) actualArgument ; if ( actualWildcardArgument . otherBounds == null ) { if ( constraint == TypeConstants . CONSTRAINT_SUPER ) { switch ( actualWildcardArgument . boundKind ) { case Wildcard . EXTENDS : formalArgument . collectSubstitutes ( scope , actualWildcardArgument . bound , inferenceContext , TypeConstants . CONSTRAINT_SUPER ) ; continue ; case Wildcard . SUPER : formalArgument . collectSubstitutes ( scope , actualWildcardArgument . bound , inferenceContext , TypeConstants . CONSTRAINT_EXTENDS ) ; continue ; default : continue ; } } else { continue ; } } } formalArgument . collectSubstitutes ( scope , actualArgument , inferenceContext , TypeConstants . CONSTRAINT_EQUAL ) ; } inferenceContext . depth -- ; } public void computeId ( ) { this . id = TypeIds . NoId ; } public char [ ] computeUniqueKey ( boolean isLeaf ) { StringBuffer sig = new StringBuffer ( 10 ) ; ReferenceBinding enclosing ; if ( isMemberType ( ) && ( ( enclosing = enclosingType ( ) ) . isParameterizedType ( ) || enclosing . isRawType ( ) ) ) { char [ ] typeSig = enclosing . computeUniqueKey ( false ) ; sig . append ( typeSig , 0 , typeSig . length - 1 ) ; sig . append ( '.' ) . append ( sourceName ( ) ) ; } else if ( this . type . isLocalType ( ) ) { LocalTypeBinding localTypeBinding = ( LocalTypeBinding ) this . type ; enclosing = localTypeBinding . enclosingType ( ) ; ReferenceBinding temp ; while ( ( temp = enclosing . enclosingType ( ) ) != null ) enclosing = temp ; char [ ] typeSig = enclosing . computeUniqueKey ( false ) ; sig . append ( typeSig , 0 , typeSig . length - 1 ) ; sig . append ( '$' ) ; sig . append ( localTypeBinding . sourceStart ) ; } else { char [ ] typeSig = this . type . computeUniqueKey ( false ) ; sig . append ( typeSig , 0 , typeSig . length - 1 ) ; } ReferenceBinding captureSourceType = null ; if ( this . arguments != null ) { sig . append ( '<' ) ; for ( int i = 0 , length = this . arguments . length ; i < length ; i ++ ) { TypeBinding typeBinding = this . arguments [ i ] ; sig . append ( typeBinding . computeUniqueKey ( false ) ) ; if ( typeBinding instanceof CaptureBinding ) captureSourceType = ( ( CaptureBinding ) typeBinding ) . sourceType ; } sig . append ( '>' ) ; } sig . append ( ';' ) ; if ( captureSourceType != null && captureSourceType != this . type ) { sig . insert ( 0 , "&" ) ; sig . insert ( 0 , captureSourceType . computeUniqueKey ( false ) ) ; } int sigLength = sig . length ( ) ; char [ ] uniqueKey = new char [ sigLength ] ; sig . getChars ( 0 , sigLength , uniqueKey , 0 ) ; return uniqueKey ; } public char [ ] constantPoolName ( ) { return this . type . constantPoolName ( ) ; } public ParameterizedMethodBinding createParameterizedMethod ( MethodBinding originalMethod ) { return new ParameterizedMethodBinding ( this , originalMethod ) ; } public String debugName ( ) { StringBuffer nameBuffer = new StringBuffer ( 10 ) ; if ( this . type instanceof UnresolvedReferenceBinding ) { nameBuffer . append ( this . type ) ; } else { nameBuffer . append ( this . type . sourceName ( ) ) ; } if ( this . arguments != null ) { nameBuffer . append ( '<' ) ; for ( int i = 0 , length = this . arguments . length ; i < length ; i ++ ) { if ( i > 0 ) nameBuffer . append ( ',' ) ; nameBuffer . append ( this . arguments [ i ] . debugName ( ) ) ; } nameBuffer . append ( '>' ) ; } return nameBuffer . toString ( ) ; } public ReferenceBinding enclosingType ( ) { return this . enclosingType ; } public LookupEnvironment environment ( ) { return this . environment ; } public TypeBinding erasure ( ) { return this . type . erasure ( ) ; } public int fieldCount ( ) { return this . type . fieldCount ( ) ; } public FieldBinding [ ] fields ( ) { if ( ( this . tagBits & TagBits . AreFieldsComplete ) != 0 ) return this . fields ; try { FieldBinding [ ] originalFields = this . type . fields ( ) ; int length = originalFields . length ; FieldBinding [ ] parameterizedFields = new FieldBinding [ length ] ; for ( int i = 0 ; i < length ; i ++ ) parameterizedFields [ i ] = new ParameterizedFieldBinding ( this , originalFields [ i ] ) ; this . fields = parameterizedFields ; } finally { if ( this . fields == null ) this . fields = Binding . NO_FIELDS ; this . tagBits |= TagBits . AreFieldsComplete ; } return this . fields ; } public ReferenceBinding genericType ( ) { if ( this . type instanceof UnresolvedReferenceBinding ) ( ( UnresolvedReferenceBinding ) this . type ) . resolve ( this . environment , false ) ; return this . type ; } public char [ ] genericTypeSignature ( ) { if ( this . genericTypeSignature == null ) { if ( ( this . modifiers & ExtraCompilerModifiers . AccGenericSignature ) == 0 ) { this . genericTypeSignature = this . type . signature ( ) ; } else { StringBuffer sig = new StringBuffer ( 10 ) ; if ( isMemberType ( ) ) { ReferenceBinding enclosing = enclosingType ( ) ; char [ ] typeSig = enclosing . genericTypeSignature ( ) ; sig . append ( typeSig , 0 , typeSig . length - 1 ) ; if ( ( enclosing . modifiers & ExtraCompilerModifiers . AccGenericSignature ) != 0 ) { sig . append ( '.' ) ; } else { sig . append ( '$' ) ; } sig . append ( sourceName ( ) ) ; } else { char [ ] typeSig = this . type . signature ( ) ; sig . append ( typeSig , 0 , typeSig . length - 1 ) ; } if ( this . arguments != null ) { sig . append ( '<' ) ; for ( int i = 0 , length = this . arguments . length ; i < length ; i ++ ) { sig . append ( this . arguments [ i ] . genericTypeSignature ( ) ) ; } sig . append ( '>' ) ; } sig . append ( ';' ) ; int sigLength = sig . length ( ) ; this . genericTypeSignature = new char [ sigLength ] ; sig . getChars ( 0 , sigLength , this . genericTypeSignature , 0 ) ; } } return this . genericTypeSignature ; } public long getAnnotationTagBits ( ) { return this . type . getAnnotationTagBits ( ) ; } public int getEnclosingInstancesSlotSize ( ) { return genericType ( ) . getEnclosingInstancesSlotSize ( ) ; } public MethodBinding getExactConstructor ( TypeBinding [ ] argumentTypes ) { int argCount = argumentTypes . length ; MethodBinding match = null ; if ( ( this . tagBits & TagBits . AreMethodsComplete ) != 0 ) { long range ; if ( ( range = ReferenceBinding . binarySearch ( TypeConstants . INIT , this . methods ) ) >= 0 ) { nextMethod : for ( int imethod = ( int ) range , end = ( int ) ( range >> 32 ) ; imethod <= end ; imethod ++ ) { MethodBinding method = this . methods [ imethod ] ; if ( method . parameters . length == argCount ) { TypeBinding [ ] toMatch = method . parameters ; for ( int iarg = 0 ; iarg < argCount ; iarg ++ ) if ( toMatch [ iarg ] != argumentTypes [ iarg ] ) continue nextMethod ; if ( match != null ) return null ; match = method ; } } } } else { MethodBinding [ ] matchingMethods = getMethods ( TypeConstants . INIT ) ; nextMethod : for ( int m = matchingMethods . length ; -- m >= 0 ; ) { MethodBinding method = matchingMethods [ m ] ; TypeBinding [ ] toMatch = method . parameters ; if ( toMatch . length == argCount ) { for ( int p = 0 ; p < argCount ; p ++ ) if ( toMatch [ p ] != argumentTypes [ p ] ) continue nextMethod ; if ( match != null ) return null ; match = method ; } } } return match ; } public MethodBinding getExactMethod ( char [ ] selector , TypeBinding [ ] argumentTypes , CompilationUnitScope refScope ) { int argCount = argumentTypes . length ; boolean foundNothing = true ; MethodBinding match = null ; if ( ( this . tagBits & TagBits . AreMethodsComplete ) != 0 ) { long range ; if ( ( range = ReferenceBinding . binarySearch ( selector , this . methods ) ) >= 0 ) { nextMethod : for ( int imethod = ( int ) range , end = ( int ) ( range >> 32 ) ; imethod <= end ; imethod ++ ) { MethodBinding method = this . methods [ imethod ] ; foundNothing = false ; if ( method . parameters . length == argCount ) { TypeBinding [ ] toMatch = method . parameters ; for ( int iarg = 0 ; iarg < argCount ; iarg ++ ) if ( toMatch [ iarg ] != argumentTypes [ iarg ] ) continue nextMethod ; if ( match != null ) return null ; match = method ; } } } } else { MethodBinding [ ] matchingMethods = getMethods ( selector ) ; foundNothing = matchingMethods == Binding . NO_METHODS ; nextMethod : for ( int m = matchingMethods . length ; -- m >= 0 ; ) { MethodBinding method = matchingMethods [ m ] ; TypeBinding [ ] toMatch = method . parameters ; if ( toMatch . length == argCount ) { for ( int p = 0 ; p < argCount ; p ++ ) if ( toMatch [ p ] != argumentTypes [ p ] ) continue nextMethod ; if ( match != null ) return null ; match = method ; } } } if ( match != null ) { if ( match . hasSubstitutedParameters ( ) ) return null ; return match ; } if ( foundNothing && ( this . arguments == null || this . arguments . length <= 1 ) ) { if ( isInterface ( ) ) { if ( superInterfaces ( ) . length == 1 ) { if ( refScope != null ) refScope . recordTypeReference ( this . superInterfaces [ 0 ] ) ; return this . superInterfaces [ 0 ] . getExactMethod ( selector , argumentTypes , refScope ) ; } } else if ( superclass ( ) != null ) { if ( refScope != null ) refScope . recordTypeReference ( this . superclass ) ; return this . superclass . getExactMethod ( selector , argumentTypes , refScope ) ; } } return null ; } public FieldBinding getField ( char [ ] fieldName , boolean needResolve ) { fields ( ) ; return ReferenceBinding . binarySearch ( fieldName , this . fields ) ; } public ReferenceBinding getMemberType ( char [ ] typeName ) { memberTypes ( ) ; int typeLength = typeName . length ; for ( int i = this . memberTypes . length ; -- i >= 0 ; ) { ReferenceBinding memberType = this . memberTypes [ i ] ; if ( memberType . sourceName . length == typeLength && CharOperation . equals ( memberType . sourceName , typeName ) ) return memberType ; } return null ; } public MethodBinding [ ] getMethods ( char [ ] selector ) { if ( this . methods != null ) { long range ; if ( ( range = ReferenceBinding . binarySearch ( selector , this . methods ) ) >= 0 ) { int start = ( int ) range ; int length = ( int ) ( range >> 32 ) - start + 1 ; MethodBinding [ ] result ; System . arraycopy ( this . methods , start , result = new MethodBinding [ length ] , 0 , length ) ; return result ; } } if ( ( this . tagBits & TagBits . AreMethodsComplete ) != 0 ) return Binding . NO_METHODS ; MethodBinding [ ] parameterizedMethods = null ; try { MethodBinding [ ] originalMethods = this . type . getMethods ( selector ) ; int length = originalMethods . length ; if ( length == 0 ) return Binding . NO_METHODS ; parameterizedMethods = new MethodBinding [ length ] ; for ( int i = 0 ; i < length ; i ++ ) parameterizedMethods [ i ] = createParameterizedMethod ( originalMethods [ i ] ) ; if ( this . methods == null ) { MethodBinding [ ] temp = new MethodBinding [ length ] ; System . arraycopy ( parameterizedMethods , 0 , temp , 0 , length ) ; this . methods = temp ; } else { int total = length + this . methods . length ; MethodBinding [ ] temp = new MethodBinding [ total ] ; System . arraycopy ( parameterizedMethods , 0 , temp , 0 , length ) ; System . arraycopy ( this . methods , 0 , temp , length , this . methods . length ) ; if ( total > 1 ) ReferenceBinding . sortMethods ( temp , 0 , total ) ; this . methods = temp ; } return parameterizedMethods ; } finally { if ( parameterizedMethods == null ) this . methods = parameterizedMethods = Binding . NO_METHODS ; } } public int getOuterLocalVariablesSlotSize ( ) { return genericType ( ) . getOuterLocalVariablesSlotSize ( ) ; } public boolean hasMemberTypes ( ) { return this . type . hasMemberTypes ( ) ; } public boolean implementsMethod ( MethodBinding method ) { return this . type . implementsMethod ( method ) ; } void initialize ( ReferenceBinding someType , TypeBinding [ ] someArguments ) { this . type = someType ; this . sourceName = someType . sourceName ; this . compoundName = someType . compoundName ; this . fPackage = someType . fPackage ; this . fileName = someType . fileName ; this . modifiers = someType . modifiers & ~ ExtraCompilerModifiers . AccGenericSignature ; if ( someArguments != null ) { this . modifiers |= ExtraCompilerModifiers . AccGenericSignature ; } else if ( this . enclosingType != null ) { this . modifiers |= ( this . enclosingType . modifiers & ExtraCompilerModifiers . AccGenericSignature ) ; this . tagBits |= this . enclosingType . tagBits & ( TagBits . HasTypeVariable | TagBits . HasMissingType ) ; } if ( someArguments != null ) { this . arguments = someArguments ; for ( int i = 0 , length = someArguments . length ; i < length ; i ++ ) { TypeBinding someArgument = someArguments [ i ] ; switch ( someArgument . kind ( ) ) { case Binding . WILDCARD_TYPE : this . tagBits |= TagBits . HasDirectWildcard ; if ( ( ( WildcardBinding ) someArgument ) . boundKind != Wildcard . UNBOUND ) { this . tagBits |= TagBits . IsBoundParameterizedType ; } break ; case Binding . INTERSECTION_TYPE : this . tagBits |= TagBits . HasDirectWildcard ; break ; default : this . tagBits |= TagBits . IsBoundParameterizedType ; break ; } this . tagBits |= someArgument . tagBits & ( TagBits . HasTypeVariable | TagBits . HasMissingType | TagBits . ContainsNestedTypeReferences ) ; } } this . tagBits |= someType . tagBits & ( TagBits . IsLocalType | TagBits . IsMemberType | TagBits . IsNestedType | TagBits . HasMissingType | TagBits . ContainsNestedTypeReferences ) ; this . tagBits &= ~ ( TagBits . AreFieldsComplete | TagBits . AreMethodsComplete ) ; } protected void initializeArguments ( ) { } void initializeForStaticImports ( ) { this . type . initializeForStaticImports ( ) ; } public boolean isEquivalentTo ( TypeBinding otherType ) { if ( this == otherType ) return true ; if ( otherType == null ) return false ; switch ( otherType . kind ( ) ) { case Binding . WILDCARD_TYPE : case Binding . INTERSECTION_TYPE : return ( ( WildcardBinding ) otherType ) . boundCheck ( this ) ; case Binding . PARAMETERIZED_TYPE : ParameterizedTypeBinding otherParamType = ( ParameterizedTypeBinding ) otherType ; if ( this . type != otherParamType . type ) return false ; if ( ! isStatic ( ) ) { ReferenceBinding enclosing = enclosingType ( ) ; if ( enclosing != null ) { ReferenceBinding otherEnclosing = otherParamType . enclosingType ( ) ; if ( otherEnclosing == null ) return false ; if ( ( otherEnclosing . tagBits & TagBits . HasDirectWildcard ) == 0 ) { if ( enclosing != otherEnclosing ) return false ; } else { if ( ! enclosing . isEquivalentTo ( otherParamType . enclosingType ( ) ) ) return false ; } } } if ( this . arguments == null ) { return otherParamType . arguments == null ; } int length = this . arguments . length ; TypeBinding [ ] otherArguments = otherParamType . arguments ; if ( otherArguments == null || otherArguments . length != length ) return false ; for ( int i = 0 ; i < length ; i ++ ) { if ( ! this . arguments [ i ] . isTypeArgumentContainedBy ( otherArguments [ i ] ) ) return false ; } return true ; case Binding . RAW_TYPE : return erasure ( ) == otherType . erasure ( ) ; } return false ; } public boolean isHierarchyConnected ( ) { return this . superclass != null && this . superInterfaces != null ; } public boolean isRawSubstitution ( ) { return isRawType ( ) ; } public int kind ( ) { return PARAMETERIZED_TYPE ; } public ReferenceBinding [ ] memberTypes ( ) { if ( this . memberTypes == null ) { try { ReferenceBinding [ ] originalMemberTypes = this . type . memberTypes ( ) ; int length = originalMemberTypes . length ; ReferenceBinding [ ] parameterizedMemberTypes = new ReferenceBinding [ length ] ; for ( int i = 0 ; i < length ; i ++ ) parameterizedMemberTypes [ i ] = this . environment . createParameterizedType ( originalMemberTypes [ i ] , null , this ) ; this . memberTypes = parameterizedMemberTypes ; } finally { if ( this . memberTypes == null ) this . memberTypes = Binding . NO_MEMBER_TYPES ; } } return this . memberTypes ; } public MethodBinding [ ] methods ( ) { if ( ( this . tagBits & TagBits . AreMethodsComplete ) != 0 ) return this . methods ; try { MethodBinding [ ] originalMethods = this . type . methods ( ) ; int length = originalMethods . length ; MethodBinding [ ] parameterizedMethods = new MethodBinding [ length ] ; for ( int i = 0 ; i < length ; i ++ ) parameterizedMethods [ i ] = createParameterizedMethod ( originalMethods [ i ] ) ; this . methods = parameterizedMethods ; } finally { if ( this . methods == null ) this . methods = Binding . NO_METHODS ; this . tagBits |= TagBits . AreMethodsComplete ; } return this . methods ; } public int problemId ( ) { return this . type . problemId ( ) ; } public char [ ] qualifiedPackageName ( ) { return this . type . qualifiedPackageName ( ) ; } public char [ ] qualifiedSourceName ( ) { return this . type . qualifiedSourceName ( ) ; } public char [ ] readableName ( ) { StringBuffer nameBuffer = new StringBuffer ( 10 ) ; if ( isMemberType ( ) ) { nameBuffer . append ( CharOperation . concat ( enclosingType ( ) . readableName ( ) , this . sourceName , '.' ) ) ; } else { nameBuffer . append ( CharOperation . concatWith ( this . type . compoundName , '.' ) ) ; } if ( this . arguments != null ) { nameBuffer . append ( '<' ) ; for ( int i = 0 , length = this . arguments . length ; i < length ; i ++ ) { if ( i > 0 ) nameBuffer . append ( ',' ) ; nameBuffer . append ( this . arguments [ i ] . readableName ( ) ) ; } nameBuffer . append ( '>' ) ; } int nameLength = nameBuffer . length ( ) ; char [ ] readableName = new char [ nameLength ] ; nameBuffer . getChars ( 0 , nameLength , readableName , 0 ) ; return readableName ; } ReferenceBinding resolve ( ) { if ( ( this . tagBits & TagBits . HasUnresolvedTypeVariables ) == 0 ) return this ; this . tagBits &= ~ TagBits . HasUnresolvedTypeVariables ; ReferenceBinding resolvedType = ( ReferenceBinding ) BinaryTypeBinding . resolveType ( this . type , this . environment , false ) ; this . tagBits |= resolvedType . tagBits & TagBits . ContainsNestedTypeReferences ; if ( this . arguments != null ) { int argLength = this . arguments . length ; for ( int i = 0 ; i < argLength ; i ++ ) { TypeBinding resolveType = BinaryTypeBinding . resolveType ( this . arguments [ i ] , this . environment , true ) ; this . arguments [ i ] = resolveType ; this . tagBits |= resolvedType . tagBits & TagBits . ContainsNestedTypeReferences ; } TypeVariableBinding [ ] refTypeVariables = resolvedType . typeVariables ( ) ; if ( refTypeVariables == Binding . NO_TYPE_VARIABLES ) { if ( ( resolvedType . tagBits & TagBits . HasMissingType ) == 0 ) { this . environment . problemReporter . nonGenericTypeCannotBeParameterized ( 0 , null , resolvedType , this . arguments ) ; } return this ; } else if ( argLength != refTypeVariables . length ) { this . environment . problemReporter . incorrectArityForParameterizedType ( null , resolvedType , this . arguments ) ; return this ; } } return this ; } public char [ ] shortReadableName ( ) { StringBuffer nameBuffer = new StringBuffer ( 10 ) ; if ( isMemberType ( ) ) { nameBuffer . append ( CharOperation . concat ( enclosingType ( ) . shortReadableName ( ) , this . sourceName , '.' ) ) ; } else { nameBuffer . append ( this . type . sourceName ) ; } if ( this . arguments != null ) { nameBuffer . append ( '<' ) ; for ( int i = 0 , length = this . arguments . length ; i < length ; i ++ ) { if ( i > 0 ) nameBuffer . append ( ',' ) ; nameBuffer . append ( this . arguments [ i ] . shortReadableName ( ) ) ; } nameBuffer . append ( '>' ) ; } int nameLength = nameBuffer . length ( ) ; char [ ] shortReadableName = new char [ nameLength ] ; nameBuffer . getChars ( 0 , nameLength , shortReadableName , 0 ) ; return shortReadableName ; } public char [ ] signature ( ) { if ( this . signature == null ) { this . signature = this . type . signature ( ) ; } return this . signature ; } public char [ ] sourceName ( ) { return this . type . sourceName ( ) ; } public TypeBinding substitute ( TypeVariableBinding originalVariable ) { ParameterizedTypeBinding currentType = this ; while ( true ) { TypeVariableBinding [ ] typeVariables = currentType . type . typeVariables ( ) ; int length = typeVariables . length ; if ( originalVariable . rank < length && typeVariables [ originalVariable . rank ] == originalVariable ) { if ( currentType . arguments == null ) currentType . initializeArguments ( ) ; if ( currentType . arguments != null ) return currentType . arguments [ originalVariable . rank ] ; } if ( currentType . isStatic ( ) ) break ; ReferenceBinding enclosing = currentType . enclosingType ( ) ; if ( ! ( enclosing instanceof ParameterizedTypeBinding ) ) break ; currentType = ( ParameterizedTypeBinding ) enclosing ; } return originalVariable ; } public ReferenceBinding superclass ( ) { if ( this . superclass == null ) { ReferenceBinding genericSuperclass = this . type . superclass ( ) ; if ( genericSuperclass == null ) return null ; this . superclass = ( ReferenceBinding ) Scope . substitute ( this , genericSuperclass ) ; } return this . superclass ; } public ReferenceBinding [ ] superInterfaces ( ) { if ( this . superInterfaces == null ) { if ( this . type . isHierarchyBeingConnected ( ) ) return Binding . NO_SUPERINTERFACES ; this . superInterfaces = Scope . substitute ( this , this . type . superInterfaces ( ) ) ; } return this . superInterfaces ; } public void swapUnresolved ( UnresolvedReferenceBinding unresolvedType , ReferenceBinding resolvedType , LookupEnvironment env ) { boolean update = false ; if ( this . type == unresolvedType ) { this . type = resolvedType ; update = true ; ReferenceBinding enclosing = resolvedType . enclosingType ( ) ; if ( enclosing != null ) { this . enclosingType = ( ReferenceBinding ) env . convertUnresolvedBinaryToRawType ( enclosing ) ; } } if ( this . arguments != null ) { for ( int i = 0 , l = this . arguments . length ; i < l ; i ++ ) { if ( this . arguments [ i ] == unresolvedType ) { this . arguments [ i ] = env . convertUnresolvedBinaryToRawType ( resolvedType ) ; update = true ; } } } if ( update ) initialize ( this . type , this . arguments ) ; } public ReferenceBinding [ ] syntheticEnclosingInstanceTypes ( ) { return genericType ( ) . syntheticEnclosingInstanceTypes ( ) ; } public SyntheticArgumentBinding [ ] syntheticOuterLocalVariables ( ) { return genericType ( ) . syntheticOuterLocalVariables ( ) ; } public String toString ( ) { StringBuffer buffer = new StringBuffer ( 30 ) ; if ( this . type instanceof UnresolvedReferenceBinding ) { buffer . append ( debugName ( ) ) ; } else { if ( isDeprecated ( ) ) buffer . append ( "deprecated " ) ; if ( isPublic ( ) ) buffer . append ( "public " ) ; if ( isProtected ( ) ) buffer . append ( "protected " ) ; if ( isPrivate ( ) ) buffer . append ( "private " ) ; if ( isAbstract ( ) && isClass ( ) ) buffer . append ( "abstract " ) ; if ( isStatic ( ) && isNestedType ( ) ) buffer . append ( "static " ) ; if ( isFinal ( ) ) buffer . append ( "final " ) ; if ( isEnum ( ) ) buffer . append ( "enum " ) ; else if ( isAnnotationType ( ) ) buffer . append ( "@interface " ) ; else if ( isClass ( ) ) buffer . append ( "class " ) ; else buffer . append ( "interface " ) ; buffer . append ( debugName ( ) ) ; buffer . append ( "ntextends " ) ; buffer . append ( ( this . superclass != null ) ? this . superclass . debugName ( ) : "NULL TYPE" ) ; if ( this . superInterfaces != null ) { if ( this . superInterfaces != Binding . NO_SUPERINTERFACES ) { buffer . append ( "" ) ; for ( int i = 0 , length = this . superInterfaces . length ; i < length ; i ++ ) { if ( i > 0 ) buffer . append ( ", " ) ; buffer . append ( ( this . superInterfaces [ i ] != null ) ? this . superInterfaces [ i ] . debugName ( ) : "NULL TYPE" ) ; } } } else { buffer . append ( "" ) ; } if ( enclosingType ( ) != null ) { buffer . append ( "" ) ; buffer . append ( enclosingType ( ) . debugName ( ) ) ; } if ( this . fields != null ) { if ( this . fields != Binding . NO_FIELDS ) { buffer . append ( "" ) ; for ( int i = 0 , length = this . fields . length ; i < length ; i ++ ) buffer . append ( '\n' ) . append ( ( this . fields [ i ] != null ) ? this . fields [ i ] . toString ( ) : "NULL FIELD" ) ; } } else { buffer . append ( "NULL FIELDS" ) ; } if ( this . methods != null ) { if ( this . methods != Binding . NO_METHODS ) { buffer . append ( "" ) ; for ( int i = 0 , length = this . methods . length ; i < length ; i ++ ) buffer . append ( '\n' ) . append ( ( this . methods [ i ] != null ) ? this . methods [ i ] . toString ( ) : "NULL METHOD" ) ; } } else { buffer . append ( "NULL METHODS" ) ; } buffer . append ( "nn" ) ; } return buffer . toString ( ) ; } public TypeVariableBinding [ ] typeVariables ( ) { if ( this . arguments == null ) { return this . type . typeVariables ( ) ; } return Binding . NO_TYPE_VARIABLES ; } } </s>