[ruby/prism] Fix up clang-analyzer violations

https://github.com/ruby/prism/commit/259aef2acd

2 files changed, 13 insertions, 8 deletions

diff --git a/prism/prism.c b/prism/prism.c
index 695734d0a3..9c489e4785 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -2774,6 +2774,7 @@ pm_call_node_not_create(pm_parser_t *parser, pm_node_t *receiver, pm_token_t *me
     if (arguments->closing_loc.start != NULL) {
         node->base.location.end = arguments->closing_loc.end;
     } else {
+        assert(receiver != NULL);
         node->base.location.end = receiver->location.end;
     }
 
@@ -21229,6 +21230,8 @@ pm_parser_errors_format(const pm_parser_t *parser, const pm_list_t *error_list,
 
         if (inline_messages) {
             pm_buffer_append_byte(buffer, ' ');
+            assert(error->error != NULL);
+
             const char *message = error->error->message;
             pm_buffer_append_string(buffer, message, strlen(message));
         }
diff --git a/prism/util/pm_integer.c b/prism/util/pm_integer.c
index 8f8b75474d..50210f0cb1 100644
--- a/prism/util/pm_integer.c
+++ b/prism/util/pm_integer.c
@@ -172,21 +172,21 @@ karatsuba_multiply(pm_integer_t *destination, pm_integer_t *left, pm_integer_t *
     pm_integer_t y0 = { 0, half, right_values, false };
     pm_integer_t y1 = { 0, right_length - half, right_values + half, false };
 
-    pm_integer_t z0;
+    pm_integer_t z0 = { 0 };
     karatsuba_multiply(&z0, &x0, &y0, base);
 
-    pm_integer_t z2;
+    pm_integer_t z2 = { 0 };
     karatsuba_multiply(&z2, &x1, &y1, base);
 
     // For simplicity to avoid considering negative values,
     // use `z1 = (x0 + x1) * (y0 + y1) - z0 - z2` instead of original karatsuba algorithm.
-    pm_integer_t x01;
+    pm_integer_t x01 = { 0 };
     big_add(&x01, &x0, &x1, base);
 
-    pm_integer_t y01;
+    pm_integer_t y01 = { 0 };
     big_add(&y01, &y0, &y1, base);
 
-    pm_integer_t xy;
+    pm_integer_t xy = { 0 };
     karatsuba_multiply(&xy, &x01, &y01, base);
 
     pm_integer_t z1;
@@ -326,6 +326,8 @@ pm_integer_convert_base(pm_integer_t *destination, const pm_integer_t *source, u
     INTEGER_EXTRACT(source, source_length, source_values)
 
     size_t bigints_length = (source_length + 1) / 2;
+    assert(bigints_length > 0);
+
     pm_integer_t *bigints = (pm_integer_t *) xcalloc(bigints_length, sizeof(pm_integer_t));
     if (bigints == NULL) return;
 
@@ -345,13 +347,13 @@ pm_integer_convert_base(pm_integer_t *destination, const pm_integer_t *source, u
         base = next_base;
 
         size_t next_length = (bigints_length + 1) / 2;
-        pm_integer_t *next_bigints = (pm_integer_t *) xmalloc(sizeof(pm_integer_t) * next_length);
+        pm_integer_t *next_bigints = (pm_integer_t *) xcalloc(next_length, sizeof(pm_integer_t));
 
         for (size_t bigints_index = 0; bigints_index < bigints_length; bigints_index += 2) {
             if (bigints_index + 1 == bigints_length) {
                 next_bigints[bigints_index / 2] = bigints[bigints_index];
             } else {
-                pm_integer_t multiplied;
+                pm_integer_t multiplied = { 0 };
                 karatsuba_multiply(&multiplied, &base, &bigints[bigints_index + 1], base_to);
 
                 big_add(&next_bigints[bigints_index / 2], &bigints[bigints_index], &multiplied, base_to);
@@ -584,7 +586,7 @@ pm_integer_string(pm_buffer_t *buffer, const pm_integer_t *integer) {
     }
 
     // Otherwise, first we'll convert the base from 1<<32 to 10**9.
-    pm_integer_t converted;
+    pm_integer_t converted = { 0 };
     pm_integer_convert_base(&converted, integer, (uint64_t) 1 << 32, 1000000000);
 
     if (converted.values == NULL) {