package org.eclipse.jdt.internal.compiler.ast;
import static org.eclipse.jdt.internal.compiler.ast.ExpressionContext.*;
import java.util.HashMap;
import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.*;
import org.eclipse.jdt.internal.compiler.flow.*;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.*;
import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
public class AllocationExpression extends Expression implements IPolyExpression, Invocation {
public TypeReference type;
public Expression[] arguments;
public MethodBinding binding;
MethodBinding syntheticAccessor;
public TypeReference[] typeArguments;
public TypeBinding[] genericTypeArguments;
public FieldDeclaration enumConstant;
protected TypeBinding typeExpected;
public boolean inferredReturnType;
public FakedTrackingVariable closeTracker;
public ExpressionContext expressionContext = VANILLA_CONTEXT;
private SimpleLookupTable inferenceContexts;
public HashMap<TypeBinding, MethodBinding> solutionsPerTargetType;
private InferenceContext18 outerInferenceContext;
public boolean argsContainCast;
public TypeBinding[] argumentTypes = Binding.NO_PARAMETERS;
public boolean argumentsHaveErrors = false;
@Override
public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
checkCapturedLocalInitializationIfNecessary((ReferenceBinding)this.binding.declaringClass.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)
.unconditionalInits();
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);
}
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);
ReferenceBinding declaringClass = this.binding.declaringClass;
MethodScope methodScope = currentScope.methodScope();
if ((declaringClass.isMemberType() && !declaringClass.isStatic()) ||
(declaringClass.isLocalType() && !methodScope.isStatic && methodScope.isLambdaScope())) {
currentScope.tagAsAccessingEnclosingInstanceStateOf(this.binding.declaringClass.enclosingType(), false );
}
manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
manageSyntheticAccessIfNecessary(currentScope, flowInfo);
flowContext.recordAbruptExit();
return flowInfo;
}
public void checkCapturedLocalInitializationIfNecessary(ReferenceBinding checkedType, BlockScope currentScope, FlowInfo flowInfo) {
if (((checkedType.tagBits & ( TagBits.AnonymousTypeMask|TagBits.LocalTypeMask)) == TagBits.LocalTypeMask)
&& !currentScope.isDefinedInType(checkedType)) {
NestedTypeBinding nestedType = (NestedTypeBinding) checkedType;
SyntheticArgumentBinding[] syntheticArguments = nestedType.syntheticOuterLocalVariables();
if (syntheticArguments != null)
for (int i = 0, count = syntheticArguments.length; i < count; i++){
SyntheticArgumentBinding syntheticArgument = syntheticArguments[i];
LocalVariableBinding targetLocal;
if ((targetLocal = syntheticArgument.actualOuterLocalVariable) == null) continue;
if (targetLocal.declaration != null && !flowInfo.isDefinitelyAssigned(targetLocal)){
currentScope.problemReporter().uninitializedLocalVariable(targetLocal, this, currentScope);
}
}
}
}
public Expression enclosingInstance() {
return null;
}
@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);
}
@Override
public TypeBinding[] genericTypeArguments() {
return this.genericTypeArguments;
}
@Override
public boolean isSuperAccess() {
return false;
}
@Override
public boolean isTypeAccess() {
return true;
}
public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) != 0) return;
ReferenceBinding allocatedTypeErasure = (ReferenceBinding) this.binding.declaringClass.erasure();
if (allocatedTypeErasure.isNestedType()
&& (currentScope.enclosingSourceType().isLocalType() || currentScope.isLambdaSubscope())) {
if (allocatedTypeErasure.isLocalType()) {
((LocalTypeBinding) allocatedTypeErasure).addInnerEmulationDependent(currentScope, false);
} else {
currentScope.propagateInnerEmulation(allocatedTypeErasure, false);
}
}
}
public void manageSyntheticAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) != 0) return;
MethodBinding codegenBinding = this.binding.original();
ReferenceBinding declaringClass;
if (codegenBinding.isPrivate() &&
!currentScope.enclosingSourceType().isNestmateOf(this.binding.declaringClass) &&
TypeBinding.notEquals(currentScope.enclosingSourceType(), (declaringClass = codegenBinding.declaringClass))) {
if ((declaringClass.tagBits & TagBits.IsLocalType) != 0 && currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4) {
codegenBinding.tagBits |= TagBits.ClearPrivateModifier;
} else {
this.syntheticAccessor = ((SourceTypeBinding) declaringClass).addSyntheticMethod(codegenBinding, isSuperAccess());
currentScope.problemReporter().needToEmulateMethodAccess(codegenBinding, this);
}
}
}
@Override
public StringBuffer printExpression(int indent, StringBuffer output) {
if (this.type != null) {
output.append("new ");
}
if (this.typeArguments != null) {
output.append('<');
int max = this.typeArguments.length - 1;
for (int j = 0; j < max; j++) {
this.typeArguments[j].print(0, output);
output.append(", ");
}
this.typeArguments[max].print(0, output);
output.append('>');
}
if (this.type != null) {
this.type.printExpression(0, output);
}
output.append('(');
if (this.arguments != null) {
for (int i = 0; i < this.arguments.length; i++) {
if (i > 0) output.append(", ");
this.arguments[i].printExpression(0, output);
}
}
return output.append(')');
}
@Override
public TypeBinding resolveType(BlockScope scope) {
final boolean isDiamond = this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0;
final CompilerOptions compilerOptions = scope.compilerOptions();
long sourceLevel = compilerOptions.sourceLevel;
if (this.constant != Constant.NotAConstant) {
this.constant = Constant.NotAConstant;
if (this.type == null) {
this.resolvedType = scope.enclosingReceiverType();
} else {
this.resolvedType = this.type.resolveType(scope, true );
}
if (this.type != null) {
checkIllegalNullAnnotation(scope, this.resolvedType);
checkParameterizedAllocation: {
if (this.type instanceof ParameterizedQualifiedTypeReference) {
ReferenceBinding currentType = (ReferenceBinding)this.resolvedType;
if (currentType == null) return currentType;
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, this.resolvedType);
break;
}
}
}
}
}
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;
}
}
if (this.arguments != null) {
this.argumentsHaveErrors = false;
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 |= DisableUnnecessaryCastCheck;
this.argsContainCast = true;
}
argument.setExpressionContext(INVOCATION_CONTEXT);
if (this.arguments[i].resolvedType != null)
scope.problemReporter().genericInferenceError("Argument was unexpectedly found resolved", this);
if ((this.argumentTypes[i] = argument.resolveType(scope)) == null) {
this.argumentsHaveErrors = true;
}
}
if (this.argumentsHaveErrors) {
if (isDiamond) {
return null;
}
if (this.resolvedType instanceof ReferenceBinding) {
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((ReferenceBinding) this.resolvedType, 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;
}
}
}
}
return this.resolvedType;
}
}
if (this.resolvedType == null || !this.resolvedType.isValidBinding()) {
return null;
}
if (this.type != null && !this.resolvedType.canBeInstantiated()) {
scope.problemReporter().cannotInstantiate(this.type, this.resolvedType);
return this.resolvedType;
}
}
if (isDiamond) {
this.binding = inferConstructorOfElidedParameterizedType(scope);
if (this.binding == null || !this.binding.isValidBinding()) {
scope.problemReporter().cannotInferElidedTypes(this);
return this.resolvedType = null;
}
if (this.typeExpected == null && compilerOptions.sourceLevel >= ClassFileConstants.JDK1_8 && this.expressionContext.definesTargetType()) {
return new PolyTypeBinding(this);
}
this.resolvedType = this.type.resolvedType = this.binding.declaringClass;
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 {
this.binding = findConstructorBinding(scope, this, (ReferenceBinding) this.resolvedType, this.argumentTypes);
}
if (!this.binding.isValidBinding()) {
if (this.binding.declaringClass == null) {
this.binding.declaringClass = (ReferenceBinding) this.resolvedType;
}
if (this.type != null && !this.type.resolvedType.isValidBinding()) {
return null;
}
scope.problemReporter().invalidConstructor(this, this.binding);
return this.resolvedType;
}
if ((this.binding.tagBits & TagBits.HasMissingType) != 0) {
scope.problemReporter().missingTypeInConstructor(this, this.binding);
}
if (isMethodUseDeprecated(this.binding, scope, true, this)) {
scope.problemReporter().deprecatedMethod(this.binding, this);
}
if (checkInvocationArguments(scope, null, this.resolvedType, this.binding, this.arguments, this.argumentTypes, this.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);
}
if (!isDiamond && this.resolvedType.isParameterizedTypeWithActualArguments()) {
checkTypeArgumentRedundancy((ParameterizedTypeBinding) this.resolvedType, scope);
}
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 this.resolvedType;
}
void checkIllegalNullAnnotation(BlockScope scope, TypeBinding allocationType) {
if (allocationType != null) {
long nullTagBits = allocationType.tagBits & TagBits.AnnotationNullMASK;
if (nullTagBits != 0) {
Annotation annotation = this.type.findAnnotation(nullTagBits);
if (annotation != null)
scope.problemReporter().nullAnnotationUnsupportedLocation(annotation);
}
}
}
@Override
public boolean isBoxingCompatibleWith(TypeBinding targetType, Scope scope) {
return isPolyExpression() ? false : isCompatibleWith(scope.boxing(targetType), scope);
}
@Override
public boolean isCompatibleWith(TypeBinding targetType, final Scope scope) {
if (this.argumentsHaveErrors || this.binding == null || !this.binding.isValidBinding() || targetType == null || scope == null)
return false;
TypeBinding allocationType = this.resolvedType;
if (isPolyExpression()) {
TypeBinding originalExpectedType = this.typeExpected;
try {
MethodBinding method = this.solutionsPerTargetType != null ? this.solutionsPerTargetType.get(targetType) : null;
if (method == null) {
this.typeExpected = targetType;
method = inferConstructorOfElidedParameterizedType(scope);
if (method == null || !method.isValidBinding())
return false;
}
allocationType = method.declaringClass;
} finally {
this.typeExpected = originalExpectedType;
}
}
return allocationType != null && allocationType.isCompatibleWith(targetType, scope);
}
public MethodBinding inferConstructorOfElidedParameterizedType(final Scope scope) {
if (this.typeExpected != null && this.binding != null) {
MethodBinding cached = this.solutionsPerTargetType != null ? this.solutionsPerTargetType.get(this.typeExpected) : null;
if (cached != null)
return cached;
}
boolean[] inferredReturnTypeOut = new boolean[1];
MethodBinding constructor = inferDiamondConstructor(scope, this, this.resolvedType, this.argumentTypes, inferredReturnTypeOut);
if (constructor != null) {
this.inferredReturnType = inferredReturnTypeOut[0];
if (constructor instanceof ParameterizedGenericMethodBinding && scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_8) {
if (this.expressionContext == INVOCATION_CONTEXT && this.typeExpected == null)
constructor = ParameterizedGenericMethodBinding.computeCompatibleMethod18(constructor.shallowOriginal(), this.argumentTypes, scope, this);
}
if (this.typeExpected != null && this.typeExpected.isProperType(true))
registerResult(this.typeExpected, constructor);
}
return constructor;
}
public static MethodBinding inferDiamondConstructor(Scope scope, InvocationSite site, TypeBinding type, TypeBinding[] argumentTypes, boolean[] inferredReturnTypeOut) {
ReferenceBinding genericType = ((ParameterizedTypeBinding) type).genericType();
ReferenceBinding enclosingType = type.enclosingType();
ParameterizedTypeBinding allocationType = scope.environment().createParameterizedType(genericType, genericType.typeVariables(), enclosingType);
MethodBinding factory = scope.getStaticFactory(allocationType, enclosingType, argumentTypes, site);
if (factory instanceof ParameterizedGenericMethodBinding && factory.isValidBinding()) {
ParameterizedGenericMethodBinding genericFactory = (ParameterizedGenericMethodBinding) factory;
inferredReturnTypeOut[0] = genericFactory.inferredReturnType;
SyntheticFactoryMethodBinding sfmb = (SyntheticFactoryMethodBinding) factory.original();
TypeVariableBinding[] constructorTypeVariables = sfmb.getConstructor().typeVariables();
TypeBinding [] constructorTypeArguments = constructorTypeVariables != null ? new TypeBinding[constructorTypeVariables.length] : Binding.NO_TYPES;
if (constructorTypeArguments.length > 0)
System.arraycopy(((ParameterizedGenericMethodBinding)factory).typeArguments, sfmb.typeVariables().length - constructorTypeArguments.length ,
constructorTypeArguments, 0, constructorTypeArguments.length);
if (allocationType.isInterface()) {
ParameterizedTypeBinding parameterizedType = (ParameterizedTypeBinding) factory.returnType;
return new ParameterizedMethodBinding(parameterizedType, sfmb.getConstructor());
}
return sfmb.applyTypeArgumentsOnConstructor(((ParameterizedTypeBinding)factory.returnType).arguments, constructorTypeArguments, genericFactory.inferredWithUncheckedConversion, site.invocationTargetType());
}
return null;
}
public TypeBinding[] inferElidedTypes(final Scope scope) {
return inferElidedTypes((ParameterizedTypeBinding) this.resolvedType, scope);
}
public TypeBinding[] inferElidedTypes(ParameterizedTypeBinding parameterizedType, final Scope scope) {
ReferenceBinding genericType = parameterizedType.genericType();
ReferenceBinding enclosingType = parameterizedType.enclosingType();
ParameterizedTypeBinding allocationType = scope.environment().createParameterizedType(genericType, genericType.typeVariables(), enclosingType);
MethodBinding factory = scope.getStaticFactory(allocationType, enclosingType, this.argumentTypes, this);
if (factory instanceof ParameterizedGenericMethodBinding && factory.isValidBinding()) {
ParameterizedGenericMethodBinding genericFactory = (ParameterizedGenericMethodBinding) factory;
this.inferredReturnType = genericFactory.inferredReturnType;
return ((ParameterizedTypeBinding)factory.returnType).arguments;
}
return null;
}
public void checkTypeArgumentRedundancy(ParameterizedTypeBinding allocationType, final BlockScope scope) {
if ((scope.problemReporter().computeSeverity(IProblem.RedundantSpecificationOfTypeArguments) == ProblemSeverities.Ignore) || scope.compilerOptions().sourceLevel < ClassFileConstants.JDK1_7) return;
if (allocationType.arguments == null) return;
if (this.genericTypeArguments != null) return;
if (this.type == null) return;
if (this.argumentTypes == Binding.NO_PARAMETERS && this.typeExpected instanceof ParameterizedTypeBinding) {
ParameterizedTypeBinding expected = (ParameterizedTypeBinding) this.typeExpected;
if (expected.arguments != null && allocationType.arguments.length == expected.arguments.length) {
int i;
for (i = 0; i < allocationType.arguments.length; i++) {
if (TypeBinding.notEquals(allocationType.arguments[i], expected.arguments[i]))
break;
}
if (i == allocationType.arguments.length) {
scope.problemReporter().redundantSpecificationOfTypeArguments(this.type, allocationType.arguments);
return;
}
}
}
TypeBinding [] inferredTypes;
int previousBits = this.type.bits;
try {
this.type.bits |= IsDiamond;
inferredTypes = inferElidedTypes(allocationType, scope);
} finally {
this.type.bits = previousBits;
}
if (inferredTypes == null) {
return;
}
for (int i = 0; i < inferredTypes.length; i++) {
if (TypeBinding.notEquals(inferredTypes[i], allocationType.arguments[i]))
return;
}
scope.problemReporter().redundantSpecificationOfTypeArguments(this.type, allocationType.arguments);
}
@Override
public void setActualReceiverType(ReferenceBinding receiverType) {
}
@Override
public void setDepth(int i) {
}
@Override
public void setFieldIndex(int i) {
}
@Override
public void traverse(ASTVisitor visitor, BlockScope scope) {
if (visitor.visit(this, 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) {
for (int i = 0, argumentsLength = this.arguments.length; i < argumentsLength; i++)
this.arguments[i].traverse(visitor, scope);
}
}
visitor.endVisit(this, scope);
}
@Override
public void setExpectedType(TypeBinding expectedType) {
this.typeExpected = expectedType;
}
@Override
public void setExpressionContext(ExpressionContext context) {
this.expressionContext = context;
}
@Override
public boolean isPolyExpression() {
return isPolyExpression(this.binding);
}
@Override
public boolean isPolyExpression(MethodBinding method) {
return (this.expressionContext == ASSIGNMENT_CONTEXT || this.expressionContext == INVOCATION_CONTEXT) &&
this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0;
}
@Override
public TypeBinding invocationTargetType() {
return this.typeExpected;
}
@Override
public boolean statementExpression() {
return ((this.bits & ASTNode.ParenthesizedMASK) == 0);
}
@Override
public MethodBinding binding() {
return this.binding;
}
@Override
public Expression[] arguments() {
return this.arguments;
}
@Override
public void registerInferenceContext(ParameterizedGenericMethodBinding method, InferenceContext18 infCtx18) {
if (this.inferenceContexts == null)
this.inferenceContexts = new SimpleLookupTable();
this.inferenceContexts.put(method, infCtx18);
}
@Override
public void registerResult(TypeBinding targetType, MethodBinding method) {
if (method != null && method.isConstructor()) {
if (this.solutionsPerTargetType == null)
this.solutionsPerTargetType = new HashMap<>();
this.solutionsPerTargetType.put(targetType, method);
}
}
@Override
public InferenceContext18 getInferenceContext(ParameterizedMethodBinding method) {
if (this.inferenceContexts == null)
return null;
return (InferenceContext18) this.inferenceContexts.get(method);
}
@Override
public void cleanUpInferenceContexts() {
if (this.inferenceContexts == null)
return;
for (Object value : this.inferenceContexts.valueTable)
if (value != null)
((InferenceContext18) value).cleanUp();
this.inferenceContexts = null;
this.outerInferenceContext = null;
this.solutionsPerTargetType = null;
}
@Override
public ExpressionContext getExpressionContext() {
return this.expressionContext;
}
@Override
public InferenceContext18 freshInferenceContext(Scope scope) {
return new InferenceContext18(scope, this.arguments, this, this.outerInferenceContext);
}
@Override
public int nameSourceStart() {
if (this.enumConstant != null)
return this.enumConstant.sourceStart;
else
return this.type.sourceStart;
}
@Override
public int nameSourceEnd() {
if (this.enumConstant != null)
return this.enumConstant.sourceEnd;
else
return this.type.sourceEnd;
}
}