Add prereqs check and docs for building on mac (microsoft#1649)

Created to help with microsoft#1642

---------

Co-authored-by: César Zaragoza Cortés <cesarzc@microsoft.com>

Author: idavis

README.md

@@ -27,6 +27,15 @@ To build this repository there are dependencies that need to be installed. These
 
 - Python (<https://python.org>)
 - Rust (<https://www.rust-lang.org/tools/install>)
+  - On all platforms, the `wasm32-unknown-unknown` must be installed to build the WASM based components
+    ```shell
+    rustup target add wasm32-unknown-unknown
+    ```
+  - On MacOS, ensure that both `aarch64` and `x86_64` targets are installed or you will encounter linking errors.
+    ```shell
+    rustup target add x86_64-apple-darwin
+    rustup target add aarch64-apple-darwin
+    ```
 - Node.js (<https://nodejs.org/>)
 - wasm-pack (<https://rustwasm.github.io/wasm-pack/installer/>)
 - A [C compiler](https://docs.rs/cc/latest/cc/#compile-time-requirements)

allocator/mimalloc-sys/src/lib.rs

@@ -8,7 +8,7 @@ pub static MI_ALIGNMENT_MAX: usize = 1024 * 1024; // 1 MiB
 extern "C" {
     /// Allocate size bytes aligned by alignment.
     /// size: the number of bytes to allocate
-    /// alignment: the minimal alignment of the allocated memory. Must be less than MI_ALIGNMENT_MAX
+    /// alignment: the minimal alignment of the allocated memory. Must be less than `MI_ALIGNMENT_MAX`
     /// returns: a pointer to the allocated memory, or null if out of memory. The returned pointer is aligned by alignment
     pub fn mi_malloc_aligned(size: usize, alignment: usize) -> *mut c_void;
     pub fn mi_zalloc_aligned(size: usize, alignment: usize) -> *mut c_void;

compiler/qsc_partial_eval/src/evaluation_context.rs

@@ -101,7 +101,7 @@ pub struct Scope {
     /// Map that holds the values of local variables.
     hybrid_vars: FxHashMap<LocalVarId, Value>,
     /// Maps variable IDs to mutable variables, which contain their current kind.
-    mutable_vars: FxHashMap<VariableId, MutableVar>,
+    mutable_vars: FxHashMap<VariableId, MutableKind>,
     /// Number of currently active blocks (starting from where this scope was created).
     active_block_count: usize,
 }
@@ -166,12 +166,12 @@ impl Scope {
     }
 
     /// Gets a mutable variable.
-    pub fn find_mutable_var(&self, var_id: VariableId) -> Option<&MutableVar> {
+    pub fn find_mutable_kind(&self, var_id: VariableId) -> Option<&MutableKind> {
         self.mutable_vars.get(&var_id)
     }
 
     /// Gets a mutable mutable variable.
-    pub fn find_mutable_var_mut(&mut self, var_id: VariableId) -> Option<&mut MutableVar> {
+    pub fn find_mutable_var_mut(&mut self, var_id: VariableId) -> Option<&mut MutableKind> {
         self.mutable_vars.get_mut(&var_id)
     }
 
@@ -197,11 +197,11 @@ impl Scope {
     }
 
     // Insert a variable into the mutable variables map.
-    pub fn insert_mutable_var(&mut self, var_id: VariableId, mutable_var: MutableVar) {
+    pub fn insert_mutable_var(&mut self, var_id: VariableId, mutable_kind: MutableKind) {
         let Entry::Vacant(vacant) = self.mutable_vars.entry(var_id) else {
             panic!("mutable variable should not already exist");
         };
-        vacant.insert(mutable_var);
+        vacant.insert(mutable_kind);
     }
 
     /// Determines whether we are currently evaluating a branch within the scope.
@@ -318,11 +318,7 @@ fn map_eval_value_to_value_kind(value: &Value) -> ValueKind {
     }
 }
 
-pub struct MutableVar {
-    pub id: LocalVarId,
-    pub kind: MutableKind,
-}
-
+#[derive(Clone, Copy, Debug)]
 pub enum MutableKind {
     Static(Literal),
     Dynamic,

compiler/qsc_partial_eval/src/lib.rs

@@ -10,8 +10,7 @@ mod management;
 
 use core::panic;
 use evaluation_context::{
-    Arg, BlockNode, BranchControlFlow, EvalControlFlow, EvaluationContext, MutableKind, MutableVar,
-    Scope,
+    Arg, BlockNode, BranchControlFlow, EvalControlFlow, EvaluationContext, MutableKind, Scope,
 };
 use management::{QuantumIntrinsicsChecker, ResourceManager};
 use miette::Diagnostic;
@@ -223,11 +222,11 @@ impl<'a> PartialEvaluator<'a> {
         }
 
         // Always bind the value to the hybrid map but do it differently depending of the value type.
-        if let Some((var_id, mutable_var)) = self.try_create_mutable_variable(ident.id, &value) {
+        if let Some((var_id, mutable_kind)) = self.try_create_mutable_variable(ident.id, &value) {
             // Keep track of whether the mutable variable is static or dynamic.
             self.eval_context
                 .get_current_scope_mut()
-                .insert_mutable_var(var_id, mutable_var);
+                .insert_mutable_var(var_id, mutable_kind);
         } else {
             self.bind_value_in_hybrid_map(ident, value);
         }
@@ -1743,10 +1742,8 @@ impl<'a> PartialEvaluator<'a> {
                 // the variable if it is static at this moment.
                 if let Value::Var(var) = bound_value {
                     let current_scope = self.eval_context.get_current_scope();
-                    if let Some(MutableVar {
-                        kind: MutableKind::Static(literal),
-                        ..
-                    }) = current_scope.find_mutable_var(var.id.into())
+                    if let Some(MutableKind::Static(literal)) =
+                        current_scope.find_mutable_kind(var.id.into())
                     {
                         map_rir_literal_to_eval_value(*literal)
                     } else {
@@ -2164,7 +2161,7 @@ impl<'a> PartialEvaluator<'a> {
         &mut self,
         local_var_id: LocalVarId,
         value: &Value,
-    ) -> Option<(rir::VariableId, MutableVar)> {
+    ) -> Option<(rir::VariableId, MutableKind)> {
         // Check if we can create a mutable variable for this value.
         let var_ty = try_get_eval_var_type(value)?;
 
@@ -2189,11 +2186,8 @@ impl<'a> PartialEvaluator<'a> {
             Operand::Literal(literal) => MutableKind::Static(literal),
             Operand::Variable(_) => MutableKind::Dynamic,
         };
-        let mutable_var = MutableVar {
-            id: local_var_id,
-            kind: mutable_kind,
-        };
-        Some((var_id, mutable_var))
+
+        Some((var_id, mutable_kind))
     }
 
     fn get_or_insert_callable(&mut self, callable: Callable) -> CallableId {
@@ -2485,8 +2479,9 @@ impl<'a> PartialEvaluator<'a> {
             if matches!(rhs_operand, Operand::Variable(_))
                 || current_scope.is_currently_evaluating_branch()
             {
-                if let Some(mutable_var) = current_scope.find_mutable_var_mut(rir_var.variable_id) {
-                    mutable_var.kind = MutableKind::Dynamic;
+                if let Some(mutable_kind) = current_scope.find_mutable_var_mut(rir_var.variable_id)
+                {
+                    *mutable_kind = MutableKind::Dynamic;
                 }
             }
         } else {

compiler/qsc_rca/src/common.rs

@@ -18,11 +18,10 @@ use std::{
     fmt::{Debug, Formatter},
 };
 
-/// A represenation of a local symbol.
+/// A representation of a local symbol.
 #[derive(Clone, Debug)]
 pub struct Local {
     pub var: LocalVarId,
-    pub pat: PatId,
     pub ty: Ty,
     pub kind: LocalKind,
 }
@@ -58,7 +57,6 @@ pub fn initialize_locals_map(input_params: &Vec<InputParam>) -> FxHashMap<LocalV
                 id,
                 Local {
                     var: id,
-                    pat: param.pat,
                     ty: param.ty.clone(),
                     kind: LocalKind::InputParam(param.index),
                 },

compiler/qsc_rca/src/core.rs

@@ -1313,7 +1313,6 @@ impl<'a> Analyzer<'a> {
         let application_instance = self.get_current_application_instance_mut();
         let local = Local {
             var: ident.id,
-            pat: pat.id,
             ty: pat.ty.clone(),
             kind: local_kind,
         };
@@ -2479,7 +2478,6 @@ fn derive_specialization_controls(
         match &pat.kind {
             PatKind::Bind(ident) => Some(Local {
                 var: ident.id,
-                pat: pat_id,
                 ty: pat.ty.clone(),
                 kind: LocalKind::SpecInput,
             }),

compiler/qsc_rca/src/cycle_detection.rs

@@ -56,7 +56,6 @@ impl<'a> CycleDetector<'a> {
                 locals_map.insert(
                     ident.id,
                     Local {
-                        pat: pat_id,
                         var: ident.id,
                         ty: pat.ty.clone(),
                         kind,

prereqs.py

@@ -26,6 +26,15 @@
 print = functools.partial(print, flush=True)
 
 
+def get_installed_rust_targets() -> str:
+    try:
+        args = ["rustup", "target", "list", "--installed"]
+        return subprocess.check_output(args, universal_newlines=True)
+    except subprocess.CalledProcessError as e:
+        message = f"Unable to determine installed rust targets: {str(e)}"
+        raise Exception(message)
+
+
 def check_prereqs(install=False):
     ### Check the Python version ###
     if (
@@ -110,6 +119,24 @@ def check_prereqs(install=False):
     else:
         raise Exception("Unable to determine the clippy version")
 
+    installed_rust_targets = get_installed_rust_targets()
+
+    # Ensure the required wasm target is installed
+    target = "wasm32-unknown-unknown"
+    if target not in installed_rust_targets:
+        print("WASM rust target is not installed.")
+        print("Please install the missing target by running:")
+        print("rustup target add wasm32-unknown-unknown")
+
+    # On MacOS, ensure the required targets are installed
+    if platform.system() == "Darwin":
+        targets = ["aarch64-apple-darwin", "x86_64-apple-darwin"]
+        if not all(target in installed_rust_targets for target in targets):
+            print("One or both rust targets are not installed.")
+            print("Please install the missing targets by running:")
+            print("rustup target add aarch64-apple-darwin")
+            print("rustup target add x86_64-apple-darwin")
+
     ### Check the Node.js version ###
     try:
         node_version = subprocess.check_output(["node", "-v"])

resource_estimator/src/counts.rs

@@ -9,13 +9,7 @@ use num_complex::Complex;
 use qsc::{interpret::Value, Backend};
 use rand::{rngs::StdRng, Rng, SeedableRng};
 use rustc_hash::FxHashMap;
-use std::{
-    array,
-    cell::RefCell,
-    f64::{consts::PI, EPSILON},
-    fmt::Debug,
-    iter::Sum,
-};
+use std::{array, cell::RefCell, f64::consts::PI, fmt::Debug, iter::Sum};
 
 use crate::system::LogicalResourceCounts;
 
@@ -456,7 +450,7 @@ impl Backend for LogicalCounter {
 
     fn rz(&mut self, theta: f64, q: usize) {
         let multiple = (theta / (PI / 4.0)).round();
-        if ((multiple * (PI / 4.0)) - theta).abs() <= EPSILON {
+        if ((multiple * (PI / 4.0)) - theta).abs() <= f64::EPSILON {
             let multiple = (multiple as i64).rem_euclid(8) as u64;
             if multiple & 1 == 1 {
                 self.t(q);