Add Nullable annot and parse annots in parameter position

Author: HarrisL2

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -1159,6 +1159,11 @@ class Definitions {
     "io.reactivex.annotations.NonNull" ::
     "org.jspecify.annotations.NonNull" :: Nil)
 
+  @tu lazy val NullableAnnots: List[ClassSymbol] = getClassesIfDefined(
+    "javax.annotation.Nullable" ::
+    "org.jetbrains.annotations.Nullable" ::
+    "org.jspecify.annotations.Nullable" :: Nil)
+
   // convenient one-parameter method types
   def methOfAny(tp: Type): MethodType = MethodType(List(AnyType), tp)
   def methOfAnyVal(tp: Type): MethodType = MethodType(List(AnyValType), tp)

compiler/src/dotty/tools/dotc/core/ImplicitNullInterop.scala

@@ -76,16 +76,22 @@ object ImplicitNullInterop:
     val skipResultType = sym.isConstructor || hasNotNullAnnot(sym)
     // Don't nullify Given/implicit parameters
     val skipCurrentLevel = sym.isOneOf(GivenOrImplicitVal)
+    // Use OrNull instead of flexible types if symbol is explicitly nullable
+    val explicitlyNullable = hasNullableAnnot(sym)
 
     val map = new ImplicitNullMap(
       javaDefined = sym.is(JavaDefined),
       skipResultType = skipResultType,
-      skipCurrentLevel = skipCurrentLevel)
+      skipCurrentLevel = skipCurrentLevel,
+      explicitlyNullable = explicitlyNullable)
     map(tp)
 
   private def hasNotNullAnnot(sym: Symbol)(using Context): Boolean =
     ctx.definitions.NotNullAnnots.exists(nna => sym.unforcedAnnotation(nna).isDefined)
 
+  private def hasNullableAnnot(sym: Symbol)(using Context): Boolean =
+    ctx.definitions.NullableAnnots.exists(nna => sym.unforcedAnnotation(nna).isDefined)
+
   /** A type map that implements the nullification function on types. Given a Java-sourced type or a type
    *  coming from Scala code compiled without explicit nulls, this adds `| Null` or `FlexibleType` in the
    *  right places to make nullability explicit in a conservative way (without forcing incomplete symbols).
@@ -98,10 +104,15 @@ object ImplicitNullInterop:
   private class ImplicitNullMap(
       val javaDefined: Boolean,
       var skipResultType: Boolean = false,
-      var skipCurrentLevel: Boolean = false
+      var skipCurrentLevel: Boolean = false,
+      var explicitlyNullable: Boolean = false
     )(using Context) extends TypeMap:
 
-    def nullify(tp: Type): Type = if ctx.flexibleTypes then FlexibleType(tp) else OrNull(tp)
+    def nullify(tp: Type): Type =
+      if ctx.flexibleTypes then
+        if explicitlyNullable then OrNull(tp) else FlexibleType(tp)
+      else
+        OrNull(tp)
 
     /** Should we nullify `tp` at the outermost level?
      *  The symbols are still under construction, so we don't have precise information.

compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala

@@ -554,7 +554,7 @@ object JavaParsers {
     def formalParam(): ValDef = {
       val start = in.offset
       if (in.token == FINAL) in.nextToken()
-      annotations()
+      val annots = annotations()
       var t = typ()
       if (in.token == DOTDOTDOT) {
         in.nextToken()
@@ -563,7 +563,7 @@ object JavaParsers {
         }
       }
       atSpan(start, in.offset) {
-        varDecl(Modifiers(Flags.JavaDefined | Flags.Param), t, ident().toTermName)
+        varDecl(Modifiers(Flags.JavaDefined | Flags.Param, annotations = annots), t, ident().toTermName)
       }
     }
 

tests/explicit-nulls/neg/i21629/J.java

@@ -0,0 +1,55 @@
+package javax.annotation;
+import java.util.*;
+
+public class J {
+
+    private static String getK() {
+        return "k";
+    }
+
+    @Nullable
+    public static final String k = getK();
+
+    @Nullable
+    public static String l = "l";
+
+    @Nullable
+    public final String m = null;
+
+    @Nullable
+    public String n = "n";
+
+    @Nullable
+    public static final String f(int i) {
+        return "f: " + i;
+    }
+
+    @Nullable
+    public static String g(int i) {
+        return "g: " + i;
+    }
+
+    @Nullable
+    public String h(int i) {
+        return "h: " + i;
+    }
+
+    @Nullable
+    public String q(String s) {
+        return "h: " + s;
+    }
+
+    @Nullable
+    public <T> String[] genericf(T a) {
+        String[] as = new String[1];
+        as[0] = "" + a;
+        return as;
+    }
+
+    @Nullable
+    public <T> List<T> genericg(T a) {
+        List<T> as = new ArrayList<T>();
+        as.add(a);
+        return as;
+    }
+}

tests/explicit-nulls/neg/i21629/Nullable.java

@@ -0,0 +1,8 @@
+package javax.annotation;
+
+import java.lang.annotation.*;
+
+// A "fake" Nullable Annotation for jsr305
+@Retention(value = RetentionPolicy.RUNTIME)
+@interface Nullable {
+}

tests/explicit-nulls/neg/i21629/S.scala

@@ -0,0 +1,16 @@
+// Test that Nullable annotations are working in Java files.
+
+import javax.annotation.J
+
+class S_3 {
+  def kk: String = J.k // error
+  def ll: String = J.l // error
+  def mm: String = (new J).m // error
+  def nn: String = (new J).n // error
+  def ff(i: Int): String = J.f(i) // error
+  def gg(i: Int): String = J.g(i) // error
+  def hh(i: Int): String = (new J).h(i) // error
+  def qq(s: String): String | Null = (new J).q(s)
+  def genericff(a: String): Array[String] = (new J).genericf(a) // error
+  def genericgg(a: String): java.util.List[String] = (new J).genericg(a) // error
+}

tests/explicit-nulls/neg/i21629_override/J.java

@@ -0,0 +1,8 @@
+package javax.annotation;
+import java.util.*;
+
+public class J {
+    public String p(@Nullable String nullableString) {
+        return nullableString;
+    }
+}

tests/explicit-nulls/neg/i21629_override/Nullable.java

@@ -0,0 +1,8 @@
+package javax.annotation;
+
+import java.lang.annotation.*;
+
+// A "fake" Nullable Annotation for jsr305
+@Retention(value = RetentionPolicy.RUNTIME)
+@interface Nullable {
+}

tests/explicit-nulls/neg/i21629_override/S.scala

@@ -0,0 +1,7 @@
+// Test that Nullable annotations are working in Java files.
+
+import javax.annotation.J
+
+class S extends J {
+  override def p(s: String): String = ??? // error
+}