Use a macro to compute the size of arrays at compile time (#18044)

* Add ARRAY_SIZE and CEILING utility macros

* Apply a coccinelle patch to use ARRAY_SIZE

* fix up some straggling items

* Fix 'make test:secure'

* Enhance ARRAY_SIZE macro to reject acting on pointers

The previous definition would not produce a diagnostic for
```
int *p;
size_t num_elem = ARRAY_SIZE(p)
```
but the new one will.

* explicitly get definition of ARRAY_SIZE

* Convert to ARRAY_SIZE when const is involved

The following spatch finds additional instances where the array is
const and the division is by the size of the type, not the size of
the first element:
```
@ rule5a using "empty.iso" @
type T;
const T[] E;
@@

- (sizeof(E)/sizeof(T))
+ ARRAY_SIZE(E)

@ rule6a using "empty.iso" @
type T;
const T[] E;
@@

- sizeof(E)/sizeof(T)
+ ARRAY_SIZE(E)
```

* New instances of ARRAY_SIZE added since initial spatch run

* Use `ARRAY_SIZE` in docs (found by grep)

* Manually use ARRAY_SIZE

hs_set is expected to be the same size as uint16_t, though it's made
of two 8-bit integers

* Just like char, sizeof(uint8_t) is guaranteed to be 1

This is at least true on any plausible system where qmk is actually used.

Per my understanding it's universally true, assuming that uint8_t exists:
https://stackoverflow.com/questions/48655310/can-i-assume-that-sizeofuint8-t-1

* Run qmk-format on core C files touched in this branch

Co-authored-by: Stefan Kerkmann <[email protected]>

docs/feature_combo.md

@@ -255,7 +255,7 @@ bool combo_should_trigger(uint16_t combo_index, combo_t *combo, uint16_t keycode
 ```
 
 ## Variable Length Combos
-If you leave `COMBO_COUNT` undefined in `config.h`, it allows you to programmatically declare the size of the Combo data structure and avoid updating `COMBO_COUNT`. Instead a variable called `COMBO_LEN` has to be set. It can be set with something similar to the following in `keymap.c`: `uint16_t COMBO_LEN = sizeof(key_combos) / sizeof(key_combos[0]);` or by adding `COMBO_LENGTH` as the *last* entry in the combo enum and then `uint16_t COMBO_LEN = COMBO_LENGTH;` as such:
+If you leave `COMBO_COUNT` undefined in `config.h`, it allows you to programmatically declare the size of the Combo data structure and avoid updating `COMBO_COUNT`. Instead a variable called `COMBO_LEN` has to be set. It can be set with something similar to the following in `keymap.c`: `uint16_t COMBO_LEN = ARRAY_SIZE(key_combos);` or by adding `COMBO_LENGTH` as the *last* entry in the combo enum and then `uint16_t COMBO_LEN = COMBO_LENGTH;` as such:
 ```c
 enum myCombos {
     ...,

drivers/haptic/solenoid.c

@@ -20,11 +20,12 @@
 #include "haptic.h"
 #include "gpio.h"
 #include "usb_device_state.h"
+#include "util.h"
 #include <stdlib.h>
 
 uint8_t      solenoid_dwell  = SOLENOID_DEFAULT_DWELL;
 static pin_t solenoid_pads[] = SOLENOID_PINS;
-#define NUMBER_OF_SOLENOIDS (sizeof(solenoid_pads) / sizeof(pin_t))
+#define NUMBER_OF_SOLENOIDS ARRAY_SIZE(solenoid_pads)
 bool     solenoid_on[NUMBER_OF_SOLENOIDS]      = {false};
 bool     solenoid_buzzing[NUMBER_OF_SOLENOIDS] = {false};
 uint16_t solenoid_start[NUMBER_OF_SOLENOIDS]   = {0};
@@ -147,7 +148,7 @@ void solenoid_check(void) {
 void solenoid_setup(void) {
 #ifdef SOLENOID_PINS_ACTIVE_STATE
     bool    state_temp[] = SOLENOID_PINS_ACTIVE_STATE;
-    uint8_t bound_check  = (sizeof(state_temp) / sizeof(bool));
+    uint8_t bound_check  = ARRAY_SIZE(state_temp);
 #endif
 
     for (uint8_t i = 0; i < NUMBER_OF_SOLENOIDS; i++) {

drivers/sensors/pmw33xx_common.c

@@ -17,10 +17,10 @@
 extern const uint8_t pmw33xx_firmware_data[PMW33XX_FIRMWARE_LENGTH] PROGMEM;
 extern const uint8_t pmw33xx_firmware_signature[3] PROGMEM;
 
-static const pin_t cs_pins[]                                 = PMW33XX_CS_PINS;
-static bool        in_burst[sizeof(cs_pins) / sizeof(pin_t)] = {0};
+static const pin_t cs_pins[]                     = PMW33XX_CS_PINS;
+static bool        in_burst[ARRAY_SIZE(cs_pins)] = {0};
 
-const size_t pmw33xx_number_of_sensors = sizeof(cs_pins) / sizeof(pin_t);
+const size_t pmw33xx_number_of_sensors = ARRAY_SIZE(cs_pins);
 
 bool __attribute__((cold)) pmw33xx_upload_firmware(uint8_t sensor);
 bool __attribute__((cold)) pmw33xx_check_signature(uint8_t sensor);

keyboards/25keys/zinc/keymaps/ginjake/keymap.c

@@ -333,7 +333,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
       aqours_num++;
       aqours_next_color_timer_count = 0;
       target_col = 0;
-      if (aqours_num == sizeof(aqours_h) / sizeof(int)) {
+      if (aqours_num == ARRAY_SIZE(aqours_h)) {
         aqours_num = 0;
       }
     }

keyboards/acheron/shark/beta/keymaps/gondolindrim/keymap.c

@@ -94,7 +94,7 @@ encoder_mode_t encoder_modes[] = {
 	// Insert your custom encoder mode here
 };
 
-#define NUM_ENCODER_MODES (sizeof(encoder_modes)/sizeof(encoder_modes[0]))
+#define NUM_ENCODER_MODES ARRAY_SIZE(encoder_modes)
 
 // This counter is used to track what encoder mode is being used at a certain time
 int encoder_mode_count = 0;

keyboards/adafruit/macropad/lib/ssd1306_sh1106.c

@@ -94,8 +94,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #define OLED_ALL_BLOCKS_MASK (((((OLED_BLOCK_TYPE)1 << (OLED_BLOCK_COUNT - 1)) - 1) << 1) | 1)
 
-#define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
-
 // spi defines
 #define OLED_STATUS_SUCCESS SPI_STATUS_SUCCESS
 

keyboards/crkbd/keymaps/gotham/oled.c

@@ -176,7 +176,7 @@ void add_keylog(uint16_t keycode) {
     keylog_str[i] = keylog_str[i - 1];
   }
 
-  if (keycode < (sizeof(code_to_name) / sizeof(char))) {
+  if (keycode < ARRAY_SIZE(code_to_name)) {
     keylog_str[0] = pgm_read_byte(&code_to_name[keycode]);
   }
 }

keyboards/crkbd/keymaps/thunderbird2086/oled.c

@@ -189,7 +189,7 @@ void add_keylog(uint16_t keycode) {
         keylog_str[i] = keylog_str[i - 1];
     }
 
-    if (keycode < (sizeof(code_to_name) / sizeof(char))) {
+    if (keycode < ARRAY_SIZE(code_to_name)) {
         keylog_str[0] = pgm_read_byte(&code_to_name[keycode]);
     }
 }

keyboards/dm9records/plaid/keymaps/brickbots/keymap.c

@@ -242,7 +242,7 @@ layer_state_t layer_state_set_user(layer_state_t state) {
 void led_keypress_update(uint8_t led, uint8_t led_mode, uint16_t keycode, keyrecord_t *record) {
     switch (led_mode) {
       case LEDMODE_MODS:
-        for (int i=0;i<sizeof(modifiers) / sizeof(modifiers[0]);i++) {
+        for (int i=0;i<ARRAY_SIZE(modifiers);i++) {
           if(keycode==modifiers[i]) {
             if (record->event.pressed) {
               writePinHigh(led);

keyboards/dm9records/plaid/keymaps/default/keymap.c

@@ -245,7 +245,7 @@ layer_state_t layer_state_set_user(layer_state_t state) {
 void led_keypress_update(uint8_t led, uint8_t led_mode, uint16_t keycode, keyrecord_t *record) {
     switch (led_mode) {
       case LEDMODE_MODS:
-        for (int i=0;i<sizeof(modifiers) / sizeof(modifiers[0]);i++) {
+        for (int i=0;i<ARRAY_SIZE(modifiers);i++) {
           if(keycode==modifiers[i]) {
             if (record->event.pressed) {
               writePinHigh(led);

keyboards/dm9records/plaid/keymaps/stephen-huan/keymap.c

@@ -184,7 +184,7 @@ layer_state_t layer_state_set_user(layer_state_t state) {
 void led_keypress_update(uint8_t led, uint8_t led_mode, uint16_t keycode, keyrecord_t *record) {
     switch (led_mode) {
       case LEDMODE_MODS:
-        for (int i=0;i<sizeof(modifiers) / sizeof(modifiers[0]);i++) {
+        for (int i=0;i<ARRAY_SIZE(modifiers);i++) {
           if(keycode==modifiers[i]) {
             if (record->event.pressed) {
               writePinHigh(led);

keyboards/dmqdesign/spin/keymaps/spidey3_pad/keymap.c

@@ -111,7 +111,7 @@ const rgblight_segment_t *const PROGMEM _rgb_layers[] = {
 };
 // clang-format off
 
-const uint8_t PROGMEM _n_rgb_layers = sizeof(_rgb_layers) / sizeof(_rgb_layers[0]) - 1;
+const uint8_t PROGMEM _n_rgb_layers = ARRAY_SIZE(_rgb_layers) - 1;
 
 void clear_rgb_layers(void) {
     dprint("clear_rgb_layers()\n");

keyboards/evolv/keymaps/gondolindrim/keymap.c

@@ -129,7 +129,7 @@ const encoder_mode_t encoder_modes[] = {
 	// Insert your custom encoder mode here
 };
 
-#define NUM_ENCODER_MODES (sizeof(encoder_modes)/sizeof(encoder_modes[0])) // DO NOT CHANGE THIS. NUM_ENCODER_MODES calculates how many modes there are.
+#define NUM_ENCODER_MODES ARRAY_SIZE(encoder_modes) // DO NOT CHANGE THIS. NUM_ENCODER_MODES calculates how many modes there are.
 
 // This counter is used to track what encoder mode is being used at a certain time
 int encoder_mode_count = 0;

keyboards/gboards/butterstick/keymaps/default/keymap.c

@@ -180,4 +180,4 @@ uint32_t processQwerty(bool lookup) {
 }
 
 // Don't fuck with this, thanks.
-size_t keymapsCount  = sizeof(keymaps)/sizeof(keymaps[0]);
+size_t keymapsCount  = ARRAY_SIZE(keymaps);

keyboards/gboards/butterstick/sten.c

@@ -21,7 +21,7 @@ uint32_t tChord			= 0;		// Protects state of cChord
 
 #ifndef STENOLAYERS
 uint32_t stenoLayers[] = { PWR };
-size_t 	 stenoLayerCount = sizeof(stenoLayers)/sizeof(stenoLayers[0]);
+size_t 	 stenoLayerCount = ARRAY_SIZE(stenoLayers);
 #endif
 
 // Mode state

keyboards/gboards/engine/keymap_engine.h

@@ -114,8 +114,8 @@ void testCollisions(void) {
 #include "dicts.def"
 
 // Get size data back into the engine
-size_t funcsLen   = sizeof(funDict) / sizeof(funDict[0]);
-size_t stringLen  = sizeof(strDict) / sizeof(strDict[0]);
-size_t keyLen     = sizeof(keyDict) / sizeof(keyDict[0]);
-size_t comboLen   = sizeof(cmbDict) / sizeof(cmbDict[0]);
-size_t specialLen = sizeof(spcDict) / sizeof(spcDict[0]);
+size_t funcsLen   = ARRAY_SIZE(funDict);
+size_t stringLen  = ARRAY_SIZE(strDict);
+size_t keyLen     = ARRAY_SIZE(keyDict);
+size_t comboLen   = ARRAY_SIZE(cmbDict);
+size_t specialLen = ARRAY_SIZE(spcDict);

keyboards/gboards/g/keymap_engine.h

@@ -115,8 +115,8 @@ void testCollisions(void) {
 #include "dicts.def"
 
 // Get size data back into the engine
-size_t funcsLen   = sizeof(funDict) / sizeof(funDict[0]);
-size_t stringLen  = sizeof(strDict) / sizeof(strDict[0]);
-size_t keyLen     = sizeof(keyDict) / sizeof(keyDict[0]);
-size_t comboLen   = sizeof(cmbDict) / sizeof(cmbDict[0]);
-size_t specialLen = sizeof(spcDict) / sizeof(spcDict[0]);
+size_t funcsLen   = ARRAY_SIZE(funDict);
+size_t stringLen  = ARRAY_SIZE(strDict);
+size_t keyLen     = ARRAY_SIZE(keyDict);
+size_t comboLen   = ARRAY_SIZE(cmbDict);
+size_t specialLen = ARRAY_SIZE(spcDict);

keyboards/gboards/georgi/keymaps/colemak-dh/keymap.c

@@ -302,5 +302,5 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 // Don't fuck with this, thanks.
-size_t keymapsCount  = sizeof(keymaps)/sizeof(keymaps[0]);
-size_t stenoLayerCount = sizeof(stenoLayers)/sizeof(stenoLayers[0]);
+size_t keymapsCount  = ARRAY_SIZE(keymaps);
+size_t stenoLayerCount = ARRAY_SIZE(stenoLayers);

keyboards/gboards/georgi/keymaps/default-flipped/keymap.c

@@ -234,4 +234,4 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 // Don't fuck with this, thanks.
-size_t keymapsCount  = sizeof(keymaps)/sizeof(keymaps[0]);
+size_t keymapsCount  = ARRAY_SIZE(keymaps);

keyboards/gboards/georgi/keymaps/default/keymap.c

@@ -244,4 +244,4 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 // Don't fuck with this, thanks.
-size_t keymapsCount  = sizeof(keymaps)/sizeof(keymaps[0]);
+size_t keymapsCount  = ARRAY_SIZE(keymaps);

keyboards/gboards/georgi/keymaps/minimal/keymap.c

@@ -219,4 +219,4 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     )
 };
 // Don't fuck with this, thanks.
-size_t keymapsCount  = sizeof(keymaps)/sizeof(keymaps[0]);
+size_t keymapsCount  = ARRAY_SIZE(keymaps);

keyboards/gboards/georgi/keymaps/norman/keymap.c

@@ -263,4 +263,4 @@ KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,       KC_PGDN, KC_LEFT, KC
 			  KC_TRNS, KC_TRNS, KC_TRNS,	                        KC_TRNS, KC_TRNS, KC_TRNS)
 };
 // Don't fuck with this, thanks.
-size_t keymapsCount  = sizeof(keymaps)/sizeof(keymaps[0]);
+size_t keymapsCount  = ARRAY_SIZE(keymaps);

keyboards/gboards/georgi/sten.c

@@ -21,7 +21,7 @@ uint32_t tChord			= 0;		// Protects state of cChord
 
 #ifndef STENOLAYERS
 uint32_t stenoLayers[] = { PWR };
-size_t 	 stenoLayerCount = sizeof(stenoLayers)/sizeof(stenoLayers[0]);
+size_t 	 stenoLayerCount = ARRAY_SIZE(stenoLayers);
 #endif
 
 // Mode state

keyboards/gmmk/pro/rev1/ansi/keymaps/cedrikl/keymap.c

@@ -107,16 +107,22 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
     // Capslock, Scroll lock and Numlock  indicator on Left side lights.
     void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
-        loop_colorset(LED_REGION_A,      (sizeof(LED_REGION_A) / sizeof(LED_REGION_A[0])),           hsv_cl_blue);
-        loop_colorset(LED_REGION_B,      (sizeof(LED_REGION_B) / sizeof(LED_REGION_B[0])),           hsv_cl_purple);
-        loop_colorset(LED_REGION_L_SIDE, (sizeof(LED_REGION_L_SIDE) / sizeof(LED_REGION_L_SIDE[0])), hsv_cl_purple);
-        loop_colorset(LED_REGION_R_SIDE, (sizeof(LED_REGION_R_SIDE) / sizeof(LED_REGION_R_SIDE[0])), hsv_cl_purple);
+        loop_colorset(LED_REGION_A,      ARRAY_SIZE(LED_REGION_A),
+                                 hsv_cl_blue);
+        loop_colorset(LED_REGION_B,      ARRAY_SIZE(LED_REGION_B),
+                                 hsv_cl_purple);
+        loop_colorset(LED_REGION_L_SIDE, ARRAY_SIZE(LED_REGION_L_SIDE),
+                      hsv_cl_purple);
+        loop_colorset(LED_REGION_R_SIDE, ARRAY_SIZE(LED_REGION_R_SIDE),
+                      hsv_cl_purple);
 
         switch(get_highest_layer(layer_state)){  // special handling per layer
             case 1:  //layer 1
                 //rgb_matrix_set_color_all(RGB_AZURE);
-                loop_colorset(LED_REGION_NUMPAD, (sizeof(LED_REGION_NUMPAD) / sizeof(LED_REGION_NUMPAD[0])), hsv_cl_numpad);
-                loop_colorset(LED_REGION_OTHER,  (sizeof(LED_REGION_OTHER) / sizeof(LED_REGION_OTHER[0])),   hsv_cl_mods);
+                loop_colorset(LED_REGION_NUMPAD,
+                              ARRAY_SIZE(LED_REGION_NUMPAD), hsv_cl_numpad);
+                loop_colorset(LED_REGION_OTHER,  ARRAY_SIZE(LED_REGION_OTHER),
+                                 hsv_cl_mods);
             break;
             default: //layer 0
                 //
@@ -148,7 +154,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
             rgb_matrix_set_color(LED_L6,   bad_rgb.r, bad_rgb.g, bad_rgb.b);
             rgb_matrix_set_color(LED_L7,   bad_rgb.r, bad_rgb.g, bad_rgb.b);
             rgb_matrix_set_color(LED_L8,   bad_rgb.r, bad_rgb.g, bad_rgb.b);
-            loop_colorset(LED_REGION_CAPS, (sizeof(LED_REGION_CAPS) / sizeof(LED_REGION_CAPS[0])), hsv_cl_bad);
+            loop_colorset(LED_REGION_CAPS, ARRAY_SIZE(LED_REGION_CAPS),
+                          hsv_cl_bad);
         }
     }
 #endif

keyboards/gmmk/pro/rev1/ansi/keymaps/gourdo1/keymap.c

@@ -538,7 +538,7 @@ void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
 
         } else if (paddle_lives == 0) {
             // Game over
-            for (uint8_t i = 0; i < sizeof(LED_GAME_OVER) / sizeof(LED_GAME_OVER[0]); i++) {
+            for (uint8_t i = 0; i < ARRAY_SIZE(LED_GAME_OVER); i++) {
                 rgb_matrix_set_color(LED_GAME_OVER[i], RGB_RED);
             }
 

keyboards/gmmk/pro/rev1/ansi/keymaps/paddlegame/keymap.c

@@ -201,15 +201,15 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 				else { ++rgb_value.r; }
 			}
 
-            for (uint8_t i=0; i<sizeof(LED_RGB)/sizeof(LED_RGB[0]); i++) {
+            for (uint8_t i=0; i<ARRAY_SIZE(LED_RGB); i++) {
                 rgb_matrix_set_color(LED_RGB[i], rgb_value.r, rgb_value.g, rgb_value.b);
             }
 
-            for (uint8_t i=0; i<sizeof(LED_WHITE)/sizeof(LED_WHITE[0]); i++) {
+            for (uint8_t i=0; i<ARRAY_SIZE(LED_WHITE); i++) {
                 rgb_matrix_set_color(LED_WHITE[i], RGB_WHITE);
             }
 
-            for (uint8_t i=0; i<sizeof(LED_GREEN)/sizeof(LED_GREEN[0]); i++) {
+            for (uint8_t i=0; i<ARRAY_SIZE(LED_GREEN); i++) {
                 rgb_matrix_set_color(LED_GREEN[i], RGB_GREEN);
             }
 
@@ -274,7 +274,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 			} else if (paddle_lives == 0) {
 				// Game over
-				for (uint8_t i=0; i<sizeof(LED_GAME_OVER)/sizeof(LED_GAME_OVER[0]); i++) {
+				for (uint8_t i=0; i<ARRAY_SIZE(LED_GAME_OVER); i++) {
 					rgb_matrix_set_color(LED_GAME_OVER[i], RGB_RED);
 				}
 
@@ -439,12 +439,12 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
             rgb_matrix_set_color(LED_CAPS, RGB_WHITE);
             if (caps_flash_on) {
-				for (uint8_t i=0; i<sizeof(LED_SIDE_LEFT)/sizeof(LED_SIDE_LEFT[0]); i++) {
+				for (uint8_t i=0; i<ARRAY_SIZE(LED_SIDE_LEFT); i++) {
 					rgb_matrix_set_color(LED_SIDE_LEFT[i], RGB_RED);
 					rgb_matrix_set_color(LED_SIDE_RIGHT[i], RGB_RED);
 				}
 			} else {
-				for (uint8_t i=0; i<sizeof(LED_SIDE_LEFT)/sizeof(LED_SIDE_LEFT[0]); i++) {
+				for (uint8_t i=0; i<ARRAY_SIZE(LED_SIDE_LEFT); i++) {
 					rgb_matrix_set_color(LED_SIDE_LEFT[i], 0, 0, 0);
 					rgb_matrix_set_color(LED_SIDE_RIGHT[i], 0, 0, 0);
 				}

keyboards/gmmk/pro/rev1/iso/keymaps/chofstede/keymap.c

@@ -84,7 +84,7 @@ void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
         }
     HSV tempHSV = {.h = 0, .s = 255, .v = current_value};
     RGB tempRGB = hsv_to_rgb(tempHSV);
-    for (uint8_t i = 0; i < sizeof(left_side_leds) / sizeof(left_side_leds[0]); i++) {
+    for (uint8_t i = 0; i < ARRAY_SIZE(left_side_leds); i++) {
         rgb_matrix_set_color(left_side_leds[i], tempRGB.r, tempRGB.g, tempRGB.b);
         rgb_matrix_set_color(right_side_leds[i], tempRGB.r, tempRGB.g, tempRGB.b);
         }
@@ -95,7 +95,7 @@ void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
        case 2:  //layer one
          break;
        case 1:
-         for (uint8_t i = 0; i < sizeof(l2_functions) / sizeof(l2_functions[0]); i++) {
+         for (uint8_t i = 0; i < ARRAY_SIZE(l2_functions); i++) {
              RGB_MATRIX_INDICATOR_SET_COLOR(l2_functions[i], 255, 0, 0);
          }
          break;

keyboards/gmmk/pro/rev1/iso/keymaps/gourdo1/keymap.c

@@ -551,7 +551,7 @@ void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
 
         } else if (paddle_lives == 0) {
             // Game over
-            for (uint8_t i = 0; i < sizeof(LED_GAME_OVER) / sizeof(LED_GAME_OVER[0]); i++) {
+            for (uint8_t i = 0; i < ARRAY_SIZE(LED_GAME_OVER); i++) {
                 rgb_matrix_set_color(LED_GAME_OVER[i], RGB_RED);
             }
 

keyboards/gopolar/gg86/keymaps/horrortroll/keymap_stuff.h

@@ -118,7 +118,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
     {{205, 250, 255}, {140, 215, 125}, false },
     };
 
-    uint8_t gp_length = sizeof(gradient_presets)/sizeof(gradient_presets[0]);
+    uint8_t gp_length = ARRAY_SIZE(gradient_presets);
 
     switch (keycode) {
         case G1_HUI:

keyboards/gopolar/gg86/lib/wave.h

@@ -69,7 +69,7 @@ void add_keylog(uint16_t keycode) {
         keycode = 0;
     }
 
-    if (keycode < (sizeof(code_to_name) / sizeof(char))) {
+    if (keycode < ARRAY_SIZE(code_to_name)) {
         char log_char = pgm_read_byte(&code_to_name[keycode]);
 
         for (uint8_t j = 0; j < OLED_FONT_WIDTH; j++) {

keyboards/handwired/lagrange/keymaps/dpapavas/keymap.c

@@ -191,8 +191,8 @@ void keyboard_post_init_user(void) {
     const pin_t pins[] = {D0, D1, D2};
     uint8_t i, j;
 
-    for (i = 0 ; i < sizeof(pins) / sizeof(pins[0]) + 2 ; i += 1) {
-        for (j = 0 ; j < sizeof(pins) / sizeof(pins[0]) ; j += 1) {
+    for (i = 0 ; i < ARRAY_SIZE(pins) + 2 ; i += 1) {
+        for (j = 0 ; j < ARRAY_SIZE(pins); j += 1) {
             setPinOutput(pins[j]);
             writePin(pins[j], (j == i || j == i - 1));
         }

keyboards/handwired/myskeeb/oled.c

@@ -183,7 +183,7 @@ void add_keylog(uint16_t keycode) {
         keylog_str[i] = keylog_str[i - 1];
     }
 
-    if (keycode < (sizeof(code_to_name) / sizeof(char))) {
+    if (keycode < ARRAY_SIZE(code_to_name)) {
         keylog_str[0] = pgm_read_byte(&code_to_name[keycode]);
     }
 }

keyboards/handwired/nicekey/keymaps/default/keymap.c

@@ -116,7 +116,7 @@ PGM_P const sentences[] PROGMEM = {
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
     if (record->event.pressed) {
-        int sentences_size = sizeof(sentences) / sizeof(sentences[0]);
+        int sentences_size = ARRAY_SIZE(sentences);
         int i = rand() % sentences_size;
 
         switch (keycode) {

keyboards/handwired/onekey/keymaps/chibios_waiting_test/keymap.c

@@ -34,11 +34,11 @@ static const uint32_t waiting_values[] = {0, 1, 5, 10, 25, 50, 100, 150, 200, 50
 void housekeeping_task_user(void) {
     static uint32_t last_bench = 0;
     if (timer_elapsed32(last_bench) > 500) {
-        for (int i = 0; i < (sizeof(waiting_values) / sizeof(waiting_values[0])); i++) {
+        for (int i = 0; i < ARRAY_SIZE(waiting_values); i++) {
             wait_us_polling_with_strobe(waiting_values[i]);
             wait_us(10);
         }
-        for (int i = 0; i < (sizeof(waiting_values) / sizeof(waiting_values[0])); i++) {
+        for (int i = 0; i < ARRAY_SIZE(waiting_values); i++) {
             wait_us_yield_with_strobe(waiting_values[i]);
             wait_us(10);
         }