<s> package org . eclipse . jdt . internal . compiler . ast ; import org . eclipse . jdt . internal . compiler . ASTVisitor ; import org . eclipse . jdt . internal . compiler . classfmt . ClassFileConstants ; import org . eclipse . jdt . internal . compiler . codegen . CodeStream ; import org . eclipse . jdt . internal . compiler . codegen . Opcodes ; import org . eclipse . jdt . internal . compiler . flow . FlowContext ; import org . eclipse . jdt . internal . compiler . flow . FlowInfo ; import org . eclipse . jdt . internal . compiler . impl . Constant ; import org . eclipse . jdt . internal . compiler . lookup . Binding ; import org . eclipse . jdt . internal . compiler . lookup . BlockScope ; import org . eclipse . jdt . internal . compiler . lookup . ExtraCompilerModifiers ; import org . eclipse . jdt . internal . compiler . lookup . LocalTypeBinding ; import org . eclipse . jdt . internal . compiler . lookup . MethodBinding ; import org . eclipse . jdt . internal . compiler . lookup . ProblemMethodBinding ; import org . eclipse . jdt . internal . compiler . lookup . ProblemReasons ; import org . eclipse . jdt . internal . compiler . lookup . ProblemReferenceBinding ; import org . eclipse . jdt . internal . compiler . lookup . RawTypeBinding ; import org . eclipse . jdt . internal . compiler . lookup . ReferenceBinding ; import org . eclipse . jdt . internal . compiler . lookup . TagBits ; import org . eclipse . jdt . internal . compiler . lookup . TypeBinding ; import org . eclipse . jdt . internal . compiler . lookup . TypeConstants ; import org . eclipse . jdt . internal . compiler . lookup . TypeIds ; public class QualifiedAllocationExpression extends AllocationExpression { public Expression enclosingInstance ; public TypeDeclaration anonymousType ; public QualifiedAllocationExpression ( ) { } public QualifiedAllocationExpression ( TypeDeclaration anonymousType ) { this . anonymousType = anonymousType ; anonymousType . allocation = this ; } public FlowInfo analyseCode ( BlockScope currentScope , FlowContext flowContext , FlowInfo flowInfo ) { if ( this . enclosingInstance != null ) { flowInfo = this . enclosingInstance . analyseCode ( currentScope , flowContext , flowInfo ) ; } checkCapturedLocalInitializationIfNecessary ( ( ReferenceBinding ) ( this . anonymousType == null ? this . binding . declaringClass . erasure ( ) : this . binding . declaringClass . superclass ( ) . erasure ( ) ) , currentScope , flowInfo ) ; if ( this . arguments != null ) { for ( int i = 0 , count = this . arguments . length ; i < count ; i ++ ) { flowInfo = this . arguments [ i ] . analyseCode ( currentScope , flowContext , flowInfo ) ; } } if ( this . anonymousType != null ) { flowInfo = this . anonymousType . analyseCode ( currentScope , flowContext , flowInfo ) ; } ReferenceBinding [ ] thrownExceptions ; if ( ( ( thrownExceptions = this . binding . thrownExceptions ) . length ) != 0 ) { if ( ( this . bits & ASTNode . Unchecked ) != 0 && this . genericTypeArguments == null ) { thrownExceptions = currentScope . environment ( ) . convertToRawTypes ( this . binding . thrownExceptions , true , true ) ; } flowContext . checkExceptionHandlers ( thrownExceptions , this , flowInfo . unconditionalCopy ( ) , currentScope ) ; } manageEnclosingInstanceAccessIfNecessary ( currentScope , flowInfo ) ; manageSyntheticAccessIfNecessary ( currentScope , flowInfo ) ; return flowInfo ; } public Expression enclosingInstance ( ) { return this . enclosingInstance ; } public void generateCode ( BlockScope currentScope , CodeStream codeStream , boolean valueRequired ) { if ( ! valueRequired ) currentScope . problemReporter ( ) . unusedObjectAllocation ( this ) ; int pc = codeStream . position ; MethodBinding codegenBinding = this . binding . original ( ) ; ReferenceBinding allocatedType = codegenBinding . declaringClass ; codeStream . new_ ( allocatedType ) ; boolean isUnboxing = ( this . implicitConversion & TypeIds . UNBOXING ) != 0 ; if ( valueRequired || isUnboxing ) { codeStream . dup ( ) ; } if ( this . type != null ) { codeStream . recordPositionsFrom ( pc , this . type . sourceStart ) ; } else { codeStream . ldc ( String . valueOf ( this . enumConstant . name ) ) ; codeStream . generateInlinedValue ( this . enumConstant . binding . id ) ; } if ( allocatedType . isNestedType ( ) ) { codeStream . generateSyntheticEnclosingInstanceValues ( currentScope , allocatedType , enclosingInstance ( ) , this ) ; } generateArguments ( this . binding , this . arguments , currentScope , codeStream ) ; if ( allocatedType . isNestedType ( ) ) { codeStream . generateSyntheticOuterArgumentValues ( currentScope , allocatedType , this ) ; } if ( this . syntheticAccessor == null ) { codeStream . invoke ( Opcodes . OPC_invokespecial , codegenBinding , null ) ; } else { for ( int i = 0 , max = this . syntheticAccessor . parameters . length - codegenBinding . parameters . length ; i < max ; i ++ ) { codeStream . aconst_null ( ) ; } codeStream . invoke ( Opcodes . OPC_invokespecial , this . syntheticAccessor , null ) ; } if ( valueRequired ) { codeStream . generateImplicitConversion ( this . implicitConversion ) ; } else if ( isUnboxing ) { codeStream . generateImplicitConversion ( this . implicitConversion ) ; switch ( postConversionType ( currentScope ) . id ) { case T_long : case T_double : codeStream . pop2 ( ) ; break ; default : codeStream . pop ( ) ; } } codeStream . recordPositionsFrom ( pc , this . sourceStart ) ; if ( this . anonymousType != null ) { this . anonymousType . generateCode ( currentScope , codeStream ) ; } } public boolean isSuperAccess ( ) { return this . anonymousType != null ; } public void manageEnclosingInstanceAccessIfNecessary ( BlockScope currentScope , FlowInfo flowInfo ) { if ( ( flowInfo . tagBits & FlowInfo . UNREACHABLE ) == 0 ) { ReferenceBinding allocatedTypeErasure = ( ReferenceBinding ) this . binding . declaringClass . erasure ( ) ; if ( allocatedTypeErasure . isNestedType ( ) && currentScope . enclosingSourceType ( ) . isLocalType ( ) ) { if ( allocatedTypeErasure . isLocalType ( ) ) { ( ( LocalTypeBinding ) allocatedTypeErasure ) . addInnerEmulationDependent ( currentScope , this . enclosingInstance != null ) ; } else { currentScope . propagateInnerEmulation ( allocatedTypeErasure , this . enclosingInstance != null ) ; } } } } public StringBuffer printExpression ( int indent , StringBuffer output ) { if ( this . enclosingInstance != null ) this . enclosingInstance . printExpression ( 0 , output ) . append ( '.' ) ; super . printExpression ( 0 , output ) ; if ( this . anonymousType != null ) { this . anonymousType . print ( indent , output ) ; } return output ; } public TypeBinding resolveType ( BlockScope scope ) { if ( this . anonymousType == null && this . enclosingInstance == null ) { return super . resolveType ( scope ) ; } this . constant = Constant . NotAConstant ; TypeBinding enclosingInstanceType = null ; TypeBinding receiverType = null ; boolean hasError = false ; boolean enclosingInstanceContainsCast = false ; boolean argsContainCast = false ; if ( this . enclosingInstance != null ) { if ( this . enclosingInstance instanceof CastExpression ) { this . enclosingInstance . bits |= ASTNode . DisableUnnecessaryCastCheck ; enclosingInstanceContainsCast = true ; } if ( ( enclosingInstanceType = this . enclosingInstance . resolveType ( scope ) ) == null ) { hasError = true ; } else if ( enclosingInstanceType . isBaseType ( ) || enclosingInstanceType . isArrayType ( ) ) { scope . problemReporter ( ) . illegalPrimitiveOrArrayTypeForEnclosingInstance ( enclosingInstanceType , this . enclosingInstance ) ; hasError = true ; } else if ( this . type instanceof QualifiedTypeReference ) { scope . problemReporter ( ) . illegalUsageOfQualifiedTypeReference ( ( QualifiedTypeReference ) this . type ) ; hasError = true ; } else { receiverType = ( ( SingleTypeReference ) this . type ) . resolveTypeEnclosing ( scope , ( ReferenceBinding ) enclosingInstanceType ) ; if ( receiverType != null && enclosingInstanceContainsCast ) { CastExpression . checkNeedForEnclosingInstanceCast ( scope , this . enclosingInstance , enclosingInstanceType , receiverType ) ; } } } else { if ( this . type == null ) { receiverType = scope . enclosingSourceType ( ) ; } else { receiverType = this . type . resolveType ( scope , true ) ; checkParameterizedAllocation : { if ( receiverType == null || ! receiverType . isValidBinding ( ) ) break checkParameterizedAllocation ; if ( this . type instanceof ParameterizedQualifiedTypeReference ) { ReferenceBinding currentType = ( ReferenceBinding ) receiverType ; do { if ( ( currentType . modifiers & ClassFileConstants . AccStatic ) != 0 ) break checkParameterizedAllocation ; if ( currentType . isRawType ( ) ) break checkParameterizedAllocation ; } while ( ( currentType = currentType . enclosingType ( ) ) != null ) ; ParameterizedQualifiedTypeReference qRef = ( ParameterizedQualifiedTypeReference ) this . type ; for ( int i = qRef . typeArguments . length - 2 ; i >= 0 ; i -- ) { if ( qRef . typeArguments [ i ] != null ) { scope . problemReporter ( ) . illegalQualifiedParameterizedTypeAllocation ( this . type , receiverType ) ; break ; } } } } } } if ( receiverType == null || ! receiverType . isValidBinding ( ) ) { hasError = true ; } if ( this . typeArguments != null ) { int length = this . typeArguments . length ; boolean argHasError = scope . compilerOptions ( ) . sourceLevel < ClassFileConstants . JDK1_5 ; this . genericTypeArguments = new TypeBinding [ length ] ; for ( int i = 0 ; i < length ; i ++ ) { TypeReference typeReference = this . typeArguments [ i ] ; if ( ( this . genericTypeArguments [ i ] = typeReference . resolveType ( scope , true ) ) == null ) { argHasError = true ; } if ( argHasError && typeReference instanceof Wildcard ) { scope . problemReporter ( ) . illegalUsageOfWildcard ( typeReference ) ; } } if ( argHasError ) { if ( this . arguments != null ) { for ( int i = 0 , max = this . arguments . length ; i < max ; i ++ ) { this . arguments [ i ] . resolveType ( scope ) ; } } return null ; } } TypeBinding [ ] argumentTypes = Binding . NO_PARAMETERS ; if ( this . arguments != null ) { int length = this . arguments . length ; argumentTypes = new TypeBinding [ length ] ; for ( int i = 0 ; i < length ; i ++ ) { Expression argument = this . arguments [ i ] ; if ( argument instanceof CastExpression ) { argument . bits |= ASTNode . DisableUnnecessaryCastCheck ; argsContainCast = true ; } if ( ( argumentTypes [ i ] = argument . resolveType ( scope ) ) == null ) { hasError = true ; } } } if ( hasError ) { if ( receiverType instanceof ReferenceBinding ) { ReferenceBinding referenceReceiver = ( ReferenceBinding ) receiverType ; if ( receiverType . isValidBinding ( ) ) { int length = this . arguments == null ? 0 : this . arguments . length ; TypeBinding [ ] pseudoArgs = new TypeBinding [ length ] ; for ( int i = length ; -- i >= 0 ; ) { pseudoArgs [ i ] = argumentTypes [ i ] == null ? TypeBinding . NULL : argumentTypes [ i ] ; } this . binding = scope . findMethod ( referenceReceiver , TypeConstants . INIT , pseudoArgs , this ) ; if ( this . binding != null && ! this . binding . isValidBinding ( ) ) { MethodBinding closestMatch = ( ( ProblemMethodBinding ) this . binding ) . closestMatch ; if ( closestMatch != null ) { if ( closestMatch . original ( ) . typeVariables != Binding . NO_TYPE_VARIABLES ) { closestMatch = scope . environment ( ) . createParameterizedGenericMethod ( closestMatch . original ( ) , ( RawTypeBinding ) null ) ; } this . binding = closestMatch ; MethodBinding closestMatchOriginal = closestMatch . original ( ) ; if ( closestMatchOriginal . isOrEnclosedByPrivateType ( ) && ! scope . isDefinedInMethod ( closestMatchOriginal ) ) { closestMatchOriginal . modifiers |= ExtraCompilerModifiers . AccLocallyUsed ; } } } } if ( this . anonymousType != null ) { scope . addAnonymousType ( this . anonymousType , referenceReceiver ) ; this . anonymousType . resolve ( scope ) ; return this . resolvedType = this . anonymousType . binding ; } } return this . resolvedType = receiverType ; } if ( this . anonymousType == null ) { if ( ! receiverType . canBeInstantiated ( ) ) { scope . problemReporter ( ) . cannotInstantiate ( this . type , receiverType ) ; return this . resolvedType = receiverType ; } ReferenceBinding allocationType = ( ReferenceBinding ) receiverType ; if ( ( this . binding = scope . getConstructor ( allocationType , argumentTypes , this ) ) . isValidBinding ( ) ) { if ( isMethodUseDeprecated ( this . binding , scope , true ) ) { scope . problemReporter ( ) . deprecatedMethod ( this . binding , this ) ; } if ( checkInvocationArguments ( scope , null , allocationType , this . binding , this . arguments , argumentTypes , argsContainCast , this ) ) { this . bits |= ASTNode . Unchecked ; } if ( this . typeArguments != null && this . binding . original ( ) . typeVariables == Binding . NO_TYPE_VARIABLES ) { scope . problemReporter ( ) . unnecessaryTypeArgumentsForMethodInvocation ( this . binding , this . genericTypeArguments , this . typeArguments ) ; } } else { if ( this . binding . declaringClass == null ) { this . binding . declaringClass = allocationType ; } if ( this . type != null && ! this . type . resolvedType . isValidBinding ( ) ) { return null ; } scope . problemReporter ( ) . invalidConstructor ( this , this . binding ) ; return this . resolvedType = receiverType ; } if ( ( this . binding . tagBits & TagBits . HasMissingType ) != 0 ) { scope . problemReporter ( ) . missingTypeInConstructor ( this , this . binding ) ; } ReferenceBinding expectedType = this . binding . declaringClass . enclosingType ( ) ; if ( expectedType != enclosingInstanceType ) scope . compilationUnitScope ( ) . recordTypeConversion ( expectedType , enclosingInstanceType ) ; if ( enclosingInstanceType . isCompatibleWith ( expectedType ) || scope . isBoxingCompatibleWith ( enclosingInstanceType , expectedType ) ) { this . enclosingInstance . computeConversion ( scope , expectedType , enclosingInstanceType ) ; return this . resolvedType = receiverType ; } scope . problemReporter ( ) . typeMismatchError ( enclosingInstanceType , expectedType , this . enclosingInstance , null ) ; return this . resolvedType = receiverType ; } ReferenceBinding superType = ( ReferenceBinding ) receiverType ; if ( superType . isTypeVariable ( ) ) { superType = new ProblemReferenceBinding ( new char [ ] [ ] { superType . sourceName ( ) } , superType , ProblemReasons . IllegalSuperTypeVariable ) ; scope . problemReporter ( ) . invalidType ( this , superType ) ; return null ; } else if ( this . type != null && superType . isEnum ( ) ) { scope . problemReporter ( ) . cannotInstantiate ( this . type , superType ) ; return this . resolvedType = superType ; } ReferenceBinding anonymousSuperclass = superType . isInterface ( ) ? scope . getJavaLangObject ( ) : superType ; scope . addAnonymousType ( this . anonymousType , superType ) ; this . anonymousType . resolve ( scope ) ; this . resolvedType = this . anonymousType . binding ; if ( ( this . resolvedType . tagBits & TagBits . HierarchyHasProblems ) != 0 ) { return null ; } MethodBinding inheritedBinding = scope . getConstructor ( anonymousSuperclass , argumentTypes , this ) ; if ( ! inheritedBinding . isValidBinding ( ) ) { if ( inheritedBinding . declaringClass == null ) { inheritedBinding . declaringClass = anonymousSuperclass ; } if ( this . type != null && ! this . type . resolvedType . isValidBinding ( ) ) { return null ; } scope . problemReporter ( ) . invalidConstructor ( this , inheritedBinding ) ; return this . resolvedType ; } if ( ( inheritedBinding . tagBits & TagBits . HasMissingType ) != 0 ) { scope . problemReporter ( ) . missingTypeInConstructor ( this , inheritedBinding ) ; } if ( this . enclosingInstance != null ) { ReferenceBinding targetEnclosing = inheritedBinding . declaringClass . enclosingType ( ) ; if ( targetEnclosing == null ) { scope . problemReporter ( ) . unnecessaryEnclosingInstanceSpecification ( this . enclosingInstance , superType ) ; return this . resolvedType ; } else if ( ! enclosingInstanceType . isCompatibleWith ( targetEnclosing ) && ! scope . isBoxingCompatibleWith ( enclosingInstanceType , targetEnclosing ) ) { scope . problemReporter ( ) . typeMismatchError ( enclosingInstanceType , targetEnclosing , this . enclosingInstance , null ) ; return this . resolvedType ; } this . enclosingInstance . computeConversion ( scope , targetEnclosing , enclosingInstanceType ) ; } if ( this . arguments != null ) { if ( checkInvocationArguments ( scope , null , anonymousSuperclass , inheritedBinding , this . arguments , argumentTypes , argsContainCast , this ) ) { this . bits |= ASTNode . Unchecked ; } } if ( this . typeArguments != null && inheritedBinding . original ( ) . typeVariables == Binding . NO_TYPE_VARIABLES ) { scope . problemReporter ( ) . unnecessaryTypeArgumentsForMethodInvocation ( inheritedBinding , this . genericTypeArguments , this . typeArguments ) ; } this . binding = this . anonymousType . createDefaultConstructorWithBinding ( inheritedBinding , ( this . bits & ASTNode . Unchecked ) != 0 && this . genericTypeArguments == null ) ; return this . resolvedType ; } public void traverse ( ASTVisitor visitor , BlockScope scope ) { if ( visitor . visit ( this , scope ) ) { if ( this . enclosingInstance != null ) this . enclosingInstance . traverse ( visitor , scope ) ; if ( this . typeArguments != null ) { for ( int i = 0 , typeArgumentsLength = this . typeArguments . length ; i < typeArgumentsLength ; i ++ ) { this . typeArguments [ i ] . traverse ( visitor , scope ) ; } } if ( this . type != null ) this . type . traverse ( visitor , scope ) ; if ( this . arguments != null ) { int argumentsLength = this . arguments . length ; for ( int i = 0 ; i < argumentsLength ; i ++ ) this . arguments [ i ] . traverse ( visitor , scope ) ; } if ( this . anonymousType != null ) this . anonymousType . traverse ( visitor , scope ) ; } visitor . endVisit ( this , scope ) ; } } </s>