Doesn't matter if size is aligned; heap pointer must be

Add tests.

compiler_tests.py

···
     def test_small_string_concat(self) -> None:
         self.assertEqual(self._run('"abc" ++ "def"'), '"abcdef"\n')
 
-    def test_heap_string(self) -> None:
+    def test_const_large_string(self) -> None:
         self.assertEqual(self._run('"hello world"'), '"hello world"\n')
+
+    def test_heap_string_concat(self) -> None:
+        self.assertEqual(self._run('"hello world" ++ " and goodbye"'), '"hello world and goodbye"\n')
 
     def test_const_list(self) -> None:
         self.assertEqual(
···
 
     def test_list(self) -> None:
         self.assertEqual(self._run("[1, 2, 3]"), "[1, 2, 3]\n")
+
+    def test_list_concat(self) -> None:
+        self.assertEqual(self._run("0 >+ [1, 2, 3]"), "[0, 1, 2, 3]\n")
 
     def test_var(self) -> None:
         self.assertEqual(self._run("a . a = 1"), "1\n")

runtime.c

···
   struct space space;
 };
 
-static uintptr_t align(uintptr_t val, uintptr_t alignment) {
+static ALWAYS_INLINE uintptr_t align(uintptr_t val, uintptr_t alignment) {
   return (val + alignment - 1) & ~(alignment - 1);
 }
-static uintptr_t align_size(uintptr_t size) {
+static ALWAYS_INLINE uintptr_t align_size(uintptr_t size) {
   return align(size, sizeof(uintptr_t));
 }
 
···
   heap->from_space = heap->limit = heap->hp + space.size / 2;
 }
 
+static ALWAYS_INLINE bool is_power_of_two(uword x) { return (x & (x - 1)) == 0; }
+
+static ALWAYS_INLINE bool is_aligned(uword value, uword alignment) {
+  assert(is_power_of_two(alignment));
+  return (value & (alignment - 1)) == 0;
+}
+
 struct gc_obj* copy(struct gc_heap* heap, struct gc_obj* obj) {
   size_t size = heap_object_size(obj);
   struct gc_obj* new_obj = (struct gc_obj*)heap->hp;
   memcpy(new_obj, obj, size);
   forward(obj, new_obj);
   heap->hp += align_size(size);
+  assert(is_aligned(heap->hp, 1 << kPrimaryTagBits) && "need 3 bits for tagging");
   return new_obj;
 }
 
···
 }
 #endif
 
-bool is_power_of_two(uword x) { return (x & (x - 1)) == 0; }
-
-bool is_aligned(uword value, uword alignment) {
-  assert(is_power_of_two(alignment));
-  return (value & (alignment - 1)) == 0;
-}
-
 uword make_tag(uword tag, uword size_bytes) {
   assert(size_bytes <= 0xffffffff);
   return (size_bytes << kBitsPerByte) | tag;
···
 
 static ALWAYS_INLINE ALLOCATOR struct object* allocate(struct gc_heap* heap,
                                                        uword tag, uword size) {
-  assert(is_aligned(size, 1 << kPrimaryTagBits) && "need 3 bits for tagging");
   uintptr_t addr = heap->hp;
   uintptr_t new_hp = align_size(addr + size);
+  assert(is_aligned(new_hp, 1 << kPrimaryTagBits) && "need 3 bits for tagging");
   if (UNLIKELY(heap->limit < new_hp)) {
     allocate_slow_path(heap, size);
     addr = heap->hp;
     new_hp = align_size(addr + size);
+    assert(is_aligned(new_hp, 1 << kPrimaryTagBits) && "need 3 bits for tagging");
   }
   heap->hp = new_hp;
   ((struct gc_obj*)addr)->tag = make_tag(tag, size);