Add @NullMarked to dagger package.

java-team-github-bot · Dagger Team · commit 25725828711f · 2025-03-13T05:39:50.000-07:00
RELNOTES=n/a
PiperOrigin-RevId: 736471153
diff --git a/dagger-runtime/main/java/dagger/Lazy.java b/dagger-runtime/main/java/dagger/Lazy.java
@@ -16,18 +16,21 @@
 
 package dagger;
 
+import org.jspecify.annotations.Nullable;
+
 /**
- * A handle to a lazily-computed value. Each {@code Lazy} computes its value on
- * the first call to {@link #get()} and remembers that same value for all
- * subsequent calls to {@code get()}.
+ * A handle to a lazily-computed value. Each {@code Lazy} computes its value on the first call to
+ * {@link #get()} and remembers that same value for all subsequent calls to {@code get()}.
  *
  * <p>All implementations are expected to be thread-safe and compute their value at most once.
  *
  * <h2>Example</h2>
- * The differences between <strong>direct injection</strong>, <strong>provider
- * injection</strong> and <strong>lazy injection</strong> are best demonstrated
- * with an example. Start with a module that computes a different integer for
- * each use:<pre><code>
+ *
+ * The differences between <strong>direct injection</strong>, <strong>provider injection</strong>
+ * and <strong>lazy injection</strong> are best demonstrated with an example. Start with a module
+ * that computes a different integer for each use:
+ *
+ * <pre><code>
  *   {@literal @Module}
  *   final class CounterModule {
  *     int next = 100;
@@ -40,7 +43,10 @@
  * </code></pre>
  *
  * <h3>Direct Injection</h3>
- * This class injects that integer and prints it 3 times:<pre><code>
+ *
+ * This class injects that integer and prints it 3 times:
+ *
+ * <pre><code>
  *   final class DirectCounter {
  *     {@literal @Inject} Integer value;
  *
@@ -52,8 +58,11 @@
  *     }
  *   }
  * </code></pre>
- * Injecting a {@code DirectCounter} and invoking {@code print()} reveals that
- * the value is computed <i>before</i> it is required:<pre><code>
+ *
+ * Injecting a {@code DirectCounter} and invoking {@code print()} reveals that the value is computed
+ * <i>before</i> it is required:
+ *
+ * <pre><code>
  *   computing...
  *   printing...
  *   100
@@ -62,8 +71,10 @@
  * </code></pre>
  *
  * <h3>Provider Injection</h3>
- * This class injects a {@linkplain javax.inject.Provider provider} for the
- * integer. It calls {@code Provider.get()} 3 times and prints each result:
+ *
+ * This class injects a {@linkplain javax.inject.Provider provider} for the integer. It calls {@code
+ * Provider.get()} 3 times and prints each result:
+ *
  * <pre><code>
  *   final class ProviderCounter {
  *     {@literal @Inject Provider<Integer> provider;}
@@ -76,8 +87,11 @@
  *     }
  *   }
  * </code></pre>
- * Injecting a {@code ProviderCounter} and invoking {@code print()} shows that
- * a new value is computed each time {@code Provider.get()} is used:<pre><code>
+ *
+ * Injecting a {@code ProviderCounter} and invoking {@code print()} shows that a new value is
+ * computed each time {@code Provider.get()} is used:
+ *
+ * <pre><code>
  *   printing...
  *   computing...
  *   100
@@ -88,8 +102,11 @@
  * </code></pre>
  *
  * <h3>Lazy Injection</h3>
- * This class injects a {@code Lazy} for the integer. Like the provider above,
- * it calls {@code Lazy.get()} 3 times and prints each result:<pre><code>
+ *
+ * This class injects a {@code Lazy} for the integer. Like the provider above, it calls {@code
+ * Lazy.get()} 3 times and prints each result:
+ *
+ * <pre><code>
  *   final class LazyCounter {
  *     {@literal @Inject Lazy<Integer> lazy;}
  *
@@ -101,9 +118,11 @@
  *     }
  *   }
  * </code></pre>
- * Injecting a {@code LazyCounter} and invoking {@code print()} shows that a new
- * value is computed immediately before it is needed. The same value is returned
- * for all subsequent uses:<pre><code>
+ *
+ * Injecting a {@code LazyCounter} and invoking {@code print()} shows that a new value is computed
+ * immediately before it is needed. The same value is returned for all subsequent uses:
+ *
+ * <pre><code>
  *   printing...
  *   computing...
  *   100
@@ -112,9 +131,11 @@
  * </code></pre>
  *
  * <h3>Lazy != Singleton</h3>
- * Note that each injected {@code Lazy} is independent, and remembers its value
- * in isolation of other {@code Lazy} instances. In this example, two {@code
- * LazyCounter} objects are created and {@code print()} is called on each:
+ *
+ * Note that each injected {@code Lazy} is independent, and remembers its value in isolation of
+ * other {@code Lazy} instances. In this example, two {@code LazyCounter} objects are created and
+ * {@code print()} is called on each:
+ *
  * <pre><code>
  *   final class LazyCounters {
  *     {@literal @Inject} LazyCounter counter1;
@@ -126,7 +147,9 @@
  *     }
  *   }
  * </code></pre>
+ *
  * The output demonstrates that each {@code Lazy} works independently:
+ *
  * <pre><code>
  *   printing...
  *   computing...
@@ -139,10 +162,11 @@
  *   101
  *   101
  * </code></pre>
- * Use {@link javax.inject.Singleton @Singleton} to share one instance among all
- * clients, and {@code Lazy} for lazy computation in a single client.
+ *
+ * Use {@link javax.inject.Singleton @Singleton} to share one instance among all clients, and {@code
+ * Lazy} for lazy computation in a single client.
  */
-public interface Lazy<T> {
+public interface Lazy<T extends @Nullable Object> {
   /**
    * Return the underlying value, computing the value if necessary. All calls to
    * the same {@code Lazy} instance will return the same result.
diff --git a/dagger-runtime/main/java/dagger/MembersInjector.java b/dagger-runtime/main/java/dagger/MembersInjector.java
@@ -16,16 +16,17 @@
 
 package dagger;
 
+import org.jspecify.annotations.Nullable;
+
 /**
  * Injects dependencies into the fields and methods on instances of type {@code T}. Ignores the
  * presence or absence of an injectable constructor.
  *
  * @param <T> type to inject members of
- *
- * @since 2.0 (since 1.0 without the provision that {@link #injectMembers} cannot accept
- *      {@code null})
+ * @since 2.0 (since 1.0 without the provision that {@link #injectMembers} cannot accept {@code
+ *     null})
  */
-public interface MembersInjector<T> {
+public interface MembersInjector<T extends @Nullable Object> {
 
   /**
    * Injects dependencies into the fields and methods of {@code instance}. Ignores the presence or
diff --git a/dagger-runtime/main/java/dagger/package-info.java b/dagger-runtime/main/java/dagger/package-info.java
@@ -30,4 +30,7 @@
  * service loader} to automatically configure the processor, so explict build configuration
  * shouldn't be necessary.
  */
+@NullMarked
 package dagger;
+
+import org.jspecify.annotations.NullMarked;
