import org.eclipse.jdt.annotation.*;

@NonNullByDefault
public class Test {

  public static final String test() {
    final String s = "test".intern();
    return s; // Why do I get a warning here "Null type safety: The expression of type 'String' needs unchecked conversion to conform to '@NonNull String'"?
  }

}

@NonNullByDefault(TYPE_BOUND)
 interface X {
     <T extends Number> void process(T t, List<? super Number> l);
 }

@NonNullByDefault Map<Object, Set<String>> myMap;

Map<@NonNull Object, @NonNull Set<@NonNull String>> myMap;

List<? super Number>

List<? super @NonNull Number>

@NonNullByDefault public <T,R> void exampleMethod(final Function<? super T,? extends R> funcArg) { .. }

import java.io.*;
import java.util.*;
import java.util.function.*;
import org.eclipse.jdt.annotation.*;

@NonNullByDefault
public class Test {

  public static final <T,R> Optional<R> applyOptional(final T input, final Function<? super T,? extends R> function) {
    return Optional.ofNullable(function.apply(input));
  }

  public static final <T,R> @NonNull R applyRequired(final T input, final Function<? super T,? extends R> function) { // Warning on '@NonNull R': "The nullness annotation is redundant with a default that applies to this location"
    return Objects.requireNonNull(function.apply(input));
  }

  public static final @Nullable Integer readIntegerFile(final String fileName) {
    final File file = new File(fileName);
    if (!file.canRead()) return null;
    try (Scanner scanner = new Scanner(new FileReader(fileName))) {
      return scanner.useDelimiter("\\A").hasNext() ? Integer.valueOf(scanner.next()) : null;
    } catch (IOException ioe) {
      throw new UncheckedIOException(ioe);
    }
  }

  public static final void main(final String[] args) {
    if (applyRequired("sun.arch.data.model", Integer::getInteger) >= 64) {
      System.err.println(applyOptional("does_not_matter.txt", Test::readIntegerFile).map(Object::toString).orElse("null"));
    } else {
      System.err.println(applyRequired("we_need_this.txt", Test::readIntegerFile).toString());
    }
    return;
  }

}

interface UniverseWithNull {
     void method1(@Nullable String s);
}
@NonNullByDefault
class UnviserveWithoutNull {
    void methodX(Optional<String> s, UniverseWithNull delegate) {
        delegate(s.isPresent() ? s.get() : null);
    }
}

class Optional<T extends @NonNull Object> {
  @Nullable T value;
  private Optional(T value) { this.value = value; }
  public static <@NonNull T> Optional<T> of(T value) {
    return new Optional<T>(value);
  }
  public T get() {
    @Nullable T t = this.value;
    if (t != null) return t; 
    else throw new NoSuchElementException("No value present");
  }
  public @Nullable T orElse(@Nullable T other) {
    return (this.value != null) ? this.value : other;
  }
}

import java.util.*;
import java.util.function.*;
import org.eclipse.jdt.annotation.*;

public class Test {

  /**
   * A null-annotated version of {@link Objects#requireNonNull(Object)}.
   */
  public static final <T> @NonNull T requireNonNull(final @Nullable T obj) {
    if (obj == null) throw new NullPointerException();
    return obj;
  }

  /**
   * A null-annotated version of {@link Optional#map(Function)}.
   */
  public static final <T,U> @NonNull Optional<U> map(final @NonNull Optional<T> optional, final Function<@NonNull ? super T,? extends U> mapper) {
    if (!optional.isPresent()) return requireNonNull(Optional.empty());
    final T source = optional.get();
    final U result = mapper.apply(source);
    return requireNonNull(Optional.<U> ofNullable(result));
  }

  /**
   * A method with a {@link NonNull} {@link DefaultLocation#PARAMETER} and {@link DefaultLocation#RETURN_TYPE}.
   */
  public static final @NonNull Integer testMethod(final @NonNull String s) {
    final Integer r = Integer.valueOf(s);
    if (r == null) throw new NullPointerException();
    return r;
  }

  public static void main(final String[] args) {
    final @NonNull Optional<@Nullable String> optNullableString = requireNonNull(Optional.ofNullable("-5"));

    final Function<@NonNull String,@NonNull Integer> testMethodRef = Test::testMethod;
    map(optNullableString, testMethodRef);

    map(optNullableString, Test::testMethod); // Error: Null type mismatch at parameter 1: required '@NonNull String' but provided '@Nullable String' via method descriptor Function<String,Integer>.apply(String)
  }

}

@NonNull Optional<@Nullable String> optNullableString

Function<@NonNull ? super @Nullable String, something>

@NonNull Optional<@NonNull String> optNullableString

public static final <T,U> @NonNull Optional<U> map(final @NonNull Optional<T> optional, final Function<? super @NonNull T,? extends U> mapper)

import java.util.*;
import java.util.function.*;
import org.eclipse.jdt.annotation.*;

public final class Optional<T> {
  private static final @NonNull Optional<?> EMPTY = new Optional<>();
  private final @Nullable T value;

  private Optional() {
    this.value = null;
  }

  public static <T> @NonNull Optional<T> empty() {
    @SuppressWarnings("unchecked")
    @NonNull Optional<T> t = (Optional<T>)EMPTY;
    return t;
  }

  private Optional(@NonNull T value) {
    this.value = Objects.requireNonNull(value);
  }

  public static <T> @NonNull Optional<@NonNull T> of(@NonNull T value) {
    return new Optional<@NonNull T>(value);
  }

  public static <T> @NonNull Optional<T> ofNullable(@Nullable T value) {
    return value == null ? empty() : of(value);
  }

  public @NonNull T get() {
    final @Nullable T value = this.value;
    if (value == null) throw new NoSuchElementException("No value present");
    return value;
  }

  public boolean isPresent() {
    return value != null;
  }

  public void ifPresent(@NonNull Consumer<? super @NonNull T> consumer) {
    final @Nullable T value = this.value;
    if (value != null) consumer.accept(value);
  }

  public @NonNull Optional<T> filter(@NonNull Predicate<? super @NonNull T> predicate) {
    Objects.requireNonNull(predicate);
    final @Nullable T value = this.value;
    return (value != null) && predicate.test(value) ? this : empty();
  }

  public <U> @NonNull Optional<U> map(@NonNull Function<? super @NonNull T,? extends U> mapper) {
    Objects.requireNonNull(mapper);
    final @Nullable T value = this.value;
    return (value != null) ? Optional.<U> ofNullable(mapper.apply(value)) : empty();
  }

  public <U> @NonNull Optional<U> flatMap(@NonNull Function<? super @NonNull T,@NonNull Optional<U>> mapper) {
    Objects.requireNonNull(mapper);
    final @Nullable T value = this.value;
    return (value != null) ? Objects.requireNonNull(mapper.apply(value)) : empty();
  }

  public T orElse(T other) {
    final @Nullable T value = this.value;
    return value != null ? value : other;
  }

  public T orElseGet(@NonNull Supplier<? extends T> other) {
    final @Nullable T value = this.value;
    return value != null ? value : other.get();
  }

  public <X extends Throwable> @NonNull T orElseThrow(@NonNull Supplier<? extends @NonNull X> exceptionSupplier) throws X {
    final @Nullable T value = this.value;
    if (value != null) return value;
    throw exceptionSupplier.get();
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    if (this == obj) return true;
    if (!(obj instanceof Optional)) return false;
    return Objects.equals(value, ((Optional<?>)obj).value);
  }

  @Override
  public int hashCode() {
    return Objects.hashCode(value);
  }

  @Override
  public @NonNull String toString() {
    final @Nullable T value = this.value;
    return value != null ? String.format("Optional[%s]", value) : "Optional.empty";
  }

}

import java.util.*;
import java.util.function.*;

import org.eclipse.jdt.annotation.*;

public final class Optional<T extends @NonNull Object> {
  private static final @NonNull Optional<@NonNull ?> EMPTY = new Optional<>();
  private final @Nullable T value;

  private Optional() {
    this.value = null;
  }

  public static <@NonNull T> @NonNull Optional<T> empty() {
    @SuppressWarnings("unchecked")
    @NonNull Optional<T> t = (Optional<T>)EMPTY;
    return t;
  }

  private Optional(T value) {
    this.value = Objects.requireNonNull(value);
  }

  public static <@NonNull T> @NonNull Optional<T> of(T value) {
    return new Optional<T>(value);
  }

  public static <@NonNull T> @NonNull Optional<T> ofNullable(@Nullable T value) {
    return value == null ? empty() : of(value);
  }

  public T get() {
    final @Nullable T value = this.value;
    if (value == null) throw new NoSuchElementException("No value present");
    return value;
  }

  public boolean isPresent() {
    return value != null;
  }

  public void ifPresent(@NonNull Consumer<? super T> consumer) {
    final @Nullable T value = this.value;
    if (value != null) consumer.accept(value);
  }

  public @NonNull Optional<T> filter(@NonNull Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    final @Nullable T value = this.value;
    return (value != null) && predicate.test(value) ? this : empty();
  }

  public <@NonNull U> @NonNull Optional<U> map(@NonNull Function<? super T,? extends U> mapper) {
    Objects.requireNonNull(mapper);
    final @Nullable T value = this.value;
    return (value != null) ? Optional.<U> ofNullable(mapper.apply(value)) : empty();
  }

  public <@NonNull U> @NonNull Optional<U> flatMap(@NonNull Function<? super T,@NonNull Optional<U>> mapper) {
    Objects.requireNonNull(mapper);
    final @Nullable T value = this.value;
    return (value != null) ? Objects.requireNonNull(mapper.apply(value)) : empty();
  }

  public @Nullable T orElse(@Nullable T other) {
    final @Nullable T value = this.value;
    return value != null ? value : other;
  }

  public @Nullable T orElseGet(@NonNull Supplier<? extends @Nullable T> other) {
    final @Nullable T value = this.value;
    return value != null ? value : other.get();
  }

  public <X extends @NonNull Throwable> T orElseThrow(@NonNull Supplier<? extends X> exceptionSupplier) throws X {
    final @Nullable T value = this.value;
    if (value != null) return value;
    throw exceptionSupplier.get();
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    if (this == obj) return true;
    if (!(obj instanceof Optional)) return false;
    return Objects.equals(value, ((Optional<@NonNull ?>)obj).value);
  }

  @Override
  public int hashCode() {
    return Objects.hashCode(value);
  }

  @Override
  public @NonNull String toString() {
    final @Nullable T value = this.value;
    return value != null ? String.format("Optional[%s]", value) : "Optional.empty";
  }

}