Java tutorial
/******************************************************************************* * Copyright (c) 2013, 2019 GK Software AG and others. * * This program and the accompanying materials * are made available under the terms of the Eclipse Public License 2.0 * which accompanies this distribution, and is available at * https://www.eclipse.org/legal/epl-2.0/ * * SPDX-License-Identifier: EPL-2.0 * * Contributors: * Stephan Herrmann - initial API and implementation * Till Brychcy - Contributions for * Bug 467482 - TYPE_USE null annotations: Incorrect "Redundant null check"-warning *******************************************************************************/ package org.eclipse.jdt.internal.compiler.ast; import org.eclipse.jdt.core.compiler.IProblem; 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.lookup.AnnotationBinding; import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding; import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding; import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding.ExternalAnnotationStatus; import org.eclipse.jdt.internal.compiler.lookup.Binding; import org.eclipse.jdt.internal.compiler.lookup.BlockScope; import org.eclipse.jdt.internal.compiler.lookup.CaptureBinding; import org.eclipse.jdt.internal.compiler.lookup.InvocationSite; import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment; import org.eclipse.jdt.internal.compiler.lookup.MethodBinding; import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding; import org.eclipse.jdt.internal.compiler.lookup.ProblemMethodBinding; import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons; 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.Substitution; 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.TypeIds; import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding; import org.eclipse.jdt.internal.compiler.lookup.VariableBinding; import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding; import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities; /** * Performs matching of null type annotations. * Instances are used to encode result from this analysis. * @since 3.10 */ public class NullAnnotationMatching { public static final NullAnnotationMatching NULL_ANNOTATIONS_OK = new NullAnnotationMatching(Severity.OK, FlowInfo.UNKNOWN, null); public static final NullAnnotationMatching NULL_ANNOTATIONS_OK_NONNULL = new NullAnnotationMatching(Severity.OK, FlowInfo.NON_NULL, null); public static final NullAnnotationMatching NULL_ANNOTATIONS_UNCHECKED = new NullAnnotationMatching( Severity.UNCHECKED, FlowInfo.UNKNOWN, null); public static final NullAnnotationMatching NULL_ANNOTATIONS_MISMATCH = new NullAnnotationMatching( Severity.MISMATCH, FlowInfo.UNKNOWN, null); public enum CheckMode { /** in this mode we check normal assignment compatibility. */ COMPATIBLE { @Override boolean requiredNullableMatchesAll() { return true; } }, /** in this mode we check similar to isTypeArgumentContained. */ EXACT, /** in this mode we check compatibility of a type argument against the corresponding type parameter. */ BOUND_CHECK, /** similar to COMPATIBLE, but for type variables we look for instantiations, rather than treating them as "free type variables". */ BOUND_SUPER_CHECK, /** allow covariant return types, but no other deviations. */ OVERRIDE_RETURN { @Override CheckMode toDetail() { return OVERRIDE; } }, /** in this mode we do not tolerate incompatibly missing annotations on type parameters (for overriding analysis) */ OVERRIDE { @Override boolean requiredNullableMatchesAll() { return true; } @Override CheckMode toDetail() { return OVERRIDE; } }; boolean requiredNullableMatchesAll() { return false; } CheckMode toDetail() { return CheckMode.EXACT; } } private enum Severity { /** No problem detected. */ OK, /** No real problem, but could issue an {@link IProblem#NonNullTypeVariableFromLegacyMethod} or similar. */ LEGACY_WARNING, /** Need unchecked conversion from unannotated to annotated. */ UNCHECKED, /** Definite nullity mismatch. */ MISMATCH; public Severity max(Severity severity) { if (compareTo(severity) < 0) return severity; return this; } public boolean isAnyMismatch() { return compareTo(LEGACY_WARNING) > 0; } } private final Severity severity; /** If non-null this field holds the supertype of the provided type which was used for direct matching. */ public final TypeBinding superTypeHint; public final int nullStatus; NullAnnotationMatching(Severity severity, int nullStatus, TypeBinding superTypeHint) { this.severity = severity; this.superTypeHint = superTypeHint; this.nullStatus = nullStatus; } public boolean isAnyMismatch() { return this.severity.isAnyMismatch(); } public boolean isUnchecked() { return this.severity == Severity.UNCHECKED; } public boolean isDefiniteMismatch() { return this.severity == Severity.MISMATCH; } public boolean wantToReport() { return this.severity == Severity.LEGACY_WARNING; } public boolean isPotentiallyNullMismatch() { return !isDefiniteMismatch() && this.nullStatus != -1 && (this.nullStatus & FlowInfo.POTENTIALLY_NULL) != 0; } public String superTypeHintName(CompilerOptions options, boolean shortNames) { return String.valueOf(this.superTypeHint.nullAnnotatedReadableName(options, shortNames)); } /** Check null-ness of 'var' against a possible null annotation */ public static int checkAssignment(BlockScope currentScope, FlowContext flowContext, VariableBinding var, FlowInfo flowInfo, int nullStatus, Expression expression, TypeBinding providedType) { if (providedType == null) return FlowInfo.UNKNOWN; // assume we already reported an error long lhsTagBits = 0L; boolean hasReported = false; boolean usesNullTypeAnnotations = currentScope.environment().usesNullTypeAnnotations(); if (!usesNullTypeAnnotations) { lhsTagBits = var.tagBits & TagBits.AnnotationNullMASK; } else { if (expression instanceof ConditionalExpression && expression.isPolyExpression()) { // drill into both branches: ConditionalExpression ce = ((ConditionalExpression) expression); int status1 = NullAnnotationMatching.checkAssignment(currentScope, flowContext, var, flowInfo, ce.ifTrueNullStatus, ce.valueIfTrue, ce.valueIfTrue.resolvedType); int status2 = NullAnnotationMatching.checkAssignment(currentScope, flowContext, var, flowInfo, ce.ifFalseNullStatus, ce.valueIfFalse, ce.valueIfFalse.resolvedType); if (status1 == status2) return status1; return nullStatus; // if both branches disagree use the precomputed & merged nullStatus } else if (expression instanceof SwitchExpression && expression.isPolyExpression()) { // drill into all the branches: SwitchExpression se = ((SwitchExpression) expression); Expression[] resExprs = se.resultExpressions.toArray(new Expression[0]); Expression re = resExprs[0]; int status0 = NullAnnotationMatching.checkAssignment(currentScope, flowContext, var, flowInfo, re.nullStatus(flowInfo, flowContext), re, re.resolvedType); boolean identicalStatus = true; for (int i = 1, l = resExprs.length; i < l; ++i) { re = resExprs[i]; int otherStatus = NullAnnotationMatching.checkAssignment(currentScope, flowContext, var, flowInfo, re.nullStatus(flowInfo, flowContext), re, re.resolvedType); identicalStatus &= status0 == otherStatus; } return identicalStatus ? status0 : nullStatus; // if not all branches agree use the precomputed & merged nullStatus } lhsTagBits = var.type.tagBits & TagBits.AnnotationNullMASK; NullAnnotationMatching annotationStatus = analyse(var.type, providedType, null, null, nullStatus, expression, CheckMode.COMPATIBLE); if (annotationStatus.isAnyMismatch()) { flowContext.recordNullityMismatch(currentScope, expression, providedType, var.type, flowInfo, nullStatus, annotationStatus); hasReported = true; } else { if (annotationStatus.wantToReport()) annotationStatus.report(currentScope); if (annotationStatus.nullStatus != FlowInfo.UNKNOWN) { return annotationStatus.nullStatus; } } } if (lhsTagBits == TagBits.AnnotationNonNull && nullStatus != FlowInfo.NON_NULL) { if (!hasReported) flowContext.recordNullityMismatch(currentScope, expression, providedType, var.type, flowInfo, nullStatus, null); return FlowInfo.NON_NULL; } else if (lhsTagBits == TagBits.AnnotationNullable && nullStatus == FlowInfo.UNKNOWN) { // provided a legacy type? if (usesNullTypeAnnotations && providedType.isTypeVariable() && (providedType.tagBits & TagBits.AnnotationNullMASK) == 0) return FlowInfo.POTENTIALLY_NULL | FlowInfo.POTENTIALLY_NON_NULL; // -> free type variable can mean either nullable or nonnull return FlowInfo.POTENTIALLY_NULL | FlowInfo.POTENTIALLY_UNKNOWN; // -> combine info from lhs & rhs } return nullStatus; } /** * Find any mismatches between the two given types, which are caused by null type annotations. * @param requiredType * @param providedType * @param nullStatus we are only interested in NULL or NON_NULL, -1 indicates that we are in a recursion, where flow info is ignored * @return a status object representing the severity of mismatching plus optionally a supertype hint */ public static NullAnnotationMatching analyse(TypeBinding requiredType, TypeBinding providedType, int nullStatus) { return analyse(requiredType, providedType, null, null, nullStatus, null, CheckMode.COMPATIBLE); } /** * Find any mismatches between the two given types, which are caused by null type annotations. * @param requiredType * @param providedType * @param providedSubstitute in inheritance situations this maps the providedType into the realm of the subclass, needed for TVB identity checks. * Pass null if not interested in these added checks. * @param substitution TODO * @param nullStatus we are only interested in NULL or NON_NULL, -1 indicates that we are in a recursion, where flow info is ignored * @param providedExpression optionally holds the provided expression of type 'providedType' * @param mode controls the kind of check performed (see {@link CheckMode}). * @return a status object representing the severity of mismatching plus optionally a supertype hint */ public static NullAnnotationMatching analyse(TypeBinding requiredType, TypeBinding providedType, TypeBinding providedSubstitute, Substitution substitution, int nullStatus, Expression providedExpression, CheckMode mode) { if (!requiredType.enterRecursiveFunction()) return NullAnnotationMatching.NULL_ANNOTATIONS_OK; try { Severity severity = Severity.OK; TypeBinding superTypeHint = null; NullAnnotationMatching okStatus = NullAnnotationMatching.NULL_ANNOTATIONS_OK; if (areSameTypes(requiredType, providedType, providedSubstitute)) { if ((requiredType.tagBits & TagBits.AnnotationNonNull) != 0) return okNonNullStatus(providedExpression); return okStatus; } if (requiredType instanceof TypeVariableBinding && substitution != null && (mode == CheckMode.EXACT || mode == CheckMode.COMPATIBLE || mode == CheckMode.BOUND_SUPER_CHECK)) { requiredType.exitRecursiveFunction(); requiredType = Scope.substitute(substitution, requiredType); if (!requiredType.enterRecursiveFunction()) return NullAnnotationMatching.NULL_ANNOTATIONS_OK; if (areSameTypes(requiredType, providedType, providedSubstitute)) { if ((requiredType.tagBits & TagBits.AnnotationNonNull) != 0) return okNonNullStatus(providedExpression); return okStatus; } } if (mode == CheckMode.BOUND_CHECK && requiredType instanceof TypeVariableBinding) { boolean passedBoundCheck = (substitution instanceof ParameterizedTypeBinding) && (((ParameterizedTypeBinding) substitution).tagBits & TagBits.PassedBoundCheck) != 0; if (!passedBoundCheck) { // during bound check against a type variable check the provided type against all upper bounds: TypeBinding superClass = requiredType.superclass(); if (superClass != null && (superClass.hasNullTypeAnnotations() || substitution != null)) { // annotations may enter when substituting a nested type variable NullAnnotationMatching status = analyse(superClass, providedType, null, substitution, nullStatus, providedExpression, CheckMode.BOUND_SUPER_CHECK); severity = severity.max(status.severity); if (severity == Severity.MISMATCH) return new NullAnnotationMatching(severity, nullStatus, superTypeHint); } TypeBinding[] superInterfaces = requiredType.superInterfaces(); if (superInterfaces != null) { for (int i = 0; i < superInterfaces.length; i++) { if (superInterfaces[i].hasNullTypeAnnotations() || substitution != null) { // annotations may enter when substituting a nested type variable NullAnnotationMatching status = analyse(superInterfaces[i], providedType, null, substitution, nullStatus, providedExpression, CheckMode.BOUND_SUPER_CHECK); severity = severity.max(status.severity); if (severity == Severity.MISMATCH) return new NullAnnotationMatching(severity, nullStatus, superTypeHint); } } } } } if (requiredType instanceof ArrayBinding) { long[] requiredDimsTagBits = ((ArrayBinding) requiredType).nullTagBitsPerDimension; if (requiredDimsTagBits != null) { int dims = requiredType.dimensions(); if (requiredType.dimensions() == providedType.dimensions()) { long[] providedDimsTagBits = ((ArrayBinding) providedType).nullTagBitsPerDimension; if (providedDimsTagBits == null) providedDimsTagBits = new long[dims + 1]; // set to unspec'd at all dimensions int currentNullStatus = nullStatus; for (int i = 0; i <= dims; i++) { long requiredBits = validNullTagBits(requiredDimsTagBits[i]); long providedBits = validNullTagBits(providedDimsTagBits[i]); if (i == 0 && requiredBits == TagBits.AnnotationNullable && nullStatus != -1 && mode.requiredNullableMatchesAll()) { // toplevel nullable array: no need to check if (nullStatus == FlowInfo.NULL) break; // null value has no details } else { if (i > 0) currentNullStatus = -1; // don't use beyond the outermost dimension Severity dimSeverity = computeNullProblemSeverity(requiredBits, providedBits, currentNullStatus, i == 0 ? mode : mode.toDetail(), false); if (i > 0 && dimSeverity == Severity.UNCHECKED && providedExpression instanceof ArrayAllocationExpression && providedBits == 0 && requiredBits != 0) { Expression[] dimensions = ((ArrayAllocationExpression) providedExpression).dimensions; Expression previousDim = dimensions[i - 1]; if (previousDim instanceof IntLiteral && previousDim.constant.intValue() == 0) { dimSeverity = Severity.OK; // element of empty dimension matches anything nullStatus = -1; break; } } severity = severity.max(dimSeverity); if (severity == Severity.MISMATCH) { if (nullStatus == FlowInfo.NULL) return new NullAnnotationMatching(severity, nullStatus, null); return NullAnnotationMatching.NULL_ANNOTATIONS_MISMATCH; } } if (severity == Severity.OK) nullStatus = -1; } } else if (providedType.id == TypeIds.T_null) { if (dims > 0 && requiredDimsTagBits[0] == TagBits.AnnotationNonNull) return NullAnnotationMatching.NULL_ANNOTATIONS_MISMATCH; } } } else if (requiredType.hasNullTypeAnnotations() || providedType.hasNullTypeAnnotations() || requiredType.isTypeVariable()) { long requiredBits = requiredNullTagBits(requiredType, mode); if (requiredBits == TagBits.AnnotationNullable && nullStatus != -1 && mode.requiredNullableMatchesAll()) { // at toplevel (having a nullStatus) nullable matches all } else { long providedBits = providedNullTagBits(providedType); Severity s = computeNullProblemSeverity(requiredBits, providedBits, nullStatus, mode, requiredType.isTypeVariable()); if (s.isAnyMismatch() && requiredType.isWildcard() && requiredBits != 0) { if (((WildcardBinding) requiredType).determineNullBitsFromDeclaration(null, null) == 0) { // wildcard has its nullBits from the type variable: avoid redundant warning. s = Severity.OK; } } severity = severity.max(s); if (!severity.isAnyMismatch() && (providedBits & TagBits.AnnotationNullMASK) == TagBits.AnnotationNonNull) okStatus = okNonNullStatus(providedExpression); } if (severity != Severity.MISMATCH && nullStatus != FlowInfo.NULL) { // null value has no details TypeBinding providedSuper = providedType.findSuperTypeOriginatingFrom(requiredType); TypeBinding providedSubstituteSuper = providedSubstitute != null ? providedSubstitute.findSuperTypeOriginatingFrom(requiredType) : null; if (severity == Severity.UNCHECKED && requiredType.isTypeVariable() && providedType.isTypeVariable() && (providedSuper == requiredType || providedSubstituteSuper == requiredType)) { //$IDENTITY-COMPARISON$ severity = Severity.OK; } if (providedSuper != providedType) //$IDENTITY-COMPARISON$ superTypeHint = providedSuper; if (requiredType.isParameterizedType() && providedSuper instanceof ParameterizedTypeBinding) { // TODO(stephan): handle providedType.isRaw() TypeBinding[] requiredArguments = ((ParameterizedTypeBinding) requiredType).arguments; TypeBinding[] providedArguments = ((ParameterizedTypeBinding) providedSuper).arguments; TypeBinding[] providedSubstitutes = (providedSubstituteSuper instanceof ParameterizedTypeBinding) ? ((ParameterizedTypeBinding) providedSubstituteSuper).arguments : null; if (requiredArguments != null && providedArguments != null && requiredArguments.length == providedArguments.length) { for (int i = 0; i < requiredArguments.length; i++) { TypeBinding providedArgSubstitute = providedSubstitutes != null ? providedSubstitutes[i] : null; NullAnnotationMatching status = analyse(requiredArguments[i], providedArguments[i], providedArgSubstitute, substitution, -1, providedExpression, mode.toDetail()); severity = severity.max(status.severity); if (severity == Severity.MISMATCH) return new NullAnnotationMatching(severity, nullStatus, superTypeHint); } } } TypeBinding requiredEnclosing = requiredType.enclosingType(); TypeBinding providedEnclosing = providedType.enclosingType(); if (requiredEnclosing != null && providedEnclosing != null) { TypeBinding providedEnclSubstitute = providedSubstitute != null ? providedSubstitute.enclosingType() : null; NullAnnotationMatching status = analyse(requiredEnclosing, providedEnclosing, providedEnclSubstitute, substitution, -1, providedExpression, mode); severity = severity.max(status.severity); } } } if (!severity.isAnyMismatch()) return okStatus; return new NullAnnotationMatching(severity, nullStatus, superTypeHint); } finally { requiredType.exitRecursiveFunction(); } } public void report(Scope scope) { // nop } public static NullAnnotationMatching okNonNullStatus(final Expression providedExpression) { if (providedExpression instanceof MessageSend) { final MethodBinding method = ((MessageSend) providedExpression).binding; if (method != null && method.isValidBinding()) { MethodBinding originalMethod = method.original(); TypeBinding originalDeclaringClass = originalMethod.declaringClass; if (originalDeclaringClass instanceof BinaryTypeBinding && ((BinaryTypeBinding) originalDeclaringClass).externalAnnotationStatus .isPotentiallyUnannotatedLib() && originalMethod.returnType.isTypeVariable() && (originalMethod.returnType.tagBits & TagBits.AnnotationNullMASK) == 0) { final int severity = ((BinaryTypeBinding) originalDeclaringClass).externalAnnotationStatus == ExternalAnnotationStatus.NO_EEA_FILE ? ProblemSeverities.Warning : ProblemSeverities.Info; // reduce severity if not configured to for external annotations return new NullAnnotationMatching(Severity.LEGACY_WARNING, FlowInfo.UNKNOWN, null) { @Override public void report(Scope scope) { scope.problemReporter().nonNullTypeVariableInUnannotatedBinary(scope.environment(), method, providedExpression, severity); } }; } } } return NullAnnotationMatching.NULL_ANNOTATIONS_OK_NONNULL; } /** Are both types identical wrt the unannotated type and any null type annotations? Only unstructured types and captures are considered. */ protected static boolean areSameTypes(TypeBinding requiredType, TypeBinding providedType, TypeBinding providedSubstitute) { if (requiredType == providedType) //$IDENTITY-COMPARISON$ // short cut for really-really-same types return true; if (requiredType.isParameterizedType() || requiredType.isArrayType()) return false; // not analysing details here if (TypeBinding.notEquals(requiredType, providedType)) { if (requiredType instanceof CaptureBinding) { // when providing exactly the lower bound of the required type we're definitely fine: TypeBinding lowerBound = ((CaptureBinding) requiredType).lowerBound; if (lowerBound != null && areSameTypes(lowerBound, providedType, providedSubstitute)) return (requiredType.tagBits & TagBits.AnnotationNullMASK) == (providedType.tagBits & TagBits.AnnotationNullMASK); } else if (requiredType.kind() == Binding.TYPE_PARAMETER && requiredType == providedSubstitute) { //$IDENTITY-COMPARISON$ return true; } else if (providedType instanceof CaptureBinding) { // when requiring exactly the upper bound of the provided type we're fine, too: TypeBinding upperBound = ((CaptureBinding) providedType).upperBound(); if (upperBound != null && areSameTypes(requiredType, upperBound, providedSubstitute)) return (requiredType.tagBits & TagBits.AnnotationNullMASK) == (providedType.tagBits & TagBits.AnnotationNullMASK); } return false; } return (requiredType.tagBits & TagBits.AnnotationNullMASK) == (providedType.tagBits & TagBits.AnnotationNullMASK); } // interpreting 'type' as a required type, compute the required null bits // we inspect the main type plus bounds of type variables and wildcards static long requiredNullTagBits(TypeBinding type, CheckMode mode) { long tagBits = type.tagBits & TagBits.AnnotationNullMASK; if (tagBits != 0) return validNullTagBits(tagBits); if (type.isWildcard()) { return TagBits.AnnotationNullMASK; } if (type.isTypeVariable()) { // assume we must require @NonNull, unless lower @Nullable bound // (annotation directly on the TV has already been checked above) if (type.isCapture()) { TypeBinding lowerBound = ((CaptureBinding) type).lowerBound; if (lowerBound != null) { tagBits = lowerBound.tagBits & TagBits.AnnotationNullMASK; if (tagBits == TagBits.AnnotationNullable) return TagBits.AnnotationNullable; // type cannot require @NonNull } } switch (mode) { case BOUND_CHECK: // no pessimistic checks during boundcheck (we *have* the instantiation) case BOUND_SUPER_CHECK: case OVERRIDE: // no pessimistic checks during override check (comparing two *declarations*) case OVERRIDE_RETURN: break; default: return TagBits.AnnotationNonNull; // instantiation could require @NonNull } } return 0; } // interpreting 'type' as a provided type, compute the provide null bits // we inspect the main type plus bounds of type variables and wildcards static long providedNullTagBits(TypeBinding type) { long tagBits = type.tagBits & TagBits.AnnotationNullMASK; if (tagBits != 0) return validNullTagBits(tagBits); if (type.isWildcard()) { // wildcard can be 'provided' during inheritance checks return TagBits.AnnotationNullMASK; } if (type.isTypeVariable()) { // incl. captures TypeVariableBinding typeVariable = (TypeVariableBinding) type; boolean haveNullBits = false; if (typeVariable.isCapture()) { TypeBinding lowerBound = ((CaptureBinding) typeVariable).lowerBound; if (lowerBound != null) { tagBits = lowerBound.tagBits & TagBits.AnnotationNullMASK; if (tagBits == TagBits.AnnotationNullable) return TagBits.AnnotationNullable; // cannot be @NonNull haveNullBits |= (tagBits != 0); } } if (typeVariable.firstBound != null) { long boundBits = typeVariable.firstBound.tagBits & TagBits.AnnotationNullMASK; if (boundBits == TagBits.AnnotationNonNull) return TagBits.AnnotationNonNull; // cannot be @Nullable haveNullBits |= (boundBits != 0); } if (haveNullBits) return TagBits.AnnotationNullMASK; // could be either, can only match to a wildcard accepting both } return 0; } /** * Use only if no suitable flowInfo is available. */ public static int nullStatusFromExpressionType(TypeBinding type) { if (type.isFreeTypeVariable()) return FlowInfo.FREE_TYPEVARIABLE; long bits = type.tagBits & TagBits.AnnotationNullMASK; if (bits == 0) return FlowInfo.UNKNOWN; if (bits == TagBits.AnnotationNonNull) return FlowInfo.NON_NULL; return FlowInfo.POTENTIALLY_NON_NULL | FlowInfo.POTENTIALLY_NULL; } public static long validNullTagBits(long bits) { bits &= TagBits.AnnotationNullMASK; return bits == TagBits.AnnotationNullMASK ? 0 : bits; } /** Provided that both types are {@link TypeBinding#equalsEquals}, return the one that is more likely to show null at runtime. */ public static TypeBinding moreDangerousType(TypeBinding one, TypeBinding two) { if (one == null) return null; long oneNullBits = validNullTagBits(one.tagBits); long twoNullBits = validNullTagBits(two.tagBits); if (oneNullBits != twoNullBits) { if (oneNullBits == TagBits.AnnotationNullable) return one; // nullable is dangerous if (twoNullBits == TagBits.AnnotationNullable) return two; // nullable is dangerous // below this point we have unknown vs. nonnull, which is which? if (oneNullBits == 0) return one; // unknown is more dangerous than nonnull return two; // unknown is more dangerous than nonnull } else if (one != two) { //$IDENTITY-COMPARISON$ if (analyse(one, two, -1).isAnyMismatch()) return two; // two doesn't snugly fit into one, so it must be more dangerous } return one; } /** * Evaluate problem severity from the given details: * @param requiredBits null tagBits of the required type * @param providedBits null tagBits of the provided type * @param nullStatus -1 means: don't use, other values see constants in FlowInfo * @param mode check mode (see {@link CheckMode}) * @param requiredIsTypeVariable is the required type a type variable (possibly: "free type variable")? * @return see {@link #severity} for interpretation of values */ private static Severity computeNullProblemSeverity(long requiredBits, long providedBits, int nullStatus, CheckMode mode, boolean requiredIsTypeVariable) { if (requiredBits == providedBits) return Severity.OK; if (requiredBits == 0) { switch (mode) { case COMPATIBLE: case BOUND_CHECK: case BOUND_SUPER_CHECK: case EXACT: return Severity.OK; case OVERRIDE_RETURN: if (providedBits == TagBits.AnnotationNonNull) return Severity.OK; // covariant redefinition to nonnull is good if (!requiredIsTypeVariable) return Severity.OK; // refining an unconstrained non-TVB return to nullable is also legal return Severity.UNCHECKED; case OVERRIDE: return Severity.UNCHECKED; // warn about dropped annotation } } else if (requiredBits == TagBits.AnnotationNullMASK) { return Severity.OK; // OK since LHS accepts either } else if (requiredBits == TagBits.AnnotationNonNull) { switch (mode) { case COMPATIBLE: if (nullStatus == FlowInfo.NULL) return Severity.MISMATCH; // NOK by flow analysis //$FALL-THROUGH$ case BOUND_SUPER_CHECK: if (nullStatus == FlowInfo.NON_NULL) return Severity.OK; // OK by flow analysis //$FALL-THROUGH$ case BOUND_CHECK: case EXACT: case OVERRIDE_RETURN: case OVERRIDE: if (providedBits == 0) return Severity.UNCHECKED; return Severity.MISMATCH; } } else if (requiredBits == TagBits.AnnotationNullable) { switch (mode) { case COMPATIBLE: case OVERRIDE_RETURN: case BOUND_SUPER_CHECK: return Severity.OK; // in these modes everything is compatible to nullable case BOUND_CHECK: case EXACT: if (providedBits == 0) return Severity.UNCHECKED; return Severity.MISMATCH; case OVERRIDE: return Severity.MISMATCH; } } return Severity.OK; // shouldn't get here, requiredBits should be one of the listed cases } static class SearchContradictions extends TypeBindingVisitor { ReferenceBinding typeWithContradiction; @Override public boolean visit(ReferenceBinding referenceBinding) { if ((referenceBinding.tagBits & TagBits.AnnotationNullMASK) == TagBits.AnnotationNullMASK) { this.typeWithContradiction = referenceBinding; return false; } return true; } @Override public boolean visit(TypeVariableBinding typeVariable) { if (!visit((ReferenceBinding) typeVariable)) return false; long allNullBits = typeVariable.tagBits & TagBits.AnnotationNullMASK; if (typeVariable.firstBound != null) allNullBits = typeVariable.firstBound.tagBits & TagBits.AnnotationNullMASK; for (TypeBinding otherBound : typeVariable.otherUpperBounds()) allNullBits |= otherBound.tagBits & TagBits.AnnotationNullMASK; if (allNullBits == TagBits.AnnotationNullMASK) { this.typeWithContradiction = typeVariable; return false; } return true; } @Override public boolean visit(RawTypeBinding rawType) { return visit((ReferenceBinding) rawType); } @Override public boolean visit(WildcardBinding wildcardBinding) { long allNullBits = wildcardBinding.tagBits & TagBits.AnnotationNullMASK; switch (wildcardBinding.boundKind) { case Wildcard.EXTENDS: allNullBits |= wildcardBinding.bound.tagBits & TagBits.AnnotationNonNull; break; case Wildcard.SUPER: allNullBits |= wildcardBinding.bound.tagBits & TagBits.AnnotationNullable; break; } if (allNullBits == TagBits.AnnotationNullMASK) { this.typeWithContradiction = wildcardBinding; return false; } return true; } @Override public boolean visit(ParameterizedTypeBinding parameterizedTypeBinding) { if (!visit((ReferenceBinding) parameterizedTypeBinding)) return false; return super.visit(parameterizedTypeBinding); } } /** * After a method has substituted type parameters, check if this resulted in any contradictory null annotations. * Problems are either reported directly (if scope != null) or by returning a ProblemMethodBinding. */ public static MethodBinding checkForContradictions(MethodBinding method, Object location, Scope scope) { int start = 0, end = 0; if (location instanceof InvocationSite) { start = ((InvocationSite) location).sourceStart(); end = ((InvocationSite) location).sourceEnd(); } else if (location instanceof ASTNode) { start = ((ASTNode) location).sourceStart; end = ((ASTNode) location).sourceEnd; } SearchContradictions searchContradiction = new SearchContradictions(); TypeBindingVisitor.visit(searchContradiction, method.returnType); if (searchContradiction.typeWithContradiction != null) { if (scope == null) return new ProblemMethodBinding(method, method.selector, method.parameters, ProblemReasons.ContradictoryNullAnnotations); scope.problemReporter().contradictoryNullAnnotationsInferred(method, start, end, location instanceof FunctionalExpression); // note: if needed, we might want to update the method by removing the contradictory annotations?? return method; } Expression[] arguments = null; if (location instanceof Invocation) arguments = ((Invocation) location).arguments(); for (int i = 0; i < method.parameters.length; i++) { TypeBindingVisitor.visit(searchContradiction, method.parameters[i]); if (searchContradiction.typeWithContradiction != null) { if (scope == null) return new ProblemMethodBinding(method, method.selector, method.parameters, ProblemReasons.ContradictoryNullAnnotations); if (arguments != null && i < arguments.length) scope.problemReporter().contradictoryNullAnnotationsInferred(method, arguments[i]); else scope.problemReporter().contradictoryNullAnnotationsInferred(method, start, end, location instanceof FunctionalExpression); return method; } } return method; } public static boolean hasContradictions(TypeBinding type) { SearchContradictions searchContradiction = new SearchContradictions(); TypeBindingVisitor.visit(searchContradiction, type); return searchContradiction.typeWithContradiction != null; } public static TypeBinding strongerType(TypeBinding type1, TypeBinding type2, LookupEnvironment environment) { if ((type1.tagBits & TagBits.AnnotationNonNull) != 0) return mergeTypeAnnotations(type1, type2, true, environment); return mergeTypeAnnotations(type2, type1, true, environment); // don't bother to distinguish unannotated vs. @Nullable, since both can accept null } public static TypeBinding[] weakerTypes(TypeBinding[] parameters1, TypeBinding[] parameters2, LookupEnvironment environment) { TypeBinding[] newParameters = new TypeBinding[parameters1.length]; for (int i = 0; i < newParameters.length; i++) { long tagBits1 = parameters1[i].tagBits; long tagBits2 = parameters2[i].tagBits; if ((tagBits1 & TagBits.AnnotationNullable) != 0) newParameters[i] = mergeTypeAnnotations(parameters1[i], parameters2[i], true, environment); // @Nullable must be preserved else if ((tagBits2 & TagBits.AnnotationNullable) != 0) newParameters[i] = mergeTypeAnnotations(parameters2[i], parameters1[i], true, environment); // @Nullable must be preserved else if ((tagBits1 & TagBits.AnnotationNonNull) == 0) newParameters[i] = mergeTypeAnnotations(parameters1[i], parameters2[i], true, environment); // unannotated must be preserved else newParameters[i] = mergeTypeAnnotations(parameters2[i], parameters1[i], true, environment); // either unannotated, or both are @NonNull } return newParameters; } private static TypeBinding mergeTypeAnnotations(TypeBinding type, TypeBinding otherType, boolean top, LookupEnvironment environment) { TypeBinding mainType = type; if (!top) { // for all but the top level type superimpose other's type annotation onto type AnnotationBinding[] otherAnnotations = otherType.getTypeAnnotations(); if (otherAnnotations != Binding.NO_ANNOTATIONS) mainType = environment.createAnnotatedType(type, otherAnnotations); } if (mainType.isParameterizedType() && otherType.isParameterizedType()) { ParameterizedTypeBinding ptb = (ParameterizedTypeBinding) type, otherPTB = (ParameterizedTypeBinding) otherType; TypeBinding[] typeArguments = ptb.arguments; TypeBinding[] otherTypeArguments = otherPTB.arguments; TypeBinding[] newTypeArguments = new TypeBinding[typeArguments.length]; for (int i = 0; i < typeArguments.length; i++) { newTypeArguments[i] = mergeTypeAnnotations(typeArguments[i], otherTypeArguments[i], false, environment); } return environment.createParameterizedType(ptb.genericType(), newTypeArguments, ptb.enclosingType()); } return mainType; } @SuppressWarnings("nls") @Override public String toString() { if (this == NULL_ANNOTATIONS_OK) return "OK"; if (this == NULL_ANNOTATIONS_MISMATCH) return "MISMATCH"; if (this == NULL_ANNOTATIONS_OK_NONNULL) return "OK NonNull"; if (this == NULL_ANNOTATIONS_UNCHECKED) return "UNCHECKED"; StringBuilder buf = new StringBuilder(); buf.append("Analysis result: severity=" + this.severity); buf.append(" nullStatus=" + this.nullStatus); return buf.toString(); } }