Merge pull request #2131 from Shopify/designated_initializers

Designated initializers

Author: soutaro

ext/rbs_extension/location.c

@@ -36,9 +36,12 @@ void rbs_loc_alloc_children(rbs_loc *loc, unsigned short cap) {
   size_t s = RBS_LOC_CHILDREN_SIZE(cap);
   loc->children = malloc(s);
 
-  loc->children->len = 0;
-  loc->children->required_p = 0;
-  loc->children->cap = cap;
+  *loc->children = (rbs_loc_children) {
+    .len = 0,
+    .required_p = 0,
+    .cap = cap,
+    .entries = { 0 },
+  };
 }
 
 static void check_children_cap(rbs_loc *loc) {
@@ -54,27 +57,28 @@ static void check_children_cap(rbs_loc *loc) {
 }
 
 void rbs_loc_add_required_child(rbs_loc *loc, ID name, range r) {
-  check_children_cap(loc);
-
-  unsigned short i = loc->children->len++;
-  loc->children->entries[i].name = name;
-  loc->children->entries[i].rg = rbs_new_loc_range(r);
+  rbs_loc_add_optional_child(loc, name, r);
 
-  loc->children->required_p |= 1 << i;
+  unsigned short last_index = loc->children->len - 1;
+  loc->children->required_p |= 1 << last_index;
 }
 
 void rbs_loc_add_optional_child(rbs_loc *loc, ID name, range r) {
   check_children_cap(loc);
 
   unsigned short i = loc->children->len++;
-  loc->children->entries[i].name = name;
-  loc->children->entries[i].rg = rbs_new_loc_range(r);
+  loc->children->entries[i] = (rbs_loc_entry) {
+    .name = name,
+    .rg = rbs_new_loc_range(r),
+  };
 }
 
 void rbs_loc_init(rbs_loc *loc, VALUE buffer, rbs_loc_range rg) {
-  loc->buffer = buffer;
-  loc->rg = rg;
-  loc->children = NULL;
+  *loc = (rbs_loc) {
+    .buffer = buffer,
+    .rg = rg,
+    .children = NULL,
+  };
 }
 
 void rbs_loc_free(rbs_loc *loc) {
@@ -122,9 +126,11 @@ static VALUE location_initialize(VALUE self, VALUE buffer, VALUE start_pos, VALU
   int start = FIX2INT(start_pos);
   int end = FIX2INT(end_pos);
 
-  loc->buffer = buffer;
-  loc->rg.start = start;
-  loc->rg.end = end;
+  *loc = (rbs_loc) {
+    .buffer = buffer,
+    .rg = (rbs_loc_range) { start, end },
+    .children = NULL,
+  };
 
   return Qnil;
 }
@@ -133,8 +139,12 @@ static VALUE location_initialize_copy(VALUE self, VALUE other) {
   rbs_loc *self_loc = rbs_check_location(self);
   rbs_loc *other_loc = rbs_check_location(other);
 
-  self_loc->buffer = other_loc->buffer;
-  self_loc->rg = other_loc->rg;
+  *self_loc = (rbs_loc) {
+    .buffer = other_loc->buffer,
+    .rg = other_loc->rg,
+    .children = NULL,
+  };
+
   if (other_loc->children != NULL) {
     rbs_loc_alloc_children(self_loc, other_loc->children->cap);
     memcpy(self_loc->children, other_loc->children, RBS_LOC_CHILDREN_SIZE(other_loc->children->cap));

ext/rbs_extension/parser.c

@@ -604,13 +604,15 @@ static VALUE parse_optional(parserstate *state) {
 }
 
 static void initialize_method_params(method_params *params){
-  params->required_positionals = EMPTY_ARRAY;
-  params->optional_positionals = EMPTY_ARRAY;
-  params->rest_positionals = Qnil;
-  params->trailing_positionals = EMPTY_ARRAY;
-  params->required_keywords = rb_hash_new();
-  params->optional_keywords = rb_hash_new();
-  params->rest_keywords = Qnil;
+  *params = (method_params) {
+    .required_positionals = EMPTY_ARRAY,
+    .optional_positionals = EMPTY_ARRAY,
+    .rest_positionals = Qnil,
+    .trailing_positionals = EMPTY_ARRAY,
+    .required_keywords = rb_hash_new(),
+    .optional_keywords = rb_hash_new(),
+    .rest_keywords = Qnil,
+  };
 }
 
 /*
@@ -1566,8 +1568,6 @@ static InstanceSingletonKind parse_instance_singleton_kind(parserstate *state, b
       parser_advance(state);
       parser_advance(state);
       kind = SINGLETON_KIND;
-      rg->start = self_range.start;
-      rg->end = state->current_token.range.end;
     } else if (
       state->next_token2.type == pQUESTION
     && state->next_token.range.end.char_pos == state->next_token2.range.start.char_pos
@@ -1577,9 +1577,12 @@ static InstanceSingletonKind parse_instance_singleton_kind(parserstate *state, b
       parser_advance(state);
       parser_advance(state);
       kind = INSTANCE_SINGLETON_KIND;
-      rg->start = self_range.start;
-      rg->end = state->current_token.range.end;
     }
+
+    *rg = (range) {
+      .start = self_range.start,
+      .end = state->current_token.range.end,
+    };
   } else {
     *rg = NULL_RANGE;
   }
@@ -2692,8 +2695,10 @@ static VALUE parse_namespace(parserstate *state, range *rg) {
   bool is_absolute = false;
 
   if (state->next_token.type == pCOLON2) {
-    rg->start = state->next_token.range.start;
-    rg->end = state->next_token.range.end;
+    *rg = (range) {
+      .start = state->next_token.range.start,
+      .end = state->next_token.range.end,
+    };
     is_absolute = true;
 
     parser_advance(state);

ext/rbs_extension/parserstate.c

@@ -4,16 +4,26 @@
 
 id_table *alloc_empty_table(void) {
   id_table *table = malloc(sizeof(id_table));
-  table->size = 10;
-  table->count = 0;
-  table->ids = calloc(10, sizeof(ID));
+
+  *table = (id_table) {
+    .size = 10,
+    .count = 0,
+    .ids = calloc(10, sizeof(ID)),
+    .next = NULL,
+  };
 
   return table;
 }
 
 id_table *alloc_reset_table(void) {
   id_table *table = malloc(sizeof(id_table));
-  table->size = 0;
+
+  *table = (id_table) {
+    .size = 0,
+    .count = 0,
+    .ids = NULL,
+    .next = NULL,
+  };
 
   return table;
 }
@@ -182,15 +192,18 @@ VALUE get_comment(parserstate *state, int subject_line) {
 }
 
 comment *alloc_comment(token comment_token, comment *last_comment) {
-  comment *new_comment = calloc(1, sizeof(comment));
+  comment *new_comment = malloc(sizeof(comment));
 
-  new_comment->next_comment = last_comment;
+  *new_comment = (comment) {
+    .start = comment_token.range.start,
+    .end = comment_token.range.end,
 
-  new_comment->start = comment_token.range.start;
-  new_comment->end = comment_token.range.end;
+    .line_size = 0,
+    .line_count = 0,
+    .tokens = NULL,
 
-  new_comment->line_size = 0;
-  new_comment->line_count = 0;
+    .next_comment = last_comment,
+  };
 
   comment_insert_new_line(new_comment, comment_token);
 
@@ -279,11 +292,25 @@ lexstate *alloc_lexer(VALUE string, int start_pos, int end_pos) {
     rb_raise(rb_eArgError, "negative position range: %d...%d", start_pos, end_pos);
   }
 
-  lexstate *lexer = calloc(1, sizeof(lexstate));
-  lexer->string = string;
-  lexer->current.line = 1;
-  lexer->start_pos = start_pos;
-  lexer->end_pos = end_pos;
+  lexstate *lexer = malloc(sizeof(lexstate));
+
+  position start_position = (position) {
+    .byte_pos = 0,
+    .char_pos = 0,
+    .line = 1,
+    .column = 0,
+  };
+
+  *lexer = (lexstate) {
+    .string = string,
+    .start_pos = start_pos,
+    .end_pos = end_pos,
+    .current = start_position,
+    .start = { 0 },
+    .first_token_of_line = false,
+    .last_char = 0,
+  };
+
   skipn(lexer, start_pos);
   lexer->start = lexer->current;
   lexer->first_token_of_line = lexer->current.column == 0;
@@ -292,13 +319,20 @@ lexstate *alloc_lexer(VALUE string, int start_pos, int end_pos) {
 }
 
 parserstate *alloc_parser(VALUE buffer, lexstate *lexer, int start_pos, int end_pos, VALUE variables) {
-  parserstate *parser = calloc(1, sizeof(parserstate));
-  parser->lexstate = lexer;
-  parser->buffer = buffer;
-  parser->current_token = NullToken;
-  parser->next_token = NullToken;
-  parser->next_token2 = NullToken;
-  parser->next_token3 = NullToken;
+  parserstate *parser = malloc(sizeof(parserstate));
+
+  *parser = (parserstate) {
+    .lexstate = lexer,
+
+    .current_token = NullToken,
+    .next_token = NullToken,
+    .next_token2 = NullToken,
+    .next_token3 = NullToken,
+    .buffer = buffer,
+
+    .vars = NULL,
+    .last_comment = NULL,
+  };
 
   parser_advance(parser);
   parser_advance(parser);