0.1.4 release!

Optimizations:

 * Eagerly calculated hashes, and switched from lists to vecs. 10-11x speedup!
 * Added Solver, the next generics solver. Uses normalized rules, much more optimizable.
 * New list uses the new arrays, should be much faster

User-visible language changes:

 * Now two kinds of non-owning reference: borrow ref like `&Ship` and pointer ref like `*Ship`. Midas will soon treat these differently.
 * Added break
 * Added foreach
 * Added basic variadic members!
 * Added new functions: range(int, int), i64(i32), migrate for arrays
 * Now need `sealed` on the interface to define abstract functions outside an interface
 * All parameters need a type. `fn do(callable)` -> `fn do<F>(callable F)`
 * Destructors:
    * Now need #!DeriveStructDrop now to make custom destructors.
    * Custom destructors are now called `drop`, not `destructor`.
 * Syntax changes:
    * Changed pack destructures from `(...)` to `[...]`
    * Changed tuples from `[...]` to `(...)`
    * `fn` is now `func`
    * Changed lambda syntax:
       * (x){ x + 5 } is now x => x + 5
       * (x, y){ moo(); foo(); } is now (x, y) => { moo(); foo(); }
    * Changed `rules(...)` to `where ...`
    * Moved struct's mutability specifier to before rules
    * `= 5;` is now just `5`, like Scala and Rust
    * Put attributes (pure, extern, export, abstract, etc) before fn. export is now exported.
    * Arrays:
       * Changed making syntax, [vary *](5, {_}) is now [](5, {_)} or Array(...)
       * We can now destroy an RSA with `() = arr;` to mirror structs.
 * Array semantics:
    * Array<M, V, E> is now Array<M, E>, all arrays are now varying.
    * Added push/pop support for arrays.
    * Added .capacity() for arrays, plus an instructino for it.
 * Extern boundary:
     * Obviated ValeReleaseMessage, added _vasp for getting message sizes
     * We no longer need artificial pointers on the extern boundary!
 * Misc:
     * Removed IFunction1 from builtins, its no longer needed by the compiler.
     * Added i64 to string
     * Made a functor struct, to give to the array instructions, since they need a 'this' object basically

Tooling changes:

 * Changed how install scripts pull in stdlib project
 * Merged package-unix/windows scripts into others
 * Cleaned up Driver build process
 * Made a Utils module to use in Driver and Tester, and it has stdlib additions
 * Added census, asan, debug_output flags
 * Made it move the old build directory to a random /tmp subdir
 * New CI, thanks to kevin!
 * Using supplied bootstrapping valec+stdlib for Driver and Tester now
 * Cleaned out old scripts
 * Clarified flags for Driver
 * Made the scripts test the unzipped zip
 * Made the scripts return 1 if they fail
 * Removed valec.py from zip
 * Split windows script into an install and build script, like mac and linux
 * Added Driver, a.k.a. valec
 * Added Tester, which runs our Midas tests now

Compiler changes:

 * Rewrote most of the parser to manual recursive descent
 * Added Void back in, no longer reusing empty tuples
 * Fixed some Never handling bugs
 * Things after Never aren't even evaluated, Hammer strips them out.
 * Made Midas BlockState a linked list, so we can jump to the end of nearest loop
 * Made Consecutor the only thing that could repeat expressions. Most blocks contain them now.
 * Moved drop_into into builtins
 * Made tuple an extern struct, using variadic members.
 * Removed RawArray, it doesn't fit anymore since all RSAs are varying.
 * Added an error for the rune type solver
 * Separated a GlobalOptions module
 * Removed astronomers specific rules
 * Removed types from the astronomer rules.
   * Learned: It's not always a great thing to denormalize data, it leads to inconsistency opportunities. An instance of premature optimization likely. Now I'm questioning why .ll does this.
 * Added better humanizing of errors
 * Added a MUCH better solver error printer
 * Brought back the distinction between declaration names and imprecise names
 * Made a better distinction between drop and free
 * Fixed build failure counting bug in Tester
 * Took out localRunes and knowableRunes from Astronomer, moved some of that logic back into astronomer.
   * Learned: It's not always a great thing to pull as much logic as possible out of Templar. In this case, reducing the amount of code in Templar actually increased its complexity, ironically.
 * Changed some astronomer tests into integration tests, feeding actual vale source code now.
   * Learned: Unit tests have a high cost in maintaining the inputs. Perhaps unit tests only make sense on very established chunks of code.
 * Moved a bunch of hardcoded functions (weaks, drop, free, array len, panic) to actual vale code.
 * Removed special PackTT type.
 * Added the "macro" concept, for any syntactical sugar features (or semantic sugar? like anonymous substructs, theyre kind of semantic sugar I guess?)
 * Moved drop functions into macros.
 * Moved anonymous substruct functionality into macros.
 * Better distinction between a template name and a stamped name, see CitizenNameT vs CitizenTemplateNameT.
 * Fixed types starting with _, like __Never
 * Added free() functions for interfaces, which then call virtualfree(). Now, there is a normal free() function for every immutable type.
 * Fixed printing exceptions twice in tests
 * Added a "Location In Function" notion, so places in the code are marked by tree-shaped paths
 * Made impl rules sane again, no more NMORFI!
 * Changed the default namespace to __vale, for Midas
 * Made the compiler spit out a different .vast per package
 * Put the generated files in include/ and abi/
 * Put generated .vast files into vast/, and .vpst files into vpst/
 * Fixed exported mutable refs, they no longer require their members be exported too
 * Using = instead of : for module mappings in the CLI
 * Updated build instructions
 * Added NodeEnvironment to templar for breaks too
 * Made most of the expressiontemplar and nearby templars use NodeEnvironmentBox
 * renamed constraint to borrow
 * cleaned up precise vs imprecise names
 * removed Maybe from variable uses
 * Replaced builtin functions with generators
 * Fixed kldc test

Author: Verdagon

.github/workflows/ci.yml

@@ -15,24 +15,24 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: install prereqs
-        run: cmd /c '.\install-compiler-prereqs-windows.bat C:\llvm-install-minimum C:\ValeCompiler-0.1.3.4-Win'
+        run: cmd /c '.\install-compiler-prereqs-windows.bat C:\llvm-install-minimum C:\ValeCompiler-0.1.3.4-Win C:\stdlib'
       - name: run vcvars and build-compiler-windows.bat
-        run: cmd /c '"C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat" && .\build-compiler-windows.bat C:\llvm-install-minimum C:\ValeCompiler-0.1.3.4-Win'
+        run: cmd /c '"C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat" && .\build-compiler-windows.bat C:\llvm-install-minimum C:\ValeCompiler-0.1.3.4-Win C:\stdlib'
 
   build_and_test_ubuntu:
     runs-on: ubuntu-latest
     steps: 
       - uses: actions/checkout@v2
       - name: install prereqs
-        run: ./install-compiler-prereqs-linux.sh ~/ValeLLVM ~/ValeCompiler-0.1.3.3-Ubuntu
+        run: ./install-compiler-prereqs-linux.sh ~/ValeLLVM ~/ValeCompiler-0.1.3.3-Ubuntu ~/stdlib
       - name: build compiler 
-        run: ./build-compiler-linux.sh ~/ValeLLVM/clang+llvm-11.1.0-x86_64-linux-gnu-ubuntu-20.10 ~/ValeCompiler-0.1.3.3-Ubuntu
+        run: ./build-compiler-linux.sh ~/ValeLLVM/clang+llvm-11.1.0-x86_64-linux-gnu-ubuntu-20.10 ~/ValeCompiler-0.1.3.3-Ubuntu ~/stdlib
 
   build_and_test_mac:
     runs-on: macos-latest
     steps: 
       - uses: actions/checkout@v2
       - name: install prereqs
-        run: ./install-compiler-prereqs-mac.sh ~/ValeCompiler-0.1.3.3-Mac
+        run: ./install-compiler-prereqs-mac.sh ~/ValeCompiler-0.1.3.3-Mac ~/stdlib
       - name: build compiler
-        run: source ~/.zshrc && ./build-compiler-mac.sh ~/ValeCompiler-0.1.3.3-Mac
+        run: source ~/.zshrc && ./build-compiler-mac.sh ~/ValeCompiler-0.1.3.3-Mac ~/stdlib

Driver/build-linux.sh

@@ -1,2 +1,2 @@
 
-%1\valec.exe build driver=src stdlib=%1\stdlib\src --output_dir build -o valec
+%1\valec.exe build driver=src stdlib=%1\stdlib\src valecutils=../Utils/src --output_dir build -o valec

Driver/build-mac.sh

@@ -5,5 +5,6 @@ if [ "$BOOTSTRAPPING_VALEC_DIR" == "" ]; then
   echo "Example: ~/TheValeCompiler"
   exit
 fi
+shift;
 
-$BOOTSTRAPPING_VALEC_DIR/valec build driver=src stdlib=$BOOTSTRAPPING_VALEC_DIR/stdlib/src --output_dir build -o valec
+$BOOTSTRAPPING_VALEC_DIR/valec build driver=src stdlib=$BOOTSTRAPPING_VALEC_DIR/stdlib/src valecutils=../Utils/src --output_dir build -o valec $@

Driver/build.bat

@@ -2,6 +2,15 @@ import stdlib.command.*;
 import stdlib.flagger.*;
 import stdlib.path.*;
 
+//fn removeAllRecursively(path &Path) {
+//  if (path.is_dir()) {
+//    iterdir(path).each((entry){
+//      removeAllRecursively(entry);
+//    });
+//  }
+//  path.remove();
+//}
+
 struct ProjectDirectoryDeclaration {
   project_name str;
   path Path;
@@ -77,6 +86,24 @@ fn build_stuff(compiler_dir &Path, all_args &Array<imm, final, str>) {
           "Whether to print out more detailed errors.",
           "true",
           "Whether to print out more detailed errors."),
+        Flag(
+          "--census",
+          FLAG_BOOL(),
+          "Whether to add run-time checks to debug the compiler itself.",
+          "true",
+          "Whether to add run-time checks to debug the compiler itself."),
+        Flag(
+          "--asan",
+          FLAG_BOOL(),
+          "Whether to run with ASan.",
+          "true",
+          "Whether to run with ASan."),
+        Flag(
+          "--debug_output",
+          FLAG_BOOL(),
+          "Whether to print out more detailed errors.",
+          "true",
+          "Whether to print out more detailed errors."),
         Flag(
           "--output_vast",
           FLAG_BOOL(),
@@ -167,6 +194,7 @@ fn build_stuff(compiler_dir &Path, all_args &Array<imm, final, str>) {
 
   benchmark = parsed_flags.get_bool_flag("--benchmark", false);
   verbose = parsed_flags.get_bool_flag("--verbose", false);
+  debug_output = parsed_flags.get_bool_flag("--debug_output", false);
   include_builtins = parsed_flags.get_bool_flag("--include_builtins", true);
   output_vast = parsed_flags.get_bool_flag("--output_vast", true);
   reuse_vast = parsed_flags.get_bool_flag("--reuse_vast", false);
@@ -178,6 +206,7 @@ fn build_stuff(compiler_dir &Path, all_args &Array<imm, final, str>) {
   flares = parsed_flags.get_bool_flag("--flares", false);
   gen_heap = parsed_flags.get_bool_flag("--gen_heap", false);
   census = parsed_flags.get_bool_flag("--census", false);
+  asan = parsed_flags.get_bool_flag("--asan", false);
   verify = parsed_flags.get_bool_flag("--verify", false);
   debug_symbols = parsed_flags.get_nothing_flag("-g");
   llvm_ir = parsed_flags.get_bool_flag("--llvm_ir", false);
@@ -240,6 +269,16 @@ fn build_stuff(compiler_dir &Path, all_args &Array<imm, final, str>) {
       panic("Error: --reuse_vast specified, but no .vast files found in " + output_dir.str() + ".");
     }
   } else {
+    if (output_dir.exists()) {
+      dest_dir = GetTempDir()./("old_output_dir_" + str(MtpId()));
+      if (dest_dir.exists()) {
+        println("Deleting existing {dest_dir.str()}.");
+        dest_dir.RemoveDirAll().expect();
+        vassert(not dest_dir.exists(), "Removing old dir {dest_dir.str()} failed!");
+      }
+      println("Moving existing output directory {output_dir.str()} to {dest_dir.str()}.");
+      output_dir.Rename(&dest_dir).expect();
+    }
     valestrom_process =
         invoke_valestrom(
             &valestrom_path,
@@ -248,6 +287,7 @@ fn build_stuff(compiler_dir &Path, all_args &Array<imm, final, str>) {
             &project_non_vale_input_declarations,
             benchmark,
             verbose,
+            debug_output,
             include_builtins,
             output_vast,
             output_vpst,
@@ -400,7 +440,7 @@ fn build_stuff(compiler_dir &Path, all_args &Array<imm, final, str>) {
           windows,
           &clang_inputs,
           &executable_name,
-          census,
+          asan,
           debug_symbols,
           &output_dir);
   println("Running:\n" + clang_process.command);

Driver/build.sh

@@ -4,7 +4,7 @@ fn invoke_clang(
   windows bool,
   clang_inputs &List<Path>,
   exe_name str,
-  census bool,
+  asan bool,
   debug_symbols bool,
   output_dir &Path)
 Subprocess {
@@ -51,7 +51,7 @@ Subprocess {
     args!.add("-g");
   }
 
-  if (census) {
+  if (asan) {
     if (windows) {
       args!.add("/fsanitize=address");
       args!.add("clang_rt.asan_dynamic-x86_64.lib");

Driver/src/build.vale

@@ -1,6 +1,8 @@
 import stdlib.command.*;
 import stdlib.flagger.*;
 import stdlib.path.*;
+import valecutils.pathadditions.*;
+import valecutils.mtpid.*;
 
 
 fn main() export {
@@ -14,6 +16,9 @@ fn main() export {
 
 
   driver_path = Path(all_args_list.get(0)).resolve();
+  if (not driver_path.exists()) {
+    panic("Path {driver_path.str()} does not exist!");
+  }
   compiler_dir = driver_path.directory();
 
   if (all_args_list.len() < 2) {

Driver/src/clang.vale

@@ -48,7 +48,7 @@ Subprocess {
     command_line_args!.add("--verify");
   }
   if (llvm_ir) {
-    command_line_args!.add("--llvmir");
+    command_line_args!.add("--llvm_ir");
   }
   if (print_mem_overhead) {
     command_line_args!.add("--print_mem_overhead");

Driver/src/main.vale

@@ -6,6 +6,7 @@ fn invoke_valestrom(
   project_non_vale_inputs &List<ProjectNonValeInputDeclaration>,
   benchmark bool,
   verbose bool,
+  debug_output bool,
   include_builtins bool,
   output_vast bool,
   output_vpst bool,
@@ -32,6 +33,9 @@ Subprocess {
   if (verbose) {
     command_line_args!.add("--verbose");
   }
+  if (debug_output) {
+    command_line_args!.add("--debug_output");
+  }
   if (not include_builtins) {
     command_line_args!.add("--include-builtins false");
   }

Driver/src/midas.vale

@@ -16,3 +16,7 @@ double __vale_castI64Float(int64_t i) {
 int64_t __vale_castFloatI64(double i) {
   return (int64_t)i;
 }
+
+int32_t __vale_TruncateI64ToI32(int64_t i) {
+  return (int32_t)i;
+}

Driver/src/valestrom.vale

@@ -62,6 +62,14 @@ Ref translateExpressionInner(
             Location::INLINE,
             globalState->metalCache->getInt(globalState->metalCache->rcImmRegionId, constantInt->bits));
     return wrap(globalState->getRegion(intRef), intRef, resultLE);
+  } else if (auto constantVoid = dynamic_cast<ConstantVoid*>(expr)) {
+    // See ULTMCIE for why we load and store here.
+    auto resultRef = makeVoidRef(globalState);
+    auto resultLE =
+        globalState->getRegion(globalState->metalCache->voidRef)
+            ->checkValidReference(FL(), functionState, builder, globalState->metalCache->voidRef, resultRef);
+    auto loadedLE = makeConstExpr(functionState, builder, resultLE);
+    return wrap(globalState->getRegion(globalState->metalCache->voidRef), globalState->metalCache->voidRef, loadedLE);
   } else if (auto constantFloat = dynamic_cast<ConstantF64*>(expr)) {
     // See ULTMCIE for why we load and store here.
 
@@ -94,6 +102,33 @@ Ref translateExpressionInner(
       LLVMBuildRet(builder, toReturnLE);
       return wrap(globalState->getRegion(globalState->metalCache->neverRef), globalState->metalCache->neverRef, globalState->neverPtr);
     }
+  } else if (auto breeak = dynamic_cast<Break*>(expr)) {
+    if (auto nearestLoopBlockStateAndEnd = blockState->getNearestLoopEnd()) {
+      auto [nearestLoopBlockState, nearestLoopEnd] = *nearestLoopBlockStateAndEnd;
+
+      LLVMBuildBr(builder, nearestLoopEnd);
+
+      return wrap(
+        globalState->getRegion(globalState->metalCache->neverRef), globalState->metalCache->neverRef,
+        globalState->neverPtr);
+
+//      buildFlare(FL(), globalState, functionState, builder, typeid(*expr).name());
+//      auto sourceRef = translateExpression(globalState, functionState, blockState, builder, ret->sourceExpr);
+//      if (ret->sourceType->kind == globalState->metalCache->never) {
+//        return sourceRef;
+//      } else {
+//        auto toReturnLE =
+//            globalState->getRegion(ret->sourceType)
+//                ->checkValidReference(FL(), functionState, builder, ret->sourceType, sourceRef);
+//        LLVMBuildRet(builder, toReturnLE);
+//        return wrap(
+//            globalState->getRegion(globalState->metalCache->neverRef), globalState->metalCache->neverRef,
+//            globalState->neverPtr);
+//      }
+    } else {
+      std::cerr << "Error: found a break not inside a loop!" << std::endl;
+      exit(1);
+    }
   } else if (auto stackify = dynamic_cast<Stackify*>(expr)) {
     buildFlare(FL(), globalState, functionState, builder, typeid(*expr).name());
     auto refToStore =
@@ -103,7 +138,7 @@ Ref translateExpressionInner(
         ->checkValidReference(FL(), functionState, builder, stackify->local->type, refToStore);
     makeHammerLocal(
         globalState, functionState, blockState, builder, stackify->local, refToStore, stackify->knownLive);
-    return makeEmptyTupleRef(globalState);
+    return makeVoidRef(globalState);
   } else if (auto localStore = dynamic_cast<LocalStore*>(expr)) {
     buildFlare(FL(), globalState, functionState, builder, typeid(*expr).name());
     // The purpose of LocalStore is to put a swap value into a local, and give
@@ -126,6 +161,18 @@ Ref translateExpressionInner(
             functionState, builder, localStore->local->type, refToStore);
     LLVMBuildStore(builder, toStoreLE, localAddr);
     return oldRef;
+  } else if (auto pointerToBorrow = dynamic_cast<PointerToBorrow*>(expr)) {
+    buildFlare(FL(), globalState, functionState, builder, typeid(*expr).name());
+    auto sourceRef =
+        translateExpression(
+            globalState, functionState, blockState, builder, pointerToBorrow->sourceExpr);
+    return sourceRef;
+  } else if (auto borrowToPointer = dynamic_cast<BorrowToPointer*>(expr)) {
+    buildFlare(FL(), globalState, functionState, builder, typeid(*expr).name());
+    auto sourceRef =
+        translateExpression(
+            globalState, functionState, blockState, builder, borrowToPointer->sourceExpr);
+    return sourceRef;
   } else if (auto weakAlias = dynamic_cast<WeakAlias*>(expr)) {
     buildFlare(FL(), globalState, functionState, builder, typeid(*expr).name());
 
@@ -284,7 +331,7 @@ Ref translateExpressionInner(
         ->dealias(
             AFL("DestroySSAIntoF"), functionState, builder, consumerType, consumerRef);
 
-    return makeEmptyTupleRef(globalState);
+    return makeVoidRef(globalState);
   } else if (auto pushRuntimeSizedArray = dynamic_cast<PushRuntimeSizedArray*>(expr)) {
     buildFlare(FL(), globalState, functionState, builder, typeid(*expr).name());
     auto arrayExpr = pushRuntimeSizedArray->arrayExpr;
@@ -318,8 +365,8 @@ Ref translateExpressionInner(
             ->checkValidReference(FL(),
                 functionState, builder, globalState->metalCache->i32Ref, arrayCapacityRef);
 
-    auto hasSpaceLE = LLVMBuildICmp(builder, LLVMIntULT, arrayLenLE, arrayCapacityLE, "hasSpace");
-    buildIf(globalState, functionState, builder, hasSpaceLE, [globalState](LLVMBuilderRef bodyBuilder) {
+    auto arrayIsFullLE = LLVMBuildICmp(builder, LLVMIntUGE, arrayLenLE, arrayCapacityLE, "hasSpace");
+    buildIf(globalState, functionState, builder, arrayIsFullLE, [globalState](LLVMBuilderRef bodyBuilder) {
       buildPrint(globalState, bodyBuilder, "Error: Runtime-sized array has no room for new element!");
     });
 
@@ -334,7 +381,7 @@ Ref translateExpressionInner(
         ->dealias(
             AFL("pushRuntimeSizedArrayNoBoundsCheck"), functionState, builder, arrayType, arrayRef);
 
-    return makeEmptyTupleRef(globalState);
+    return makeVoidRef(globalState);
   } else if (auto popRuntimeSizedArray = dynamic_cast<PopRuntimeSizedArray*>(expr)) {
     buildFlare(FL(), globalState, functionState, builder, typeid(*expr).name());
     auto arrayExpr = popRuntimeSizedArray->arrayExpr;
@@ -363,8 +410,8 @@ Ref translateExpressionInner(
     auto indexRef =
         wrap(globalState->getRegion(globalState->metalCache->i32Ref), globalState->metalCache->i32Ref, indexLE);
 
-    auto hasElementsLE = LLVMBuildICmp(builder, LLVMIntNE, arrayLenLE, constI32LE(globalState, 0), "hasElements");
-    buildIf(globalState, functionState, builder, hasElementsLE, [globalState](LLVMBuilderRef bodyBuilder) {
+    auto arrayIsEmptyLE = LLVMBuildICmp(builder, LLVMIntEQ, arrayLenLE, constI32LE(globalState, 0), "hasElements");
+    buildIf(globalState, functionState, builder, arrayIsEmptyLE, [globalState](LLVMBuilderRef bodyBuilder) {
       buildPrint(globalState, bodyBuilder, "Error: Cannot pop element from empty runtime-sized array!");
     });
 
@@ -415,7 +462,7 @@ Ref translateExpressionInner(
       assert(false);
     }
 
-    return makeEmptyTupleRef(globalState);
+    return makeVoidRef(globalState);
   } else if (auto dirsa = dynamic_cast<DestroyImmRuntimeSizedArray*>(expr)) {
     buildFlare(FL(), globalState, functionState, builder, typeid(*expr).name());
     auto consumerType = dirsa->consumerType;
@@ -485,7 +532,7 @@ Ref translateExpressionInner(
         ->dealias(
             AFL("DestroyRSAIntoF"), functionState, builder, consumerType, consumerRef);
 
-    return makeEmptyTupleRef(globalState);
+    return makeVoidRef(globalState);
   } else if (auto staticSizedArrayLoad = dynamic_cast<StaticSizedArrayLoad*>(expr)) {
     buildFlare(FL(), globalState, functionState, builder, typeid(*expr).name());
     auto arrayType = staticSizedArrayLoad->arrayType;
@@ -646,6 +693,25 @@ Ref translateExpressionInner(
     globalState->getRegion(arrayType)
         ->dealias(AFL("RSALen"), functionState, builder, arrayType, arrayRefLE);
 
+    return sizeLE;
+  } else if (auto arrayCapacity = dynamic_cast<ArrayCapacity*>(expr)) {
+    buildFlare(FL(), globalState, functionState, builder, typeid(*expr).name());
+    auto arrayType = arrayCapacity->sourceType;
+    auto arrayExpr = arrayCapacity->sourceExpr;
+    bool arrayKnownLive = arrayCapacity->sourceKnownLive || globalState->opt->overrideKnownLiveTrue;
+//    auto indexExpr = arrayLength->indexExpr;
+
+    auto arrayRefLE = translateExpression(globalState, functionState, blockState, builder, arrayExpr);
+    globalState->getRegion(arrayType)
+        ->checkValidReference(FL(), functionState, builder, arrayType, arrayRefLE);
+
+    auto sizeLE =
+        globalState->getRegion(arrayType)
+            ->getRuntimeSizedArrayCapacity(
+                functionState, builder, arrayType, arrayRefLE, arrayKnownLive);
+    globalState->getRegion(arrayType)
+        ->dealias(AFL("RSACapacity"), functionState, builder, arrayType, arrayRefLE);
+
     return sizeLE;
   } else if (auto narrowPermission = dynamic_cast<NarrowPermission*>(expr)) {
     buildFlare(FL(), globalState, functionState, builder, typeid(*expr).name());

Midas/src/builtins/math.c

@@ -14,7 +14,7 @@ Ref translateBlock(
     LLVMBuilderRef builder,
     Block* block) {
 
-  BlockState childBlockState(globalState->addressNumberer, parentBlockState);
+  BlockState childBlockState(globalState->addressNumberer, parentBlockState, std::nullopt);
 
   auto resultLE =
       translateExpression(globalState, functionState, &childBlockState, builder, block->inner);

Midas/src/c-compiler/function/expression.cpp

@@ -18,5 +18,5 @@ Ref translateConstruct(
     const std::vector<Ref>& memberRefs) {
   return globalState->getRegion(desiredReference)
       ->allocate(
-          makeEmptyTupleRef(globalState), from, functionState, builder, desiredReference, memberRefs);
+          makeVoidRef(globalState), from, functionState, builder, desiredReference, memberRefs);
 }

Midas/src/c-compiler/function/expressions/block.cpp

@@ -60,5 +60,5 @@ Ref translateDestructure(
 
   buildFlare(FL(), globalState, functionState, builder);
 
-  return makeEmptyTupleRef(globalState);
+  return makeVoidRef(globalState);
 }