io.github.tanyaofei.guava.common.util.concurrent.ParametricNullness Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of guava Show documentation
Relocate google/guava
The newest version!
/*
 * Copyright (C) 2021 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package io.github.tanyaofei.guava.common.util.concurrent;

import io.github.tanyaofei.guava.common.annotations.GwtCompatible;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Annotates a "top-level" type-variable usage that takes its nullness from the type argument
 * supplied by the user of the class. For example, {@code Multiset.Entry.getElement()} returns
 * {@code @ParametricNullness E}, which means:
 *
 * 
 *   {@code getElement} on a {@code Multiset.Entry<@NonNull String>} returns {@code @NonNull
 *       String}.
 *   
{@code getElement} on a {@code Multiset.Entry<@Nullable String>} returns {@code @Nullable
 *       String}.
 * 
 *
 * This is the same behavior as type-variable usages have to Kotlin and to the Checker Framework.
 * Contrast the method above to:
 *
 * 
 *   methods whose return type is a type variable but which can never return {@code null},
 *       typically because the type forbids nullable type arguments: For example, {@code
 *       ImmutableList.get} returns {@code E}, but that value is never {@code null}. (Accordingly,
 *       {@code ImmutableList} is declared to forbid {@code ImmutableList<@Nullable String>}.)
 *   
methods whose return type is a type variable but which can return {@code null} regardless
 *       of the type argument supplied by the user of the class: For example, {@code
 *       ImmutableMap.get} returns {@code @Nullable E} because the method can return {@code null}
 *       even on an {@code ImmutableMap}.
 * 
 *
 * Consumers of this annotation include:
 *
 * 

 *   Kotlin, for which it makes the type-variable usage (a) a Kotlin platform type when the type
 *       argument is non-nullable and (b) nullable when the type argument is nullable. We use this
 *       to "undo" {@link ElementTypesAreNonnullByDefault}. It is the best we can do for Kotlin
 *       under our current constraints.
 *   
NullAway, which will treat it
 *       identically to {@code Nullable} as of version 0.9.9. To treat it that way before then,
 *       you can set {@code
 *       -XepOpt:NullAway:CustomNullableAnnotations=io.github.tanyaofei.guava.common.base.ParametricNullness,...,io.github.tanyaofei.guava.common.util.concurrent.ParametricNullness},
 *       where the {@code ...} contains the names of all the other {@code ParametricNullness}
 *       annotations in Guava. Or you might prefer to omit Guava from your {@code AnnotatedPackages}
 *       list.
 *   
J2ObjC
 *   
{@code NullPointerTester}, at least in the Android backport (where the type-use annotations
 *       {@code NullPointerTester} would need are not available) and in case of JDK-8202469
 * 
 *
 * This annotation is a temporary hack. We will remove it after we're able to adopt the JSpecify nullness annotations and tools no longer need
 * it.
 */
@GwtCompatible
@Retention(RUNTIME)
@Target({FIELD, METHOD, PARAMETER})
@javax.annotation.meta.TypeQualifierNickname
@javax.annotation.Nonnull(when = javax.annotation.meta.When.UNKNOWN)
@interface ParametricNullness {}