Emit a checkNotNull method in all generated factories instead of packaging a runtime dependency for one method.

Fixes https://github.com/google/auto/issues/436

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=154474844

21 files changed, 296 insertions, 134 deletions

diff --git a/factory/src/main/java/com/google/auto/factory/internal/Preconditions.java b/factory/src/main/java/com/google/auto/factory/internal/Preconditions.java
deleted file mode 100644
index 514d1b04..00000000
--- a/factory/src/main/java/com/google/auto/factory/internal/Preconditions.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (C) 2016 Google, Inc.
- *
- * 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 com.google.auto.factory.internal;
-
-/**
- * An adaptation of Guava's {@code com.google.common.base.Preconditions} that is specially tailored
- * to support checks applied in AutoFactory's generated code.
- */
-public final class Preconditions {
-
-  /**
-   * Ensures that an object reference passed as a parameter to the calling method is not null.
-   *
-   * @param reference an object reference
-   * @param argumentIndex the index of the argument for the {@link
-   *     com.google.auto.factory.AutoFactory} method which is being checked.
-   * @return the non-null reference that was validated
-   * @throws NullPointerException if {@code reference} is null
-   */
-  public static <T> T checkNotNull(T reference, int argumentIndex) {
-    if (reference == null) {
-      throw new NullPointerException(
-          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
-              + argumentIndex);
-    }
-    return reference;
-  }
-
-  private Preconditions() {}
-}
diff --git a/factory/src/main/java/com/google/auto/factory/processor/FactoryWriter.java b/factory/src/main/java/com/google/auto/factory/processor/FactoryWriter.java
index dfebab2a..6efea39d 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/FactoryWriter.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/FactoryWriter.java
@@ -22,8 +22,8 @@ import static com.squareup.javapoet.TypeSpec.classBuilder;
 import static javax.lang.model.element.Modifier.FINAL;
 import static javax.lang.model.element.Modifier.PRIVATE;
 import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
 
-import com.google.auto.factory.internal.Preconditions;
 import com.google.common.base.Function;
 import com.google.common.base.Joiner;
 import com.google.common.collect.FluentIterable;
@@ -37,6 +37,7 @@ import com.squareup.javapoet.MethodSpec;
 import com.squareup.javapoet.ParameterSpec;
 import com.squareup.javapoet.ParameterizedTypeName;
 import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeVariableName;
 import com.squareup.javapoet.TypeSpec;
 import java.io.IOException;
 import java.util.Iterator;
@@ -45,9 +46,7 @@ import javax.annotation.processing.Filer;
 import javax.inject.Inject;
 import javax.inject.Provider;
 import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.type.PrimitiveType;
 import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.SimpleTypeVisitor7;
 
 final class FactoryWriter {
 
@@ -84,6 +83,7 @@ final class FactoryWriter {
     addConstructorAndProviderFields(factory, descriptor);
     addFactoryMethods(factory, descriptor);
     addImplementationMethods(factory, descriptor);
+    addCheckNotNullMethod(factory, descriptor);
 
     JavaFile.builder(getPackage(descriptor.name()), factory.build())
         .skipJavaLangImports(true)
@@ -108,11 +108,7 @@ final class FactoryWriter {
         providerType = providerType.annotated(AnnotationSpec.get(provider.key().qualifier().get()));
       }
       constructor.addParameter(providerType, provider.name());
-      constructor.addStatement(
-          "this.$1L = $2T.checkNotNull($1L, $3L)",
-          provider.name(),
-          Preconditions.class,
-          argumentIndex);
+      constructor.addStatement("this.$1L = checkNotNull($1L, $2L)", provider.name(), argumentIndex);
     }
 
     factory.addMethod(constructor.build());
@@ -139,7 +135,7 @@ final class FactoryWriter {
         CodeBlock argument;
         if (methodDescriptor.passedParameters().contains(parameter)) {
           argument = CodeBlock.of(parameter.name());
-          if (isPrimitive(parameter.type())) {
+          if (parameter.type().getKind().isPrimitive()) {
             checkNotNull = false;
           }
         } else {
@@ -153,8 +149,7 @@ final class FactoryWriter {
           }
         }
         if (checkNotNull) {
-          argument =
-              CodeBlock.of("$T.checkNotNull($L, $L)", Preconditions.class, argument, argumentIndex);
+          argument = CodeBlock.of("checkNotNull($L, $L)", argument, argumentIndex);
         }
         args.add(argument);
         if (parameters.hasNext()) {
@@ -211,6 +206,43 @@ final class FactoryWriter {
     return builder.build();
   }
 
+  private static void addCheckNotNullMethod(
+      TypeSpec.Builder factory, FactoryDescriptor descriptor) {
+    if (shouldGenerateCheckNotNull(descriptor)) {
+      TypeVariableName typeVariable = TypeVariableName.get("T");
+      factory.addMethod(
+          methodBuilder("checkNotNull")
+              .addModifiers(PRIVATE, STATIC)
+              .addTypeVariable(typeVariable)
+              .returns(typeVariable)
+              .addParameter(typeVariable, "reference")
+              .addParameter(TypeName.INT, "argumentIndex")
+              .beginControlFlow("if (reference == null)")
+              .addStatement(
+                  "throw new $T($S + argumentIndex)",
+                  NullPointerException.class,
+                  "@AutoFactory method argument is null but is not marked @Nullable. Argument "
+                      + "index: ")
+              .endControlFlow()
+              .addStatement("return reference")
+              .build());
+    }
+  }
+
+  private static boolean shouldGenerateCheckNotNull(FactoryDescriptor descriptor) {
+    if (!descriptor.providers().isEmpty()) {
+      return true;
+    }
+    for (FactoryMethodDescriptor method : descriptor.methodDescriptors()) {
+      for (Parameter parameter : method.creationParameters()) {
+        if (!parameter.nullable().isPresent() && !parameter.type().getKind().isPrimitive()) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   private static CharSequence getSimpleName(CharSequence fullyQualifiedName) {
     int lastDot = lastIndexOf(fullyQualifiedName, '.');
     return fullyQualifiedName.subSequence(lastDot + 1, fullyQualifiedName.length());
@@ -229,18 +261,4 @@ final class FactoryWriter {
     }
     return -1;
   }
-
-  private static boolean isPrimitive(TypeMirror type) {
-    return type.accept(new SimpleTypeVisitor7<Boolean, Void>(){
-      @Override
-      public Boolean visitPrimitive(PrimitiveType t, Void aVoid) {
-        return true;
-      }
-
-      @Override
-      protected Boolean defaultAction(TypeMirror e, Void aVoid) {
-        return false;
-      }
-    }, null);
-  }
 }
diff --git a/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryProcessorTest.java b/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryProcessorTest.java
index 042f3989..2b49ae5c 100644
--- a/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryProcessorTest.java
+++ b/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryProcessorTest.java
@@ -395,4 +395,12 @@ public class AutoFactoryProcessorTest {
         .and()
         .generatesSources(JavaFileObjects.forResource("expected/SimpleClassVarargsFactory.java"));
   }
+
+  @Test public void onlyPrimitives() {
+    assertThat(JavaFileObjects.forResource("good/OnlyPrimitives.java"))
+        .processedWith(new AutoFactoryProcessor())
+        .compilesWithoutError()
+        .and()
+        .generatesSources(JavaFileObjects.forResource("expected/OnlyPrimitivesFactory.java"));
+  }
 }
diff --git a/factory/src/test/resources/expected/ClassUsingQualifierWithArgsFactory.java b/factory/src/test/resources/expected/ClassUsingQualifierWithArgsFactory.java
index c5b7f2e0..988e7b0b 100644
--- a/factory/src/test/resources/expected/ClassUsingQualifierWithArgsFactory.java
+++ b/factory/src/test/resources/expected/ClassUsingQualifierWithArgsFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -29,11 +28,19 @@ final class ClassUsingQualifierWithArgsFactory {
 
   @Inject ClassUsingQualifierWithArgsFactory(
       @QualifierWithArgs(name="Fred", count=3) Provider<String> providedDepAProvider) {
-    this.providedDepAProvider = Preconditions.checkNotNull(providedDepAProvider, 1);
+    this.providedDepAProvider = checkNotNull(providedDepAProvider, 1);
   }
 
   ClassUsingQualifierWithArgs create() {
-    return new ClassUsingQualifierWithArgs(
-        Preconditions.checkNotNull(providedDepAProvider.get(), 1));
+    return new ClassUsingQualifierWithArgs(checkNotNull(providedDepAProvider.get(), 1));
+  }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
   }
 }
diff --git a/factory/src/test/resources/expected/ConstructorAnnotatedFactory.java b/factory/src/test/resources/expected/ConstructorAnnotatedFactory.java
index 2e4dc801..35aac934 100644
--- a/factory/src/test/resources/expected/ConstructorAnnotatedFactory.java
+++ b/factory/src/test/resources/expected/ConstructorAnnotatedFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -28,7 +27,7 @@ final class ConstructorAnnotatedFactory {
   private final Provider<Object> objProvider;
 
   @Inject ConstructorAnnotatedFactory(Provider<Object> objProvider) {
-    this.objProvider = Preconditions.checkNotNull(objProvider, 1);
+    this.objProvider = checkNotNull(objProvider, 1);
   }
 
   ConstructorAnnotated create() {
@@ -36,14 +35,23 @@ final class ConstructorAnnotatedFactory {
   }
 
   ConstructorAnnotated create(String s) {
-    return new ConstructorAnnotated(Preconditions.checkNotNull(s, 1));
+    return new ConstructorAnnotated(checkNotNull(s, 1));
   }
 
   ConstructorAnnotated create(int i) {
-    return new ConstructorAnnotated(Preconditions.checkNotNull(objProvider.get(), 1), i);
+    return new ConstructorAnnotated(checkNotNull(objProvider.get(), 1), i);
   }
 
   ConstructorAnnotated create(char c) {
-    return new ConstructorAnnotated(Preconditions.checkNotNull(objProvider.get(), 1), c);
+    return new ConstructorAnnotated(checkNotNull(objProvider.get(), 1), c);
+  }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
   }
 }
diff --git a/factory/src/test/resources/expected/ConstructorAnnotatedNonFinalFactory.java b/factory/src/test/resources/expected/ConstructorAnnotatedNonFinalFactory.java
index 305354d7..ba1433cd 100644
--- a/factory/src/test/resources/expected/ConstructorAnnotatedNonFinalFactory.java
+++ b/factory/src/test/resources/expected/ConstructorAnnotatedNonFinalFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -28,7 +27,7 @@ class ConstructorAnnotatedNonFinalFactory {
   private final Provider<Object> objProvider;
 
   @Inject ConstructorAnnotatedNonFinalFactory(Provider<Object> objProvider) {
-    this.objProvider = Preconditions.checkNotNull(objProvider, 1);
+    this.objProvider = checkNotNull(objProvider, 1);
   }
 
   ConstructorAnnotatedNonFinal create() {
@@ -36,14 +35,23 @@ class ConstructorAnnotatedNonFinalFactory {
   }
 
   ConstructorAnnotatedNonFinal create(String s) {
-    return new ConstructorAnnotatedNonFinal(Preconditions.checkNotNull(s, 1));
+    return new ConstructorAnnotatedNonFinal(checkNotNull(s, 1));
   }
 
   ConstructorAnnotatedNonFinal create(int i) {
-    return new ConstructorAnnotatedNonFinal(Preconditions.checkNotNull(objProvider.get(), 1), i);
+    return new ConstructorAnnotatedNonFinal(checkNotNull(objProvider.get(), 1), i);
   }
 
   ConstructorAnnotatedNonFinal create(char c) {
-    return new ConstructorAnnotatedNonFinal(Preconditions.checkNotNull(objProvider.get(), 1), c);
+    return new ConstructorAnnotatedNonFinal(checkNotNull(objProvider.get(), 1), c);
+  }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
   }
 }
diff --git a/factory/src/test/resources/expected/CustomNullableFactory.java b/factory/src/test/resources/expected/CustomNullableFactory.java
index 9004ece6..e00895c3 100644
--- a/factory/src/test/resources/expected/CustomNullableFactory.java
+++ b/factory/src/test/resources/expected/CustomNullableFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -30,10 +29,19 @@ final class CustomNullableFactory {
 
   @Inject
   CustomNullableFactory(Provider<Object> objectProvider) {
-    this.objectProvider = Preconditions.checkNotNull(objectProvider, 1);
+    this.objectProvider = checkNotNull(objectProvider, 1);
   }
 
   CustomNullable create(@CustomNullable.Nullable String string) {
     return new CustomNullable(string, objectProvider.get());
   }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
+  }
 }
diff --git a/factory/src/test/resources/expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java b/factory/src/test/resources/expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java
index 3980a7fc..efc31ef1 100644
--- a/factory/src/test/resources/expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java
+++ b/factory/src/test/resources/expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import java.util.List;
 import javax.annotation.Generated;
 import javax.inject.Inject;
@@ -43,10 +42,19 @@ final class FactoryImplementingCreateMethod_ConcreteClassFactory
   @Override
   public FactoryImplementingCreateMethod.ConcreteClass create(List<Integer> genericWithDifferentArgumentName) {
     return new FactoryImplementingCreateMethod.ConcreteClass(
-        Preconditions.checkNotNull(genericWithDifferentArgumentName, 1));
+        checkNotNull(genericWithDifferentArgumentName, 1));
   }
 
   FactoryImplementingCreateMethod.ConcreteClass create(int a, boolean b) {
     return new FactoryImplementingCreateMethod.ConcreteClass(a, b);
   }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
+  }
 }
diff --git a/factory/src/test/resources/expected/FactoryImplementingGenericInterfaceExtensionFactory.java b/factory/src/test/resources/expected/FactoryImplementingGenericInterfaceExtensionFactory.java
index dcfb0361..0c2d0eeb 100644
--- a/factory/src/test/resources/expected/FactoryImplementingGenericInterfaceExtensionFactory.java
+++ b/factory/src/test/resources/expected/FactoryImplementingGenericInterfaceExtensionFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -29,14 +28,23 @@ final class FactoryImplementingGenericInterfaceExtensionFactory
   private final Provider<String> sProvider;
   @Inject
   FactoryImplementingGenericInterfaceExtensionFactory(Provider<String> sProvider) {
-    this.sProvider = Preconditions.checkNotNull(sProvider, 1);
+    this.sProvider = checkNotNull(sProvider, 1);
   }
   FactoryImplementingGenericInterfaceExtension create(Integer i) {
     return new FactoryImplementingGenericInterfaceExtension(
-        Preconditions.checkNotNull(sProvider.get(), 1), Preconditions.checkNotNull(i, 2));
+        checkNotNull(sProvider.get(), 1), checkNotNull(i, 2));
   }
   @Override
   public FactoryImplementingGenericInterfaceExtension make(Integer arg) {
     return create(arg);
   }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
+  }
 }
diff --git a/factory/src/test/resources/expected/MixedDepsImplementingInterfacesFactory.java b/factory/src/test/resources/expected/MixedDepsImplementingInterfacesFactory.java
index 3ae87d4b..723221d4 100644
--- a/factory/src/test/resources/expected/MixedDepsImplementingInterfacesFactory.java
+++ b/factory/src/test/resources/expected/MixedDepsImplementingInterfacesFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -33,15 +32,15 @@ final class MixedDepsImplementingInterfacesFactory
   private final Provider<String> sProvider;
 
   @Inject MixedDepsImplementingInterfacesFactory(Provider<String> sProvider) {
-    this.sProvider = Preconditions.checkNotNull(sProvider, 1);
+    this.sProvider = checkNotNull(sProvider, 1);
   }
 
   MixedDepsImplementingInterfaces create(int i) {
-    return new MixedDepsImplementingInterfaces(Preconditions.checkNotNull(sProvider.get(), 1), i);
+    return new MixedDepsImplementingInterfaces(checkNotNull(sProvider.get(), 1), i);
   }
 
   MixedDepsImplementingInterfaces create(Object o) {
-    return new MixedDepsImplementingInterfaces(Preconditions.checkNotNull(o, 1));
+    return new MixedDepsImplementingInterfaces(checkNotNull(o, 1));
   }
 
   @Override public MixedDepsImplementingInterfaces fromInt(int i) {
@@ -51,4 +50,13 @@ final class MixedDepsImplementingInterfacesFactory
   @Override public MixedDepsImplementingInterfaces fromObject(Object o) {
     return create(o);
   }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
+  }
 }
diff --git a/factory/src/test/resources/expected/MultipleFactoriesConflictingParameterNamesFactory.java b/factory/src/test/resources/expected/MultipleFactoriesConflictingParameterNamesFactory.java
index be436523..60e64f17 100644
--- a/factory/src/test/resources/expected/MultipleFactoriesConflictingParameterNamesFactory.java
+++ b/factory/src/test/resources/expected/MultipleFactoriesConflictingParameterNamesFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -37,25 +36,34 @@ final class MultipleFactoriesConflictingParameterNamesFactory {
       Provider<Object> java_lang_ObjectProvider,
       @AQualifier Provider<String> stringProvider2,
       @AQualifier Provider<Object> _tests_AQualifier_java_lang_ObjectProvider) {
-    this.stringProvider = Preconditions.checkNotNull(stringProvider, 1);
-    this.java_lang_ObjectProvider = Preconditions.checkNotNull(java_lang_ObjectProvider, 2);
-    this.stringProvider2 = Preconditions.checkNotNull(stringProvider2, 3);
+    this.stringProvider = checkNotNull(stringProvider, 1);
+    this.java_lang_ObjectProvider = checkNotNull(java_lang_ObjectProvider, 2);
+    this.stringProvider2 = checkNotNull(stringProvider2, 3);
     this._tests_AQualifier_java_lang_ObjectProvider =
-        Preconditions.checkNotNull(_tests_AQualifier_java_lang_ObjectProvider, 4);
+        checkNotNull(_tests_AQualifier_java_lang_ObjectProvider, 4);
   }
 
   MultipleFactoriesConflictingParameterNames create(Object unused) {
     return new MultipleFactoriesConflictingParameterNames(
-        Preconditions.checkNotNull(stringProvider.get(), 1),
-        Preconditions.checkNotNull(java_lang_ObjectProvider.get(), 2),
+        checkNotNull(stringProvider.get(), 1),
+        checkNotNull(java_lang_ObjectProvider.get(), 2),
         java_lang_ObjectProvider,
-        Preconditions.checkNotNull(unused, 4));
+        checkNotNull(unused, 4));
   }
 
   MultipleFactoriesConflictingParameterNames create() {
     return new MultipleFactoriesConflictingParameterNames(
-        Preconditions.checkNotNull(stringProvider2.get(), 1),
-        Preconditions.checkNotNull(_tests_AQualifier_java_lang_ObjectProvider.get(), 2),
+        checkNotNull(stringProvider2.get(), 1),
+        checkNotNull(_tests_AQualifier_java_lang_ObjectProvider.get(), 2),
         _tests_AQualifier_java_lang_ObjectProvider);
   }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
+  }
 }
diff --git a/factory/src/test/resources/expected/MultipleProvidedParamsSameKeyFactory.java b/factory/src/test/resources/expected/MultipleProvidedParamsSameKeyFactory.java
index 53021977..a04e5bcf 100644
--- a/factory/src/test/resources/expected/MultipleProvidedParamsSameKeyFactory.java
+++ b/factory/src/test/resources/expected/MultipleProvidedParamsSameKeyFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -29,15 +28,24 @@ final class MultipleProvidedParamsSameKeyFactory {
 
   @Inject
   MultipleProvidedParamsSameKeyFactory(Provider<String> java_lang_StringProvider) {
-    this.java_lang_StringProvider = Preconditions.checkNotNull(java_lang_StringProvider, 1);
+    this.java_lang_StringProvider = checkNotNull(java_lang_StringProvider, 1);
   }
 
   MultipleProvidedParamsSameKey create() {
     return new MultipleProvidedParamsSameKey(
-        Preconditions.checkNotNull(java_lang_StringProvider.get(), 1),
-        Preconditions.checkNotNull(java_lang_StringProvider.get(), 2),
+        checkNotNull(java_lang_StringProvider.get(), 1),
+        checkNotNull(java_lang_StringProvider.get(), 2),
         java_lang_StringProvider.get(),
         java_lang_StringProvider,
         java_lang_StringProvider);
   }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
+  }
 }
diff --git a/factory/src/test/resources/expected/OnlyPrimitivesFactory.java b/factory/src/test/resources/expected/OnlyPrimitivesFactory.java
new file mode 100644
index 00000000..f7321822
--- /dev/null
+++ b/factory/src/test/resources/expected/OnlyPrimitivesFactory.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2017 Google, Inc.
+ *
+ * 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 tests;
+
+import javax.annotation.Generated;
+import javax.inject.Inject;
+
+@Generated(
+  value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+  comments = "https://github.com/google/auto/tree/master/factory"
+  )
+final class OnlyPrimitivesFactory {
+  @Inject OnlyPrimitivesFactory() {}
+
+  OnlyPrimitives create(int i, long l) {
+    return new OnlyPrimitives(i, l);
+  }
+}
diff --git a/factory/src/test/resources/expected/ProviderArgumentToCreateMethodFactory.java b/factory/src/test/resources/expected/ProviderArgumentToCreateMethodFactory.java
index 0a46fe3f..d04d7ac9 100644
--- a/factory/src/test/resources/expected/ProviderArgumentToCreateMethodFactory.java
+++ b/factory/src/test/resources/expected/ProviderArgumentToCreateMethodFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -29,11 +28,20 @@ final class ProviderArgumentToCreateMethodFactory
   @Inject ProviderArgumentToCreateMethodFactory() {}
 
   ProviderArgumentToCreateMethod create(Provider<String> stringProvider) {
-    return new ProviderArgumentToCreateMethod(Preconditions.checkNotNull(stringProvider, 1));
+    return new ProviderArgumentToCreateMethod(checkNotNull(stringProvider, 1));
   }
 
   @Override
   public ProviderArgumentToCreateMethod newInstance(Provider<String> stringProvider) {
     return create(stringProvider);
   }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
+  }
 }
diff --git a/factory/src/test/resources/expected/SimpleClassMixedDepsFactory.java b/factory/src/test/resources/expected/SimpleClassMixedDepsFactory.java
index a76c5bb1..4aa772be 100644
--- a/factory/src/test/resources/expected/SimpleClassMixedDepsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassMixedDepsFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -29,12 +28,20 @@ final class SimpleClassMixedDepsFactory {
 
   @Inject SimpleClassMixedDepsFactory(
       @AQualifier Provider<String> providedDepAProvider) {
-    this.providedDepAProvider = Preconditions.checkNotNull(providedDepAProvider, 1);
+    this.providedDepAProvider = checkNotNull(providedDepAProvider, 1);
   }
 
   SimpleClassMixedDeps create(String depB) {
     return new SimpleClassMixedDeps(
-        Preconditions.checkNotNull(providedDepAProvider.get(), 1),
-        Preconditions.checkNotNull(depB, 2));
+        checkNotNull(providedDepAProvider.get(), 1), checkNotNull(depB, 2));
+  }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
   }
 }
diff --git a/factory/src/test/resources/expected/SimpleClassNullableParametersFactory.java b/factory/src/test/resources/expected/SimpleClassNullableParametersFactory.java
index f6086320..f01fc655 100644
--- a/factory/src/test/resources/expected/SimpleClassNullableParametersFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassNullableParametersFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.annotation.Nullable;
 import javax.inject.Inject;
@@ -34,9 +33,8 @@ final class SimpleClassNullableParametersFactory {
   SimpleClassNullableParametersFactory(
       Provider<String> providedNullableProvider,
       @BQualifier Provider<String> providedQualifiedNullableProvider) {
-    this.providedNullableProvider = Preconditions.checkNotNull(providedNullableProvider, 1);
-    this.providedQualifiedNullableProvider =
-        Preconditions.checkNotNull(providedQualifiedNullableProvider, 2);
+    this.providedNullableProvider = checkNotNull(providedNullableProvider, 1);
+    this.providedQualifiedNullableProvider = checkNotNull(providedQualifiedNullableProvider, 2);
   }
 
   SimpleClassNullableParameters create(
@@ -47,4 +45,13 @@ final class SimpleClassNullableParametersFactory {
         providedNullableProvider.get(),
         providedQualifiedNullableProvider.get());
   }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
+  }
 }
diff --git a/factory/src/test/resources/expected/SimpleClassPassedDepsFactory.java b/factory/src/test/resources/expected/SimpleClassPassedDepsFactory.java
index dd495343..70c57f1e 100644
--- a/factory/src/test/resources/expected/SimpleClassPassedDepsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassPassedDepsFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 
@@ -27,7 +26,15 @@ final class SimpleClassPassedDepsFactory {
   @Inject SimpleClassPassedDepsFactory() {}
 
   SimpleClassPassedDeps create(String depA, String depB) {
-    return new SimpleClassPassedDeps(
-        Preconditions.checkNotNull(depA, 1), Preconditions.checkNotNull(depB, 2));
+    return new SimpleClassPassedDeps(checkNotNull(depA, 1), checkNotNull(depB, 2));
+  }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
   }
 }
diff --git a/factory/src/test/resources/expected/SimpleClassProvidedDepsFactory.java b/factory/src/test/resources/expected/SimpleClassProvidedDepsFactory.java
index b1e60ffb..e52e8ff1 100644
--- a/factory/src/test/resources/expected/SimpleClassProvidedDepsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassProvidedDepsFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -36,17 +35,26 @@ final class SimpleClassProvidedDepsFactory {
       @BQualifier Provider<Integer> providedPrimitiveBProvider,
       @AQualifier Provider<String> providedDepAProvider,
       @BQualifier Provider<String> providedDepBProvider) {
-    this.providedPrimitiveAProvider = Preconditions.checkNotNull(providedPrimitiveAProvider, 1);
-    this.providedPrimitiveBProvider = Preconditions.checkNotNull(providedPrimitiveBProvider, 2);
-    this.providedDepAProvider = Preconditions.checkNotNull(providedDepAProvider, 3);
-    this.providedDepBProvider = Preconditions.checkNotNull(providedDepBProvider, 4);
+    this.providedPrimitiveAProvider = checkNotNull(providedPrimitiveAProvider, 1);
+    this.providedPrimitiveBProvider = checkNotNull(providedPrimitiveBProvider, 2);
+    this.providedDepAProvider = checkNotNull(providedDepAProvider, 3);
+    this.providedDepBProvider = checkNotNull(providedDepBProvider, 4);
   }
 
   SimpleClassProvidedDeps create() {
     return new SimpleClassProvidedDeps(
-        Preconditions.checkNotNull(providedPrimitiveAProvider.get(), 1),
-        Preconditions.checkNotNull(providedPrimitiveBProvider.get(), 2),
-        Preconditions.checkNotNull(providedDepAProvider.get(), 3),
-        Preconditions.checkNotNull(providedDepBProvider.get(), 4));
+        checkNotNull(providedPrimitiveAProvider.get(), 1),
+        checkNotNull(providedPrimitiveBProvider.get(), 2),
+        checkNotNull(providedDepAProvider.get(), 3),
+        checkNotNull(providedDepBProvider.get(), 4));
+  }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
   }
 }
diff --git a/factory/src/test/resources/expected/SimpleClassProvidedProviderDepsFactory.java b/factory/src/test/resources/expected/SimpleClassProvidedProviderDepsFactory.java
index 0e6d46ee..e49cce32 100644
--- a/factory/src/test/resources/expected/SimpleClassProvidedProviderDepsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassProvidedProviderDepsFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -32,11 +31,20 @@ final class SimpleClassProvidedProviderDepsFactory {
   SimpleClassProvidedProviderDepsFactory(
       @AQualifier Provider<String> providedDepAProvider,
       @BQualifier Provider<String> providedDepBProvider) {
-    this.providedDepAProvider = Preconditions.checkNotNull(providedDepAProvider, 1);
-    this.providedDepBProvider = Preconditions.checkNotNull(providedDepBProvider, 2);
+    this.providedDepAProvider = checkNotNull(providedDepAProvider, 1);
+    this.providedDepBProvider = checkNotNull(providedDepBProvider, 2);
   }
 
   SimpleClassProvidedProviderDeps create() {
     return new SimpleClassProvidedProviderDeps(providedDepAProvider, providedDepBProvider);
   }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
+  }
 }
diff --git a/factory/src/test/resources/expected/SimpleClassVarargsFactory.java b/factory/src/test/resources/expected/SimpleClassVarargsFactory.java
index e8b13161..0b56a1a3 100644
--- a/factory/src/test/resources/expected/SimpleClassVarargsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassVarargsFactory.java
@@ -15,7 +15,6 @@
  */
 package tests;
 
-import com.google.auto.factory.internal.Preconditions;
 import javax.annotation.Generated;
 import javax.inject.Inject;
 
@@ -27,11 +26,20 @@ final class SimpleClassVarargsFactory implements SimpleClassVarargs.InterfaceWit
   @Inject SimpleClassVarargsFactory() {}
 
   SimpleClassVarargs create(String... args) {
-    return new SimpleClassVarargs(Preconditions.checkNotNull(args, 1));
+    return new SimpleClassVarargs(checkNotNull(args, 1));
   }
 
   @Override
   public SimpleClassVarargs build(String... args) {
     return create(args);
   }
+
+  private static <T> T checkNotNull(T reference, int argumentIndex) {
+    if (reference == null) {
+      throw new NullPointerException(
+          "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+              + argumentIndex);
+    }
+    return reference;
+  }
 }
diff --git a/factory/src/test/resources/good/OnlyPrimitives.java b/factory/src/test/resources/good/OnlyPrimitives.java
new file mode 100644
index 00000000..6ed62d76
--- /dev/null
+++ b/factory/src/test/resources/good/OnlyPrimitives.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2017 Google, Inc.
+ *
+ * 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 tests;
+
+import com.google.auto.factory.AutoFactory;
+
+/** @author Ron Shapiro */
+@AutoFactory
+final class OnlyPrimitives {
+  OnlyPrimitives(int i, long l) {}
+}