/** Check null-ness of 'var' against a possible null annotation */
protected int checkAssignmentAgainstNullAnnotation(
BlockScope currentScope,
FlowContext flowContext,
VariableBinding var,
int nullStatus,
Expression expression,
TypeBinding providedType) {
int severity = 0;
if ((var.tagBits & TagBits.AnnotationNonNull) != 0 && nullStatus != FlowInfo.NON_NULL) {
flowContext.recordNullityMismatch(
currentScope, expression, providedType, var.type, nullStatus);
return FlowInfo.NON_NULL;
} else if ((severity = findNullTypeAnnotationMismatch(var.type, providedType)) > 0) {
currentScope
.problemReporter()
.nullityMismatchingTypeAnnotation(
expression, providedType, var.type, severity == 1, currentScope.environment());
} else if ((var.tagBits & TagBits.AnnotationNullable) != 0
&& nullStatus == FlowInfo.UNKNOWN) { // provided a legacy type?
return FlowInfo.POTENTIALLY_NULL; // -> use more specific info from the annotation
}
return nullStatus;
}
/** Analysing arguments of MessageSend, ExplicitConstructorCall, AllocationExpression. */
protected void analyseArguments(
BlockScope currentScope,
FlowContext flowContext,
FlowInfo flowInfo,
MethodBinding methodBinding,
Expression[] arguments) {
// compare actual null-status against parameter annotations of the called method:
if (arguments != null) {
CompilerOptions compilerOptions = currentScope.compilerOptions();
boolean considerTypeAnnotations =
compilerOptions.sourceLevel >= ClassFileConstants.JDK1_8
&& compilerOptions.isAnnotationBasedNullAnalysisEnabled;
boolean hasJDK15NullAnnotations = methodBinding.parameterNonNullness != null;
int numParamsToCheck = methodBinding.parameters.length;
if (considerTypeAnnotations || hasJDK15NullAnnotations) {
// check if varargs need special treatment:
boolean passThrough = false;
if (methodBinding.isVarargs()) {
int varArgPos = numParamsToCheck - 1;
// this if-block essentially copied from generateArguments(..):
if (numParamsToCheck == arguments.length) {
TypeBinding varArgsType = methodBinding.parameters[varArgPos];
TypeBinding lastType = arguments[varArgPos].resolvedType;
if (lastType == TypeBinding.NULL
|| (varArgsType.dimensions() == lastType.dimensions()
&& lastType.isCompatibleWith(varArgsType)))
passThrough = true; // pass directly as-is
}
if (!passThrough)
numParamsToCheck--; // with non-passthrough varargs last param is fed from individual
// args -> don't check
}
}
if (considerTypeAnnotations) {
for (int i = 0; i < numParamsToCheck; i++) {
TypeBinding expectedType = methodBinding.parameters[i];
Expression argument = arguments[i];
// prefer check based on type annotations:
int severity = findNullTypeAnnotationMismatch(expectedType, argument.resolvedType);
if (severity > 0) {
// immediate reporting:
currentScope
.problemReporter()
.nullityMismatchingTypeAnnotation(
argument,
argument.resolvedType,
expectedType,
severity == 1,
currentScope.environment());
// next check flow-based null status against null JDK15-style annotations:
} else if (hasJDK15NullAnnotations
&& methodBinding.parameterNonNullness[i] == Boolean.TRUE) {
int nullStatus =
argument.nullStatus(
flowInfo,
flowContext); // slight loss of precision: should also use the null info from
// the receiver.
if (nullStatus != FlowInfo.NON_NULL) // if required non-null is not provided
flowContext.recordNullityMismatch(
currentScope, argument, argument.resolvedType, expectedType, nullStatus);
}
}
} else if (hasJDK15NullAnnotations) {
for (int i = 0; i < numParamsToCheck; i++) {
if (methodBinding.parameterNonNullness[i] == Boolean.TRUE) {
TypeBinding expectedType = methodBinding.parameters[i];
Expression argument = arguments[i];
int nullStatus =
argument.nullStatus(
flowInfo,
flowContext); // slight loss of precision: should also use the null info from
// the receiver.
if (nullStatus != FlowInfo.NON_NULL) // if required non-null is not provided
flowContext.recordNullityMismatch(
currentScope, argument, argument.resolvedType, expectedType, nullStatus);
}
}
}
}
}
public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
// check captured variables are initialized in current context (26134)
checkCapturedLocalInitializationIfNecessary(
(ReferenceBinding) this.binding.declaringClass.erasure(), currentScope, flowInfo);
// process arguments
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 argument is an AutoCloseable insert info that it *may* be closed (by the target
// method, i.e.)
if (analyseResources
&& !hasResourceWrapperType) { // allocation of wrapped closeables is analyzed specially
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);
}
// record some dependency information for exception types
ReferenceBinding[] thrownExceptions;
if (((thrownExceptions = this.binding.thrownExceptions).length) != 0) {
if ((this.bits & ASTNode.Unchecked) != 0 && this.genericTypeArguments == null) {
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=277643, align with javac on JLS 15.12.2.6
thrownExceptions =
currentScope.environment().convertToRawTypes(this.binding.thrownExceptions, true, true);
}
// check exception handling
flowContext.checkExceptionHandlers(
thrownExceptions, this, flowInfo.unconditionalCopy(), currentScope);
}
// after having analysed exceptions above start tracking newly allocated resource:
if (currentScope.compilerOptions().analyseResourceLeaks
&& FakedTrackingVariable.isAnyCloseable(this.resolvedType))
FakedTrackingVariable.analyseCloseableAllocation(currentScope, flowInfo, this);
if (this.binding.declaringClass.isMemberType() && !this.binding.declaringClass.isStatic()) {
// allocating a non-static member type without an enclosing instance of parent type
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=335845
currentScope.resetDeclaringClassMethodStaticFlag(this.binding.declaringClass.enclosingType());
// Reviewed for https://bugs.eclipse.org/bugs/show_bug.cgi?id=378674 :
// The corresponding problem (when called from static) is not produced until during code
// generation
}
manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
manageSyntheticAccessIfNecessary(currentScope, flowInfo);
// account for possible exceptions thrown by the constructor
flowContext.recordAbruptExit(); // TODO whitelist of ctors that cannot throw any exc.??
return flowInfo;
}
public TypeBinding resolveType(BlockScope scope) {
// Propagate the type checking to the arguments, and check if the constructor is defined.
this.constant = Constant.NotAConstant;
if (this.type == null) {
// initialization of an enum constant
this.resolvedType = scope.enclosingReceiverType();
} else {
this.resolvedType = this.type.resolveType(scope, true /* check bounds*/);
checkParameterizedAllocation:
{
if (this.type
instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()
ReferenceBinding currentType = (ReferenceBinding) this.resolvedType;
if (currentType == null) return currentType;
do {
// isStatic() is answering true for toplevel types
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;
}
}
}
}
}
// will check for null after args are resolved
final boolean isDiamond = this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0;
// resolve type arguments (for generic constructor call)
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 /* check bounds*/))
== null) {
argHasError = true;
}
if (argHasError && typeReference instanceof Wildcard) {
scope.problemReporter().illegalUsageOfWildcard(typeReference);
}
}
if (isDiamond) {
scope.problemReporter().diamondNotWithExplicitTypeArguments(this.typeArguments);
return null;
}
if (argHasError) {
if (this.arguments != null) { // still attempt to resolve arguments
for (int i = 0, max = this.arguments.length; i < max; i++) {
this.arguments[i].resolveType(scope);
}
}
return null;
}
}
// buffering the arguments' types
boolean argsContainCast = false;
TypeBinding[] argumentTypes = Binding.NO_PARAMETERS;
if (this.arguments != null) {
boolean argHasError = false;
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 |= DisableUnnecessaryCastCheck; // will check later on
argsContainCast = true;
}
if ((argumentTypes[i] = argument.resolveType(scope)) == null) {
argHasError = true;
}
}
if (argHasError) {
/* https://bugs.eclipse.org/bugs/show_bug.cgi?id=345359, if arguments have errors, completely bail out in the <> case.
No meaningful type resolution is possible since inference of the elided types is fully tied to argument types. Do
not return the partially resolved type.
*/
if (isDiamond) {
return null; // not the partially cooked this.resolvedType
}
if (this.resolvedType instanceof ReferenceBinding) {
// record a best guess, for clients who need hint about possible constructor match
TypeBinding[] pseudoArgs = new TypeBinding[length];
for (int i = length; --i >= 0; ) {
pseudoArgs[i] =
argumentTypes[i] == null
? TypeBinding.NULL
: argumentTypes[i]; // replace args with errors with null type
}
this.binding =
scope.findMethod(
(ReferenceBinding) this.resolvedType, TypeConstants.INIT, pseudoArgs, this);
if (this.binding != null && !this.binding.isValidBinding()) {
MethodBinding closestMatch = ((ProblemMethodBinding) this.binding).closestMatch;
// record the closest match, for clients who may still need hint about possible method
// match
if (closestMatch != null) {
if (closestMatch.original().typeVariables
!= Binding.NO_TYPE_VARIABLES) { // generic method
// shouldn't return generic method outside its context, rather convert it to raw
// method (175409)
closestMatch =
scope
.environment()
.createParameterizedGenericMethod(
closestMatch.original(), (RawTypeBinding) null);
}
this.binding = closestMatch;
MethodBinding closestMatchOriginal = closestMatch.original();
if (closestMatchOriginal.isOrEnclosedByPrivateType()
&& !scope.isDefinedInMethod(closestMatchOriginal)) {
// ignore cases where method is used from within inside itself (e.g. direct
// recursions)
closestMatchOriginal.modifiers |= ExtraCompilerModifiers.AccLocallyUsed;
}
}
}
}
return this.resolvedType;
}
}
if (this.resolvedType == null || !this.resolvedType.isValidBinding()) {
return null;
}
// null type denotes fake allocation for enum constant inits
if (this.type != null && !this.resolvedType.canBeInstantiated()) {
scope.problemReporter().cannotInstantiate(this.type, this.resolvedType);
return this.resolvedType;
}
if (isDiamond) {
TypeBinding[] inferredTypes =
inferElidedTypes(
((ParameterizedTypeBinding) this.resolvedType).genericType(),
null,
argumentTypes,
scope);
if (inferredTypes == null) {
scope.problemReporter().cannotInferElidedTypes(this);
return this.resolvedType = null;
}
this.resolvedType =
this.type.resolvedType =
scope
.environment()
.createParameterizedType(
((ParameterizedTypeBinding) this.resolvedType).genericType(),
inferredTypes,
((ParameterizedTypeBinding) this.resolvedType).enclosingType());
}
ReferenceBinding allocationType = (ReferenceBinding) this.resolvedType;
if (!(this.binding = scope.getConstructor(allocationType, argumentTypes, this))
.isValidBinding()) {
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;
}
if ((this.binding.tagBits & TagBits.HasMissingType) != 0) {
scope.problemReporter().missingTypeInConstructor(this, this.binding);
}
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);
}
if (!isDiamond && this.resolvedType.isParameterizedTypeWithActualArguments()) {
checkTypeArgumentRedundancy(
(ParameterizedTypeBinding) this.resolvedType, null, argumentTypes, scope);
}
final CompilerOptions compilerOptions = scope.compilerOptions();
if (compilerOptions.isAnnotationBasedNullAnalysisEnabled
&& (this.binding.tagBits & TagBits.IsNullnessKnown) == 0) {
new ImplicitNullAnnotationVerifier(
scope.environment(), compilerOptions.inheritNullAnnotations)
.checkImplicitNullAnnotations(this.binding, null /*srcMethod*/, false, scope);
}
return allocationType;
}
public TypeBinding resolveTypeExpecting(BlockScope scope, TypeBinding expectedType) {
// Array initializers can only occur on the right hand side of an assignment
// expression, therefore the expected type contains the valid information
// concerning the type that must be enforced by the elements of the array initializer.
// this method is recursive... (the test on isArrayType is the stop case)
this.constant = Constant.NotAConstant;
if (expectedType instanceof ArrayBinding) {
// allow new List<?>[5]
if ((this.bits & IsAnnotationDefaultValue)
== 0) { // annotation default value need only to be commensurate JLS9.7
// allow new List<?>[5] - only check for generic array when no initializer, since also
// checked inside initializer resolution
TypeBinding leafComponentType = expectedType.leafComponentType();
if (!leafComponentType.isReifiable()) {
scope.problemReporter().illegalGenericArray(leafComponentType, this);
}
}
this.resolvedType = this.binding = (ArrayBinding) expectedType;
if (this.expressions == null) return this.binding;
TypeBinding elementType = this.binding.elementsType();
for (int i = 0, length = this.expressions.length; i < length; i++) {
Expression expression = this.expressions[i];
expression.setExpectedType(elementType);
TypeBinding expressionType =
expression instanceof ArrayInitializer
? expression.resolveTypeExpecting(scope, elementType)
: expression.resolveType(scope);
if (expressionType == null) continue;
// Compile-time conversion required?
if (elementType
!= expressionType) // must call before computeConversion() and typeMismatchError()
scope.compilationUnitScope().recordTypeConversion(elementType, expressionType);
if (expression.isConstantValueOfTypeAssignableToType(expressionType, elementType)
|| expressionType.isCompatibleWith(elementType)) {
expression.computeConversion(scope, elementType, expressionType);
} else if (scope.isBoxingCompatibleWith(expressionType, elementType)
|| (expressionType.isBaseType() // narrowing then boxing ?
&& scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing
&& !elementType.isBaseType()
&& expression.isConstantValueOfTypeAssignableToType(
expressionType, scope.environment().computeBoxingType(elementType)))) {
expression.computeConversion(scope, elementType, expressionType);
} else {
scope.problemReporter().typeMismatchError(expressionType, elementType, expression, null);
}
}
return this.binding;
}
// infer initializer type for error reporting based on first element
TypeBinding leafElementType = null;
int dim = 1;
if (this.expressions == null) {
leafElementType = scope.getJavaLangObject();
} else {
Expression expression = this.expressions[0];
while (expression != null && expression instanceof ArrayInitializer) {
dim++;
Expression[] subExprs = ((ArrayInitializer) expression).expressions;
if (subExprs == null) {
leafElementType = scope.getJavaLangObject();
expression = null;
break;
}
expression = ((ArrayInitializer) expression).expressions[0];
}
if (expression != null) {
leafElementType = expression.resolveType(scope);
}
// fault-tolerance - resolve other expressions as well
for (int i = 1, length = this.expressions.length; i < length; i++) {
expression = this.expressions[i];
if (expression != null) {
expression.resolveType(scope);
}
}
}
if (leafElementType != null) {
this.resolvedType = scope.createArrayType(leafElementType, dim);
if (expectedType != null)
scope.problemReporter().typeMismatchError(this.resolvedType, expectedType, this, null);
}
return null;
}
public TypeBinding resolveType(BlockScope scope) {
this.constant = Constant.NotAConstant;
if ((this.targetType = this.type.resolveType(scope, true /* check bounds*/)) == null)
return null;
/* https://bugs.eclipse.org/bugs/show_bug.cgi?id=320463
https://bugs.eclipse.org/bugs/show_bug.cgi?id=312076
JLS3 15.8.2 forbids the type named in the class literal expression from being a parameterized type.
And the grammar in 18.1 disallows (where X and Y are some concrete types) constructs of the form
Outer<X>.class, Outer<X>.Inner.class, Outer.Inner<X>.class, Outer<X>.Inner<Y>.class etc.
Corollary wise, we should resolve the type of the class literal expression to be a raw type as
class literals exist only for the raw underlying type.
*/
LookupEnvironment environment = scope.environment();
this.targetType =
environment.convertToRawType(
this.targetType, true /* force conversion of enclosing types*/);
if (this.targetType.isArrayType()) {
ArrayBinding arrayBinding = (ArrayBinding) this.targetType;
TypeBinding leafComponentType = arrayBinding.leafComponentType;
if (leafComponentType == TypeBinding.VOID) {
scope.problemReporter().cannotAllocateVoidArray(this);
return null;
} else if (leafComponentType.isTypeVariable()) {
scope
.problemReporter()
.illegalClassLiteralForTypeVariable((TypeVariableBinding) leafComponentType, this);
}
} else if (this.targetType.isTypeVariable()) {
scope
.problemReporter()
.illegalClassLiteralForTypeVariable((TypeVariableBinding) this.targetType, this);
}
// {ObjectTeams: do we need a RoleClassLiteralAccess?
if (this.targetType instanceof ReferenceBinding) {
ReferenceBinding targetRef = (ReferenceBinding) this.targetType;
if (targetRef.isRole()) {
if (this.verbatim) {
this.targetType =
RoleTypeCreator.maybeWrapUnqualifiedRoleType(scope, this.targetType, this);
} else {
SourceTypeBinding site = scope.enclosingSourceType();
if (scope.methodScope().isStatic // role class literal needs team instance
&& !site.isRole() // static role method are OK.
&& !RoleTypeBinding.isRoleWithExplicitAnchor(this.targetType)) // t.R.class?
{
scope.problemReporter().roleClassLiteralLacksTeamInstance(this, targetRef);
return null;
}
ReferenceBinding teamBinding;
if (RoleTypeBinding.isRoleWithExplicitAnchor(targetRef))
teamBinding = targetRef.enclosingType();
else teamBinding = TeamModel.findEnclosingTeamContainingRole(site, targetRef);
if (teamBinding == null)
scope.problemReporter().externalizedRoleClassLiteral(this, targetRef);
else {
TypeBinding methodType =
RoleClassLiteralAccess.ensureGetClassMethod(
teamBinding.getTeamModel(),
targetRef.roleModel); // not affected by visibility check (for resilience)
this.roleClassLiteralAccess = new RoleClassLiteralAccess(this, methodType);
this.resolvedType = this.roleClassLiteralAccess.resolveType(scope);
}
return this.resolvedType;
}
}
}
// SH}
ReferenceBinding classType = scope.getJavaLangClass();
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=328689
if (scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) {
// Integer.class --> Class<Integer>, perform boxing of base types (int.class -->
// Class<Integer>)
TypeBinding boxedType = null;
if (this.targetType.id == T_void) {
boxedType = environment.getResolvedType(JAVA_LANG_VOID, scope);
} else {
boxedType = scope.boxing(this.targetType);
}
if (environment.usesNullTypeAnnotations())
boxedType =
environment.createAnnotatedType(
boxedType, new AnnotationBinding[] {environment.getNonNullAnnotation()});
this.resolvedType =
environment.createParameterizedType(
classType, new TypeBinding[] {boxedType}, null /*not a member*/);
} else {
this.resolvedType = classType;
}
return this.resolvedType;
}
