Remove all instances of static_cast<size_t>(1).

In preparation for removing magic numbers, simplify code that is
computing masks with a single bit set.

src/mem/alloc.h

@@ -1211,7 +1211,7 @@ namespace snmalloc
       MEASURE_TIME(large_dealloc, 4, 16);
 
       size_t size_bits = bits::next_pow2_bits(size);
-      size_t rsize = static_cast<size_t>(1) << size_bits;
+      size_t rsize = bits::one_at_bit(size_bits);
       assert(rsize >= SUPERSLAB_SIZE);
       size_t large_class = size_bits - SUPERSLAB_BITS;
 

src/mem/allocstats.h

@@ -117,7 +117,7 @@ namespace snmalloc
     static constexpr size_t BUCKETS = 1 << BUCKETS_BITS;
     static constexpr size_t TOTAL_BUCKETS =
       bits::to_exp_mant_const<BUCKETS_BITS>(
-        (static_cast<size_t>(1) << (bits::ADDRESS_BITS - 1)));
+        bits::one_at_bit(bits::ADDRESS_BITS - 1));
 
     Stats sizeclass[N];
     Stats large[LARGE_N];

src/mem/largealloc.h

@@ -98,8 +98,7 @@ namespace snmalloc
         {
           break;
         }
-        size_t rsize = (static_cast<size_t>(1) << SUPERSLAB_BITS)
-          << large_class;
+        size_t rsize = bits::one_at_bit(SUPERSLAB_BITS) << large_class;
         size_t decommit_size = rsize - OS_PAGE_SIZE;
         // Grab all of the chunks of this size class.
         auto* slab = large_stack[large_class].pop_all();
@@ -321,7 +320,7 @@ namespace snmalloc
     template<ZeroMem zero_mem = NoZero, AllowReserve allow_reserve = YesReserve>
     void* alloc(size_t large_class, size_t size)
     {
-      size_t rsize = (static_cast<size_t>(1) << SUPERSLAB_BITS) << large_class;
+      size_t rsize = bits::one_at_bit(SUPERSLAB_BITS) << large_class;
       if (size == 0)
         size = rsize;
 

src/mem/metaslab.h

@@ -102,10 +102,13 @@ namespace snmalloc
     {
       size_t size = sizeclass_to_size(sizeclass);
       size_t offset = get_slab_offset(sizeclass, is_short);
+      size_t all_ones = std::numeric_limits<size_t>::is_signed ?
+        size_t(-1) :
+        std::numeric_limits<size_t>::max();
 
       size_t head_start =
-        remove_cache_friendly_offset(head & ~static_cast<size_t>(1), sizeclass);
-      size_t slab_start = offset & ~static_cast<size_t>(1);
+        remove_cache_friendly_offset(head & all_ones, sizeclass);
+      size_t slab_start = offset & all_ones;
 
       return ((head_start - slab_start) % size) == 0;
     }

src/mem/sizeclass.h

@@ -30,12 +30,12 @@ namespace snmalloc
 
   constexpr static inline size_t large_sizeclass_to_size(uint8_t large_class)
   {
-    return static_cast<size_t>(1) << (large_class + SUPERSLAB_BITS);
+    return bits::one_at_bit(large_class + SUPERSLAB_BITS);
   }
 
   // Small classes range from [MIN, SLAB], i.e. inclusive.
   static constexpr size_t NUM_SMALL_CLASSES =
-    size_to_sizeclass_const(static_cast<size_t>(1) << SLAB_BITS) + 1;
+    size_to_sizeclass_const(bits::one_at_bit(SLAB_BITS)) + 1;
 
   static constexpr size_t NUM_SIZECLASSES =
     size_to_sizeclass_const(SUPERSLAB_SIZE);

src/mem/sizeclasstable.h

@@ -30,8 +30,7 @@ namespace snmalloc
           bits::from_exp_mant<INTERMEDIATE_BITS, MIN_ALLOC_BITS>(sizeclass);
 
         size_t alignment = bits::min(
-          static_cast<size_t>(1) << bits::ctz_const(size[sizeclass]),
-          OS_PAGE_SIZE);
+          bits::one_at_bit(bits::ctz_const(size[sizeclass])), OS_PAGE_SIZE);
         cache_friendly_mask[sizeclass] = (alignment - 1);
         inverse_cache_friendly_mask[sizeclass] = ~(alignment - 1);
       }