Adjust styles [ci skip]

* --braces-after-func-def-line
* --dont-cuddle-else
* --procnames-start-lines
* --space-after-for
* --space-after-if
* --space-after-while

array.c

@@ -3074,11 +3074,13 @@ ary_rotate_ptr(VALUE *ptr, long len, long cnt)
         VALUE tmp = *ptr;
         memmove(ptr, ptr + 1, sizeof(VALUE)*(len - 1));
         *(ptr + len - 1) = tmp;
-    } else if (cnt == len - 1) {
+    }
+    else if (cnt == len - 1) {
         VALUE tmp = *(ptr + len - 1);
         memmove(ptr + 1, ptr, sizeof(VALUE)*(len - 1));
         *ptr = tmp;
-    } else {
+    }
+    else {
         --len;
         if (cnt < len) ary_reverse(ptr + cnt, ptr + len);
         if (--cnt > 0) ary_reverse(ptr, ptr + cnt);

compile.c

@@ -2155,7 +2155,8 @@ fix_sp_depth(rb_iseq_t *iseq, LINK_ANCHOR *const anchor)
 			}
 			if (lobj->sp == -1) {
 			    lobj->sp = sp;
-                        } else if (lobj->sp != sp) {
+                        }
+                        else if (lobj->sp != sp) {
                             debugs("%s:%d: sp inconsistency found but ignored (" LABEL_FORMAT " sp: %d, calculated sp: %d)\n",
                                    RSTRING_PTR(rb_iseq_path(iseq)), line,
                                    lobj->label_no, lobj->sp, sp);
@@ -11696,7 +11697,8 @@ ibf_load_object_string(const struct ibf_load *load, const struct ibf_object_head
     VALUE str;
     if (header->frozen && !header->internal) {
         str = rb_enc_interned_str(ptr, len, rb_enc_from_index(encindex));
-    } else {
+    }
+    else {
         str = rb_enc_str_new(ptr, len, rb_enc_from_index(encindex));
 
         if (header->internal) rb_obj_hide(str);

enumerator.c

@@ -2701,7 +2701,8 @@ lazy_with_index_proc(VALUE proc_entry, struct MEMO* result, VALUE memos, long me
 }
 
 static VALUE
-lazy_with_index_size(VALUE proc, VALUE receiver) {
+lazy_with_index_size(VALUE proc, VALUE receiver)
+{
     return receiver;
 }
 
@@ -3144,7 +3145,8 @@ enum_chain_initialize(VALUE obj, VALUE enums)
 }
 
 static VALUE
-new_enum_chain(VALUE enums) {
+new_enum_chain(VALUE enums)
+{
     long i;
     VALUE obj = enum_chain_initialize(enum_chain_allocate(rb_cEnumChain), enums);
 

gc.c

@@ -4955,7 +4955,8 @@ try_move(rb_objspace_t *objspace, rb_heap_t *heap, struct heap_page *sweep_page,
             index = BITMAP_INDEX(heap->compact_cursor_index);
             p = heap->compact_cursor_index;
             GC_ASSERT(cursor == GET_HEAP_PAGE(p));
-        } else {
+        }
+        else {
             index = 0;
             p = cursor->start;
         }
@@ -4967,7 +4968,8 @@ try_move(rb_objspace_t *objspace, rb_heap_t *heap, struct heap_page *sweep_page,
 
         if (index == 0) {
             p = cursor->start + (BITS_BITLENGTH - NUM_IN_PAGE(cursor->start));
-        } else {
+        }
+        else {
             p = cursor->start + (BITS_BITLENGTH - NUM_IN_PAGE(cursor->start)) + (BITS_BITLENGTH * index);
         }
 

include/ruby/internal/core/rbignum.h

@@ -37,13 +37,15 @@ int rb_big_sign(VALUE num);
 RBIMPL_SYMBOL_EXPORT_END()
 
 static inline bool
-RBIGNUM_POSITIVE_P(VALUE b) {
+RBIGNUM_POSITIVE_P(VALUE b)
+{
     RBIMPL_ASSERT_TYPE(b, RUBY_T_BIGNUM);
     return RBIGNUM_SIGN(b);
 }
 
 static inline bool
-RBIGNUM_NEGATIVE_P(VALUE b) {
+RBIGNUM_NEGATIVE_P(VALUE b)
+{
     RBIMPL_ASSERT_TYPE(b, RUBY_T_BIGNUM);
     return ! RBIGNUM_POSITIVE_P(b);
 }

io.c

@@ -1289,7 +1289,8 @@ rb_io_wait(VALUE io, VALUE events, VALUE timeout)
 
     if (ready > 0) {
         return RB_INT2NUM(ready);
-    } else {
+    }
+    else {
         return Qfalse;
     }
 }
@@ -1323,7 +1324,8 @@ rb_io_wait_readable(int f)
             return RTEST(
                 rb_fiber_scheduler_io_wait_readable(scheduler, rb_io_from_fd(f))
             );
-        } else {
+        }
+        else {
             rb_thread_wait_fd(f);
         }
         return TRUE;
@@ -1365,7 +1367,8 @@ rb_io_wait_writable(int f)
             return RTEST(
                 rb_fiber_scheduler_io_wait_writable(scheduler, rb_io_from_fd(f))
             );
-        } else {
+        }
+        else {
             rb_thread_fd_writable(f);
         }
         return TRUE;

memory_view.c

@@ -128,7 +128,8 @@ static const rb_data_type_t memory_view_entry_data_type = {
 
 /* Register memory view functions for the given class */
 bool
-rb_memory_view_register(VALUE klass, const rb_memory_view_entry_t *entry) {
+rb_memory_view_register(VALUE klass, const rb_memory_view_entry_t *entry)
+{
     Check_Type(klass, T_CLASS);
     VALUE entry_obj = rb_ivar_lookup(klass, id_memory_view, Qnil);
     if (! NIL_P(entry_obj)) {
@@ -372,7 +373,8 @@ get_format_size(const char *format, bool *native_p, ssize_t *alignment, endianne
 }
 
 static inline ssize_t
-calculate_padding(ssize_t total, ssize_t alignment_size) {
+calculate_padding(ssize_t total, ssize_t alignment_size)
+{
     if (alignment_size > 1) {
         ssize_t res = total % alignment_size;
         if (res > 0) {

proc.c

@@ -2635,7 +2635,8 @@ umethod_bind_call(int argc, VALUE *argv, VALUE method)
     if (data->me == (const rb_method_entry_t *)cme) {
         vm_passed_block_handler_set(ec, proc_to_block_handler(passed_procval));
         return rb_vm_call_kw(ec, recv, cme->called_id, argc, argv, cme, RB_PASS_CALLED_KEYWORDS);
-    } else {
+    }
+    else {
         VALUE methclass, klass, iclass;
         const rb_method_entry_t *me;
         convert_umethod_to_method_components(data, recv, &methclass, &klass, &iclass, &me);

scheduler.c

@@ -102,7 +102,8 @@ rb_fiber_scheduler_current_for_threadptr(rb_thread_t *thread)
 
     if (thread->blocking == 0) {
         return thread->scheduler;
-    } else {
+    }
+    else {
         return Qnil;
     }
 }

st.c

@@ -841,7 +841,8 @@ find_table_entry_ind(st_table *tab, st_hash_t hash_value, st_data_t key)
 		return REBUILT_TABLE_ENTRY_IND;
 	    if (eq_p)
 		break;
-	} else if (EMPTY_BIN_P(bin))
+	}
+	else if (EMPTY_BIN_P(bin))
             return UNDEFINED_ENTRY_IND;
 #ifdef QUADRATIC_PROBE
 	ind = hash_bin(ind + d, tab);
@@ -886,7 +887,8 @@ find_table_bin_ind(st_table *tab, st_hash_t hash_value, st_data_t key)
 		return REBUILT_TABLE_BIN_IND;
 	    if (eq_p)
 		break;
-	} else if (EMPTY_BIN_P(bin))
+	}
+	else if (EMPTY_BIN_P(bin))
             return UNDEFINED_BIN_IND;
 #ifdef QUADRATIC_PROBE
 	ind = hash_bin(ind + d, tab);

string.c

@@ -3718,7 +3718,8 @@ rb_str_index_m(int argc, VALUE *argv, VALUE str)
 
 	if (rb_reg_search(sub, str, pos, 0) < 0) {
             return Qnil;
-        } else {
+        }
+        else {
             VALUE match = rb_backref_get();
             struct re_registers *regs = RMATCH_REGS(match);
             pos = rb_str_sublen(str, BEG(0));

thread.c

@@ -549,7 +549,8 @@ rb_threadptr_join_list_wakeup(rb_thread_t *thread)
 
         if (target_thread->scheduler != Qnil && rb_fiberptr_blocking(join_list->fiber) == 0) {
             rb_fiber_scheduler_unblock(target_thread->scheduler, target_thread->self, rb_fiberptr_self(join_list->fiber));
-        } else {
+        }
+        else {
             rb_threadptr_interrupt(target_thread);
 
             switch (target_thread->status) {
@@ -820,7 +821,8 @@ thread_start_func_2(rb_thread_t *th, VALUE *stack_start)
 
     if ((state = EC_EXEC_TAG()) == TAG_NONE) {
         SAVE_ROOT_JMPBUF(th, thread_do_start(th));
-    } else {
+    }
+    else {
         errinfo = th->ec->errinfo;
 
         if (state == TAG_FATAL) {
@@ -1182,7 +1184,8 @@ thread_join_sleep(VALUE arg)
 
         if (scheduler != Qnil) {
             rb_fiber_scheduler_block(scheduler, target_th->self, p->timeout);
-        } else if (!limit) {
+        }
+        else if (!limit) {
             th->status = THREAD_STOPPED_FOREVER;
             rb_ractor_sleeper_threads_inc(th->ractor);
             rb_check_deadlock(th->ractor);
@@ -1528,7 +1531,8 @@ rb_thread_sleep_deadly_allow_spurious_wakeup(VALUE blocker)
     VALUE scheduler = rb_fiber_scheduler_current();
     if (scheduler != Qnil) {
         rb_fiber_scheduler_block(scheduler, blocker, Qnil);
-    } else {
+    }
+    else {
         thread_debug("rb_thread_sleep_deadly_allow_spurious_wakeup\n");
         sleep_forever(GET_THREAD(), SLEEP_DEADLOCKABLE);
     }
@@ -4276,7 +4280,8 @@ do_select(VALUE p)
             if (result > 0 && rb_fd_isset(set->sigwait_fd, set->rset)) {
                 result--;
                 (void)check_signals_nogvl(set->th, set->sigwait_fd);
-            } else {
+            }
+            else {
                 (void)check_signals_nogvl(set->th, -1);
             }
         }

thread_sync.c

@@ -195,7 +195,8 @@ rb_mutex_locked_p(VALUE self)
 }
 
 static void
-thread_mutex_insert(rb_thread_t *thread, rb_mutex_t *mutex) {
+thread_mutex_insert(rb_thread_t *thread, rb_mutex_t *mutex)
+{
     if (thread->keeping_mutexes) {
         mutex->next_mutex = thread->keeping_mutexes;
     }
@@ -204,7 +205,8 @@ thread_mutex_insert(rb_thread_t *thread, rb_mutex_t *mutex) {
 }
 
 static void
-thread_mutex_remove(rb_thread_t *thread, rb_mutex_t *mutex) {
+thread_mutex_remove(rb_thread_t *thread, rb_mutex_t *mutex)
+{
     rb_mutex_t **keeping_mutexes = &thread->keeping_mutexes;
 
     while (*keeping_mutexes && *keeping_mutexes != mutex) {
@@ -268,7 +270,9 @@ mutex_owned_p(rb_fiber_t *fiber, rb_mutex_t *mutex)
     }
 }
 
-static VALUE call_rb_fiber_scheduler_block(VALUE mutex) {
+static VALUE
+call_rb_fiber_scheduler_block(VALUE mutex)
+{
     return rb_fiber_scheduler_block(rb_fiber_scheduler_current(), mutex, Qnil);
 }
 

variable.c

@@ -1422,7 +1422,8 @@ init_iv_list(VALUE obj, uint32_t len, uint32_t newsize, st_table *index_tbl)
         MEMCPY(newptr, ptr, VALUE, len);
         RBASIC(obj)->flags &= ~ROBJECT_EMBED;
         ROBJECT(obj)->as.heap.ivptr = newptr;
-    } else {
+    }
+    else {
         newptr = obj_ivar_heap_realloc(obj, len, newsize);
     }
 

vm.c

@@ -1438,7 +1438,8 @@ invoke_block_from_c_proc(rb_execution_context_t *ec, const rb_proc_t *proc,
             }
             if (RHASH_EMPTY_P(keyword_hash)) {
                 argc--;
-            } else {
+            }
+            else {
                 ((VALUE *)argv)[argc-1] = rb_hash_dup(keyword_hash);
             }
         }

vm_backtrace.c

@@ -610,7 +610,8 @@ backtrace_each(const rb_execution_context_t *ec,
                         ignored_frames++;
                     }
                 }
-            } else {
+            }
+            else {
                 /* No ignored frames before start frame, just decrement start */
                 start -= ignored_frames;
             }
@@ -629,7 +630,8 @@ backtrace_each(const rb_execution_context_t *ec,
 	if (cfp->iseq) {
             if (cfp->pc) {
                 iter_iseq(arg, cfp);
-            } else {
+            }
+            else {
                 i--;
             }
 	}
@@ -697,12 +699,14 @@ bt_iter_iseq_skip_internal(void *ptr, const rb_control_frame_t *cfp)
         loc->body.iseq.iseq = cfp->iseq;
         loc->body.iseq.lineno.pc = cfp->pc;
         arg->prev_loc = loc;
-    } else if (arg->prev_cfp) {
+    }
+    else if (arg->prev_cfp) {
         loc->type = LOCATION_TYPE_ISEQ;
         loc->body.iseq.iseq = arg->prev_cfp->iseq;
         loc->body.iseq.lineno.pc = arg->prev_cfp->pc;
         arg->prev_loc = loc;
-    } else {
+    }
+    else {
         rb_bug("No non-internal backtrace entry before an <internal: backtrace entry");
     }
 }
@@ -724,7 +728,8 @@ bt_iter_cfunc(void *ptr, const rb_control_frame_t *cfp, ID mid)
         arg->init_loc->body.iseq.iseq = iseq;
         arg->init_loc->body.iseq.lineno.pc = pc;
         loc->body.cfunc.prev_loc = arg->prev_loc = arg->init_loc;
-    } else {
+    }
+    else {
         loc->body.cfunc.prev_loc = NULL;
     }
 }

vm_method.c

@@ -2048,7 +2048,8 @@ set_method_visibility(VALUE self, int argc, const VALUE *argv, rb_method_visibil
 	for (j = 0; j < RARRAY_LEN(v); j++) {
 	    check_and_export_method(self, RARRAY_AREF(v, j), visi);
 	}
-    } else {
+    }
+    else {
         for (i = 0; i < argc; i++) {
             check_and_export_method(self, argv[i], visi);
         }