Throw JsonSyntaxException instead of raw exceptions in built-in adapters

Gson.fromJson is documented to throw JsonSyntaxException for malformed
input, but four groups of built-in adapters let raw NumberFormatException,
IllegalArgumentException or NullPointerException escape to the caller.
Callers that guard with catch (JsonParseException) do not catch these.

This is the same defect class already fixed for AtomicLongArray in #3038
and currently open for AtomicIntegerArray in #3047 / #3095. In each case
the neighbouring target type already behaves correctly.

- BitSet with a malformed number
- null elements in primitive arrays (int[], double[], char[], ...)
- double/float with a malformed number
- null elements in collections that reject them (TreeSet, ArrayDeque,
  PriorityQueue, EnumSet)

Author: yusmer96-maker

gson/src/main/java/com/google/gson/internal/bind/ArrayTypeAdapter.java

@@ -17,6 +17,7 @@
 package com.google.gson.internal.bind;
 
 import com.google.gson.Gson;
+import com.google.gson.JsonSyntaxException;
 import com.google.gson.TypeAdapter;
 import com.google.gson.TypeAdapterFactory;
 import com.google.gson.internal.GsonTypes;
@@ -69,17 +70,27 @@ public Object read(JsonReader in) throws IOException {
       return null;
     }
 
+    boolean primitiveComponent = componentType.isPrimitive();
     ArrayList<E> list = new ArrayList<>();
     in.beginArray();
     while (in.hasNext()) {
       E instance = componentTypeAdapter.read(in);
+      if (instance == null && primitiveComponent) {
+        // A primitive array cannot hold null; reject it here so that callers see Gson's documented
+        // JsonSyntaxException instead of an IllegalArgumentException from Array.set below.
+        throw new JsonSyntaxException(
+            "null is not a valid value for a "
+                + componentType.getName()
+                + " array element; at path "
+                + in.getPreviousPath());
+      }
       list.add(instance);
     }
     in.endArray();
 
     int size = list.size();
     // Have to copy primitives one by one to primitive array
-    if (componentType.isPrimitive()) {
+    if (primitiveComponent) {
       Object array = Array.newInstance(componentType, size);
       for (int i = 0; i < size; i++) {
         Array.set(array, i, list.get(i));

gson/src/main/java/com/google/gson/internal/bind/CollectionTypeAdapterFactory.java

@@ -17,6 +17,7 @@
 package com.google.gson.internal.bind;
 
 import com.google.gson.Gson;
+import com.google.gson.JsonSyntaxException;
 import com.google.gson.TypeAdapter;
 import com.google.gson.TypeAdapterFactory;
 import com.google.gson.internal.ConstructorConstructor;
@@ -82,7 +83,24 @@ public Collection<E> read(JsonReader in) throws IOException {
       in.beginArray();
       while (in.hasNext()) {
         E instance = elementTypeAdapter.read(in);
-        collection.add(instance);
+        if (instance == null) {
+          // Most collections accept null, but some (TreeSet, ArrayDeque, PriorityQueue, EnumSet...)
+          // reject it with a NullPointerException. Surface that as Gson's documented
+          // JsonSyntaxException. Only the null case is wrapped, so a NullPointerException from
+          // anywhere else is not masked.
+          try {
+            collection.add(null);
+          } catch (NullPointerException e) {
+            throw new JsonSyntaxException(
+                "null is not a valid element for "
+                    + collection.getClass().getName()
+                    + "; at path "
+                    + in.getPreviousPath(),
+                e);
+          }
+        } else {
+          collection.add(instance);
+        }
       }
       in.endArray();
       return collection;

gson/src/main/java/com/google/gson/internal/bind/TypeAdapters.java

@@ -102,7 +102,14 @@ public BitSet read(JsonReader in) throws IOException {
             switch (tokenType) {
               case NUMBER:
               case STRING:
-                int intValue = in.nextInt();
+                int intValue;
+                try {
+                  intValue = in.nextInt();
+                } catch (NumberFormatException e) {
+                  // Match the other adapters: malformed numbers must surface as Gson's documented
+                  // JsonSyntaxException, not as a raw NumberFormatException.
+                  throw new JsonSyntaxException(e);
+                }
                 if (intValue == 0) {
                   set = false;
                 } else if (intValue == 1) {
@@ -467,7 +474,13 @@ public Float read(JsonReader in) throws IOException {
         in.nextNull();
         return null;
       }
-      return (float) in.nextDouble();
+      try {
+        return (float) in.nextDouble();
+      } catch (NumberFormatException e) {
+        // Consistent with BYTE, SHORT, INTEGER, LONG, BIG_DECIMAL and BIG_INTEGER above: a
+        // malformed number must surface as Gson's documented JsonSyntaxException.
+        throw new JsonSyntaxException(e);
+      }
     }
 
     @Override
@@ -500,7 +513,13 @@ public Double read(JsonReader in) throws IOException {
         in.nextNull();
         return null;
       }
-      return in.nextDouble();
+      try {
+        return in.nextDouble();
+      } catch (NumberFormatException e) {
+        // Consistent with BYTE, SHORT, INTEGER, LONG, BIG_DECIMAL and BIG_INTEGER above: a
+        // malformed number must surface as Gson's documented JsonSyntaxException.
+        throw new JsonSyntaxException(e);
+      }
     }
 
     @Override

gson/src/test/java/com/google/gson/functional/ArrayTest.java

@@ -22,6 +22,7 @@
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonParseException;
+import com.google.gson.JsonSyntaxException;
 import com.google.gson.common.TestTypes.BagOfPrimitives;
 import com.google.gson.common.TestTypes.ClassWithObjects;
 import com.google.gson.reflect.TypeToken;
@@ -294,4 +295,29 @@ public void testArrayElementsAreArrays() {
     assertThat(new Gson().toJson(stringArrays))
         .isEqualTo("[[\"test1\",\"test2\"],[\"test3\",\"test4\"]]");
   }
+
+  @Test
+  public void testPrimitiveArrayWithNullElement() {
+    // A primitive array cannot hold null, so this must be reported as malformed input rather than
+    // as the IllegalArgumentException that Array.set would throw.
+    JsonSyntaxException e =
+        assertThrows(JsonSyntaxException.class, () -> gson.fromJson("[1,null]", int[].class));
+    assertThat(e)
+        .hasMessageThat()
+        .isEqualTo("null is not a valid value for a int array element; at path $[1]");
+
+    e = assertThrows(JsonSyntaxException.class, () -> gson.fromJson("[null]", double[].class));
+    assertThat(e)
+        .hasMessageThat()
+        .isEqualTo("null is not a valid value for a double array element; at path $[0]");
+
+    e = assertThrows(JsonSyntaxException.class, () -> gson.fromJson("[[null]]", int[][].class));
+    assertThat(e)
+        .hasMessageThat()
+        .isEqualTo("null is not a valid value for a int array element; at path $[0][0]");
+
+    // Arrays of reference types still accept null.
+    assertThat(gson.fromJson("[1,null]", Integer[].class)).asList().containsExactly(1, null);
+    assertThat(gson.fromJson("[null]", String[].class)).asList().containsExactly((Object) null);
+  }
 }

gson/src/test/java/com/google/gson/functional/CollectionTest.java

@@ -27,10 +27,12 @@
 import com.google.gson.JsonPrimitive;
 import com.google.gson.JsonSerializationContext;
 import com.google.gson.JsonSerializer;
+import com.google.gson.JsonSyntaxException;
 import com.google.gson.common.TestTypes.BagOfPrimitives;
 import com.google.gson.reflect.TypeToken;
 import java.lang.reflect.Type;
 import java.util.AbstractCollection;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -44,6 +46,7 @@
 import java.util.Queue;
 import java.util.Set;
 import java.util.Stack;
+import java.util.TreeSet;
 import java.util.Vector;
 import org.junit.Before;
 import org.junit.Test;
@@ -501,4 +504,29 @@ public void testIssue1107() {
     assertThat(small).isNotNull();
     assertThat(small.inSmall).isEqualTo("hello");
   }
+
+  @Test
+  public void testCollectionRejectingNullElement() {
+    // TreeSet, ArrayDeque and PriorityQueue throw NullPointerException from add(null); that must be
+    // reported as malformed input instead of escaping to the caller.
+    TypeToken<TreeSet<String>> treeSetType = new TypeToken<TreeSet<String>>() {};
+    TypeToken<ArrayDeque<String>> dequeType = new TypeToken<ArrayDeque<String>>() {};
+    TypeToken<PriorityQueue<String>> queueType = new TypeToken<PriorityQueue<String>>() {};
+    TypeToken<List<String>> listType = new TypeToken<List<String>>() {};
+
+    JsonSyntaxException e =
+        assertThrows(JsonSyntaxException.class, () -> gson.fromJson("[null]", treeSetType));
+    assertThat(e)
+        .hasMessageThat()
+        .isEqualTo("null is not a valid element for java.util.TreeSet; at path $[0]");
+
+    assertThrows(JsonSyntaxException.class, () -> gson.fromJson("[null]", dequeType));
+    assertThrows(JsonSyntaxException.class, () -> gson.fromJson("[null]", queueType));
+
+    // Collections that do accept null are unaffected.
+    assertThat(gson.<List<String>>fromJson("[null]", listType)).containsExactly((String) null);
+    assertThat(gson.<TreeSet<String>>fromJson("[\"b\",\"a\"]", treeSetType))
+        .containsExactly("a", "b")
+        .inOrder();
+  }
 }

gson/src/test/java/com/google/gson/functional/DefaultTypeAdaptersTest.java

@@ -432,6 +432,15 @@ public void testBitSetDeserialization() {
     assertThat(exception)
         .hasMessageThat()
         .isEqualTo("Invalid bitset value 2, expected 0 or 1; at path $[1]");
+
+    // A malformed number must not escape as a raw NumberFormatException.
+    exception =
+        assertThrows(JsonSyntaxException.class, () -> gson.fromJson("[\"0AA\"]", BitSet.class));
+    assertThat(exception)
+        .hasMessageThat()
+        .isEqualTo(
+            "java.lang.NumberFormatException: Expected an int but was 0AA at line 1 column 7"
+                + " path $[0]");
   }
 
   @Test

gson/src/test/java/com/google/gson/functional/PrimitiveTest.java

@@ -969,4 +969,26 @@ public void testStringsAsBooleans() {
     List<Boolean> deserialized = gson.fromJson(json, new TypeToken<List<Boolean>>() {});
     assertThat(deserialized).isEqualTo(Arrays.asList(true, false, true, false, false));
   }
+
+  @Test
+  public void testDoubleAndFloatDeserializationMalformed() {
+    // Consistent with byte, short, int, long, BigDecimal and BigInteger, which already wrap the
+    // NumberFormatException from JsonReader into a JsonSyntaxException.
+    JsonSyntaxException e =
+        assertThrows(JsonSyntaxException.class, () -> gson.fromJson("\"0AA\"", double.class));
+    assertThat(e)
+        .hasMessageThat()
+        .isEqualTo(
+            "java.lang.NumberFormatException: Expected a double but was 0AA at line 1 column 6"
+                + " path $");
+
+    assertThrows(JsonSyntaxException.class, () -> gson.fromJson("\"0AA\"", float.class));
+    assertThrows(JsonSyntaxException.class, () -> gson.fromJson("\"0AA\"", Double.class));
+
+    // Well-formed values keep working, including the special ones.
+    assertThat(gson.fromJson("1.5", double.class)).isEqualTo(1.5);
+    assertThat(gson.fromJson("\"1.5\"", double.class)).isEqualTo(1.5);
+    assertThat(gson.fromJson("1e3", double.class)).isEqualTo(1000.0);
+    assertThat(gson.fromJson("NaN", double.class)).isNaN();
+  }
 }