package org.eclipse.jdt.internal.compiler.ast;
import static org.eclipse.jdt.internal.compiler.ast.ExpressionContext.INVOCATION_CONTEXT;
import java.util.Arrays;
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.CompilerOptions;
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.ImplicitNullAnnotationVerifier;
import org.eclipse.jdt.internal.compiler.lookup.IntersectionTypeBinding18;
import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedGenericMethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.PolyTypeBinding;
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.Scope;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBindingVisitor;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
public class QualifiedAllocationExpression extends AllocationExpression {
public Expression enclosingInstance;
public TypeDeclaration anonymousType;
public QualifiedAllocationExpression() {
}
public QualifiedAllocationExpression(TypeDeclaration anonymousType) {
this.anonymousType = anonymousType;
anonymousType.allocation = this;
}
@Override
public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
if (this.enclosingInstance != null) {
flowInfo = this.enclosingInstance.analyseCode(currentScope, flowContext, flowInfo);
} else {
if (this.binding != null && this.binding.declaringClass != null) {
ReferenceBinding superclass = this.binding.declaringClass.superclass();
if (superclass != null && superclass.isMemberType() && !superclass.isStatic()) {
currentScope.tagAsAccessingEnclosingInstanceStateOf(superclass.enclosingType(), false );
}
}
}
checkCapturedLocalInitializationIfNecessary(
(ReferenceBinding)(this.anonymousType == null
? this.binding.declaringClass.erasure()
: this.binding.declaringClass.superclass().erasure()),
currentScope,
flowInfo);
if (this.arguments != null) {
boolean analyseResources = currentScope.compilerOptions().analyseResourceLeaks;
boolean hasResourceWrapperType = analyseResources
&& this.resolvedType instanceof ReferenceBinding
&& ((ReferenceBinding)this.resolvedType).hasTypeBit(TypeIds.BitWrapperCloseable);
for (int i = 0, count = this.arguments.length; i < count; i++) {
flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo);
if (analyseResources && !hasResourceWrapperType) {
flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo, flowContext, false);
}
this.arguments[i].checkNPEbyUnboxing(currentScope, flowContext, flowInfo);
}
analyseArguments(currentScope, flowContext, flowInfo, this.binding, this.arguments);
}
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);
}
if (currentScope.compilerOptions().analyseResourceLeaks && FakedTrackingVariable.isAnyCloseable(this.resolvedType)) {
FakedTrackingVariable.analyseCloseableAllocation(currentScope, flowInfo, this);
}
manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
manageSyntheticAccessIfNecessary(currentScope, flowInfo);
flowContext.recordAbruptExit();
return flowInfo;
}
@Override
public Expression enclosingInstance() {
return this.enclosingInstance;
}
@Override
public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
cleanUpInferenceContexts();
if (!valueRequired)
currentScope.problemReporter().unusedObjectAllocation(this);
int pc = codeStream.position;
MethodBinding codegenBinding = this.binding.original();
ReferenceBinding allocatedType = codegenBinding.declaringClass;
codeStream.new_(this.type, 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 , this.typeArguments);
} 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 , this.typeArguments);
}
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);
}
}
@Override
public boolean isSuperAccess() {
return this.anonymousType != null;
}
@Override
public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0) {
ReferenceBinding allocatedTypeErasure = (ReferenceBinding) this.binding.declaringClass.erasure();
if (allocatedTypeErasure.isNestedType()
&& (currentScope.enclosingSourceType().isLocalType() || currentScope.isLambdaSubscope())) {
if (allocatedTypeErasure.isLocalType()) {
((LocalTypeBinding) allocatedTypeErasure).addInnerEmulationDependent(currentScope, this.enclosingInstance != null);
} else {
currentScope.propagateInnerEmulation(allocatedTypeErasure, this.enclosingInstance != null);
}
}
}
}
@Override
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;
}
@Override
public TypeBinding resolveType(BlockScope scope) {
if (this.anonymousType == null && this.enclosingInstance == null) {
return super.resolveType(scope);
}
TypeBinding result = resolveTypeForQualifiedAllocationExpression(scope);
if (result != null && !result.isPolyType() && this.binding != null) {
final CompilerOptions compilerOptions = scope.compilerOptions();
if (compilerOptions.isAnnotationBasedNullAnalysisEnabled) {
ImplicitNullAnnotationVerifier.ensureNullnessIsKnown(this.binding, scope);
if (compilerOptions.sourceLevel >= ClassFileConstants.JDK1_8) {
if (this.binding instanceof ParameterizedGenericMethodBinding && this.typeArguments != null) {
TypeVariableBinding[] typeVariables = this.binding.original().typeVariables();
for (int i = 0; i < this.typeArguments.length; i++)
this.typeArguments[i].checkNullConstraints(scope, (ParameterizedGenericMethodBinding) this.binding, typeVariables, i);
}
}
}
if (compilerOptions.sourceLevel >= ClassFileConstants.JDK1_8 &&
this.binding.getTypeAnnotations() != Binding.NO_ANNOTATIONS) {
this.resolvedType = scope.environment().createAnnotatedType(this.resolvedType, this.binding.getTypeAnnotations());
}
}
return result;
}
private TypeBinding resolveTypeForQualifiedAllocationExpression(BlockScope scope) {
final boolean isDiamond = this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0;
TypeBinding enclosingInstanceType = null;
TypeBinding receiverType = null;
long sourceLevel = scope.compilerOptions().sourceLevel;
if (this.constant != Constant.NotAConstant) {
this.constant = Constant.NotAConstant;
ReferenceBinding enclosingInstanceReference = null;
boolean hasError = false;
boolean enclosingInstanceContainsCast = 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 if (!(enclosingInstanceReference = (ReferenceBinding) enclosingInstanceType).canBeSeenBy(scope)) {
enclosingInstanceType = new ProblemReferenceBinding(
enclosingInstanceReference.compoundName,
enclosingInstanceReference,
ProblemReasons.NotVisible);
scope.problemReporter().invalidType(this.enclosingInstance, enclosingInstanceType);
hasError = true;
} else {
this.resolvedType = receiverType = ((SingleTypeReference) this.type).resolveTypeEnclosing(scope, (ReferenceBinding) enclosingInstanceType);
checkIllegalNullAnnotation(scope, receiverType);
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 );
checkIllegalNullAnnotation(scope, receiverType);
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;
this.argumentsHaveErrors = 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) {
this.argumentsHaveErrors = true;
}
if (this.argumentsHaveErrors && typeReference instanceof Wildcard) {
scope.problemReporter().illegalUsageOfWildcard(typeReference);
}
}
if (isDiamond) {
scope.problemReporter().diamondNotWithExplicitTypeArguments(this.typeArguments);
return null;
}
if (this.argumentsHaveErrors) {
if (this.arguments != null) {
for (int i = 0, max = this.arguments.length; i < max; i++) {
this.arguments[i].resolveType(scope);
}
}
return null;
}
}
this.argumentTypes = Binding.NO_PARAMETERS;
if (this.arguments != null) {
int length = this.arguments.length;
this.argumentTypes = new TypeBinding[length];
for (int i = 0; i < length; i++) {
Expression argument = this.arguments[i];
if (argument instanceof CastExpression) {
argument.bits |= ASTNode.DisableUnnecessaryCastCheck;
this.argsContainCast = true;
}
argument.setExpressionContext(INVOCATION_CONTEXT);
if ((this.argumentTypes[i] = argument.resolveType(scope)) == null){
this.argumentsHaveErrors = hasError = true;
}
}
}
if (hasError) {
if (isDiamond) {
return null;
}
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] = this.argumentTypes[i] == null ? TypeBinding.NULL : this.argumentTypes[i];
}
this.binding = scope.findMethod(referenceReceiver, TypeConstants.INIT, pseudoArgs, this, false);
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;
}
} else {
if (isDiamond) {
if (sourceLevel < ClassFileConstants.JDK9) {
scope.problemReporter().diamondNotWithAnoymousClasses(this.type);
return null;
}
}
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;
}
this.resolvedType = receiverType;
}
} else {
if (this.enclosingInstance != null) {
enclosingInstanceType = this.enclosingInstance.resolvedType;
this.resolvedType = receiverType = this.type.resolvedType;
}
}
MethodBinding constructorBinding = null;
if (isDiamond) {
this.binding = constructorBinding = inferConstructorOfElidedParameterizedType(scope);
if (this.binding == null || !this.binding.isValidBinding()) {
scope.problemReporter().cannotInferElidedTypes(this);
return this.resolvedType = null;
}
if (this.typeExpected == null && sourceLevel >= ClassFileConstants.JDK1_8 && this.expressionContext.definesTargetType()) {
return new PolyTypeBinding(this);
}
this.resolvedType = this.type.resolvedType = receiverType = this.binding.declaringClass;
if (this.anonymousType != null) {
constructorBinding = getAnonymousConstructorBinding((ReferenceBinding) receiverType, scope);
if (constructorBinding == null)
return null;
this.resolvedType = this.anonymousType.binding;
if (!validate((ParameterizedTypeBinding) receiverType, scope)) {
return this.resolvedType;
}
} else {
if (this.binding.isVarargs()) {
TypeBinding lastArg = this.binding.parameters[this.binding.parameters.length - 1].leafComponentType();
if (!lastArg.erasure().canBeSeenBy(scope)) {
scope.problemReporter().invalidType(this, new ProblemReferenceBinding(new char[][] {lastArg.readableName()}, (ReferenceBinding)lastArg, ProblemReasons.NotVisible));
return this.resolvedType = null;
}
}
}
this.binding = resolvePolyExpressionArguments(this, this.binding, this.argumentTypes, scope);
} else {
if (this.anonymousType != null) {
constructorBinding = getAnonymousConstructorBinding((ReferenceBinding) receiverType, scope);
if (constructorBinding == null)
return null;
this.resolvedType = this.anonymousType.binding;
} else {
this.binding = constructorBinding = findConstructorBinding(scope, this, (ReferenceBinding) receiverType, this.argumentTypes);
}
}
ReferenceBinding receiver = (ReferenceBinding) receiverType;
ReferenceBinding superType = receiver.isInterface() ? scope.getJavaLangObject() : receiver;
if (constructorBinding.isValidBinding()) {
if (isMethodUseDeprecated(constructorBinding, scope, true, this)) {
scope.problemReporter().deprecatedMethod(constructorBinding, this);
}
if (checkInvocationArguments(scope, null, superType, constructorBinding, this.arguments,
this.argumentTypes, this.argsContainCast, this)) {
this.bits |= ASTNode.Unchecked;
}
if (this.typeArguments != null && constructorBinding.original().typeVariables == Binding.NO_TYPE_VARIABLES) {
scope.problemReporter().unnecessaryTypeArgumentsForMethodInvocation(constructorBinding,
this.genericTypeArguments, this.typeArguments);
}
} else {
if (constructorBinding.declaringClass == null) {
constructorBinding.declaringClass = superType;
}
if (this.type != null && !this.type.resolvedType.isValidBinding()) {
return null;
}
scope.problemReporter().invalidConstructor(this, constructorBinding);
return this.resolvedType;
}
if ((constructorBinding.tagBits & TagBits.HasMissingType) != 0) {
scope.problemReporter().missingTypeInConstructor(this, constructorBinding);
}
if (this.enclosingInstance != null) {
ReferenceBinding targetEnclosing = constructorBinding.declaringClass.enclosingType();
if (targetEnclosing == null) {
scope.problemReporter().unnecessaryEnclosingInstanceSpecification(this.enclosingInstance, receiver);
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 (!isDiamond && receiverType.isParameterizedTypeWithActualArguments() &&
(this.anonymousType == null || sourceLevel >= ClassFileConstants.JDK9)) {
checkTypeArgumentRedundancy((ParameterizedTypeBinding) receiverType, scope);
}
if (this.anonymousType != null) {
LookupEnvironment environment=scope.environment();
if (environment.globalOptions.isAnnotationBasedNullAnalysisEnabled) {
ImplicitNullAnnotationVerifier.ensureNullnessIsKnown(constructorBinding, scope);
}
this.binding = this.anonymousType.createDefaultConstructorWithBinding(constructorBinding, (this.bits & ASTNode.Unchecked) != 0 && this.genericTypeArguments == null);
return this.resolvedType;
} else {
return this.resolvedType = receiverType;
}
}
private boolean validate(final ParameterizedTypeBinding allocationType, final Scope scope) {
class ValidityInspector extends TypeBindingVisitor {
private boolean noErrors;
public ValidityInspector() {
this.noErrors = true;
}
@Override
public boolean visit(IntersectionTypeBinding18 intersectionTypeBinding18) {
Arrays.sort(intersectionTypeBinding18.intersectingTypes, (t1, t2) -> t1.id - t2.id);
scope.problemReporter().anonymousDiamondWithNonDenotableTypeArguments(QualifiedAllocationExpression.this.type, allocationType);
return this.noErrors = false;
}
@Override
public boolean visit(TypeVariableBinding typeVariable) {
if (typeVariable.isCapture()) {
scope.problemReporter().anonymousDiamondWithNonDenotableTypeArguments(QualifiedAllocationExpression.this.type, allocationType);
return this.noErrors = false;
}
return true;
}
@Override
public boolean visit(ReferenceBinding ref) {
if (!ref.canBeSeenBy(scope)) {
scope.problemReporter().invalidType(QualifiedAllocationExpression.this.anonymousType, new ProblemReferenceBinding(ref.compoundName, ref, ProblemReasons.NotVisible));
return this.noErrors = false;
}
return true;
}
public boolean isValid() {
TypeBindingVisitor.visit(this, allocationType);
return this.noErrors;
}
}
return new ValidityInspector().isValid();
}
private MethodBinding getAnonymousConstructorBinding(ReferenceBinding receiverType, BlockScope scope) {
ReferenceBinding superType = receiverType;
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;
}
return findConstructorBinding(scope, this, anonymousSuperclass, this.argumentTypes);
}
@Override
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);
}
}
QualifiedAllocationExpression
resolveTypeForQualifiedAllocationExpression(BlockScope): TypeBinding
