From 79593b4235efc031ed9b95c0b301cef66b4ab88c Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Wed, 14 Aug 2024 09:19:09 -0500
Subject: [PATCH] feat: add `unsafe` blocks for calling unconstrained code from
 constrained functions (#4429)

# Description

## Problem\*

Resolves <!-- Link to GitHub Issue -->

## Summary\*

This is an experimental PR to play around with unsafe blocks as a method
to make it clearer when unconstrained values are entering the circuit to
avoid under-constrained errors.

Calls to unconstrained functions will now fail to compile unless inside
of an `unsafe` block. Note that any code inside of an `unsafe` block
still lays down constraints as usual so it's possible to fully constrain
the return values from any unconstrained function calls before returning
a safe value out from the block.


## Additional Context



## Documentation\*

Check one:
- [ ] No documentation needed.
- [ ] Documentation included in this PR.
- [ ] **[Exceptional Case]** Documentation to be submitted in a separate
PR.

# PR Checklist\*

- [ ] I have tested the changes locally.
- [ ] I have formatted the changes with [Prettier](https://prettier.io/)
and/or `cargo fmt` on default settings.

---------

Co-authored-by: Ary Borenszweig <asterite@gmail.com>
Co-authored-by: jfecher <jake@aztecprotocol.com>
---
 aztec_macros/src/utils/parse_utils.rs         |   5 +-
 compiler/noirc_driver/src/abi_gen.rs          |   2 +-
 .../src/ssa/ssa_gen/context.rs                |   2 +-
 compiler/noirc_frontend/src/ast/expression.rs |   2 +
 compiler/noirc_frontend/src/ast/mod.rs        |   7 +-
 compiler/noirc_frontend/src/ast/statement.rs  |  10 +-
 compiler/noirc_frontend/src/debug/mod.rs      |  24 ++-
 .../src/elaborator/expressions.rs             |  18 ++-
 compiler/noirc_frontend/src/elaborator/mod.rs |   9 +-
 .../noirc_frontend/src/elaborator/traits.rs   |  13 +-
 .../noirc_frontend/src/elaborator/types.rs    |  36 +++--
 .../src/hir/comptime/hir_to_display_ast.rs    |   7 +-
 .../src/hir/comptime/interpreter.rs           |   1 +
 .../interpreter/builtin/builtin_helpers.rs    |   4 +-
 .../src/hir/type_check/errors.rs              |   5 +
 compiler/noirc_frontend/src/hir_def/expr.rs   |   1 +
 .../noirc_frontend/src/hir_def/function.rs    |   4 +-
 compiler/noirc_frontend/src/hir_def/traits.rs |   8 +-
 compiler/noirc_frontend/src/hir_def/types.rs  | 115 +++++++++----
 compiler/noirc_frontend/src/lexer/token.rs    |   3 +
 .../src/monomorphization/ast.rs               |  13 +-
 .../src/monomorphization/mod.rs               |  45 ++++--
 compiler/noirc_frontend/src/node_interner.rs  |  19 ++-
 compiler/noirc_frontend/src/parser/parser.rs  |  13 +-
 .../noirc_frontend/src/parser/parser/types.rs |  12 +-
 compiler/noirc_frontend/src/tests.rs          | 152 ++++++++++++++++++
 compiler/noirc_printable_type/src/lib.rs      |   1 +
 docs/docs/noir/concepts/unconstrained.md      |   9 +-
 noir_stdlib/src/array.nr                      |  20 ++-
 noir_stdlib/src/collections/bounded_vec.nr    |   4 +-
 noir_stdlib/src/collections/map.nr            |   4 +-
 noir_stdlib/src/collections/umap.nr           |   6 +-
 noir_stdlib/src/field/bn254.nr                |  50 +++---
 noir_stdlib/src/hash/mod.nr                   |   4 +-
 noir_stdlib/src/lib.nr                        |  18 ++-
 noir_stdlib/src/{unsafe.nr => mem.nr}         |   1 +
 noir_stdlib/src/meta/mod.nr                   |   4 +-
 noir_stdlib/src/option.nr                     |   2 +-
 noir_stdlib/src/slice.nr                      |   2 +-
 noir_stdlib/src/uint128.nr                    |  62 ++++---
 .../array_length_defaulting/src/main.nr       |   2 +-
 .../brillig_mut_ref_from_acir/src/main.nr     |   4 +-
 .../regression_5008/src/main.nr               |   4 +-
 .../turbofish_generic_count/src/main.nr       |   2 +-
 .../unconstrained_ref/src/main.nr             |   4 +-
 .../arithmetic_generics/src/main.nr           |   4 +-
 .../brillig_cast/src/main.nr                  |  12 +-
 .../src/main.nr                               |  14 +-
 .../src/main.nr                               |  34 ++--
 .../brillig_modulo/src/main.nr                |  28 ++--
 .../brillig_slice_input/src/main.nr           |  12 +-
 .../comptime_fmt_strings/src/main.nr          |   2 +-
 .../macros_in_comptime/src/main.nr            |   4 +-
 .../zeroed_slice/src/main.nr                  |   2 +-
 .../check_uncostrained_regression/src/main.nr |   4 +-
 .../brillig_assert_fail/src/main.nr           |   6 +-
 .../brillig_assert_msg_runtime/src/main.nr    |   6 +-
 .../src/main.nr                               |   4 +-
 .../regression_5202/src/main.nr               |   8 +-
 .../acir_inside_brillig_recursion/src/main.nr |   4 +-
 .../aes128_encrypt/src/main.nr                |  21 ++-
 .../src/main.nr                               |   6 +-
 .../execution_success/bigint/src/main.nr      |   4 +-
 .../brillig_acir_as_brillig/src/main.nr       |   8 +-
 .../brillig_array_to_slice/src/main.nr        |  10 +-
 .../brillig_arrays/src/main.nr                |   6 +-
 .../brillig_assert/src/main.nr                |   4 +-
 .../brillig_blake2s/src/main.nr               |   4 +-
 .../src/main.nr                               |   4 +-
 .../brillig_calls/src/main.nr                 |  10 +-
 .../brillig_calls_array/src/main.nr           |   6 +-
 .../brillig_calls_conditionals/src/main.nr    |  10 +-
 .../brillig_conditional/src/main.nr           |   4 +-
 .../brillig_ecdsa_secp256k1/src/main.nr       |   4 +-
 .../brillig_ecdsa_secp256r1/src/main.nr       |   4 +-
 .../brillig_fns_as_values/src/main.nr         |  20 +--
 .../brillig_hash_to_field/src/main.nr         |   4 +-
 .../brillig_identity_function/src/main.nr     |  22 +--
 .../brillig_keccak/src/main.nr                |  26 +--
 .../brillig_loop/src/main.nr                  |   6 +-
 .../brillig_nested_arrays/src/main.nr         |  16 +-
 .../execution_success/brillig_not/src/main.nr |   6 +-
 .../brillig_oracle/src/main.nr                |  30 ++--
 .../brillig_recursion/src/main.nr             |   4 +-
 .../brillig_sha256/src/main.nr                |   4 +-
 .../brillig_unitialised_arrays/src/main.nr    |   6 +-
 .../execution_success/databus/src/main.nr     |   4 +-
 .../execution_success/generics/src/main.nr    |   2 +-
 .../global_consts/src/main.nr                 |   2 +-
 .../is_unconstrained/src/main.nr              |   4 +-
 .../nested_arrays_from_brillig/src/main.nr    |   4 +-
 .../regression_4124/src/main.nr               |   2 +-
 .../regression_5435/src/main.nr               |   4 +-
 .../execution_success/slice_regex/src/main.nr |   8 +-
 .../execution_success/u16_support/src/main.nr |   4 +-
 .../execution_success/uhashmap/src/main.nr    |   8 +-
 .../execution_success/unit_value/src/main.nr  |   2 +-
 .../noir_test_success/mock_oracle/src/main.nr | 112 +++++++------
 .../out_of_bounds_alignment/src/main.nr       |   4 +-
 .../regression_4561/src/main.nr               |   8 +-
 tooling/lsp/src/requests/completion.rs        |  12 +-
 .../lsp/src/requests/completion/builtins.rs   |   2 +
 tooling/lsp/src/requests/hover.rs             |   2 +-
 tooling/lsp/src/requests/inlay_hint.rs        |  10 +-
 tooling/nargo_fmt/src/rewrite/expr.rs         |   3 +
 tooling/nargo_fmt/src/rewrite/typ.rs          |   6 +-
 tooling/nargo_fmt/tests/expected/fn.nr        |   2 +
 tooling/nargo_fmt/tests/expected/unsafe.nr    |   8 +
 tooling/nargo_fmt/tests/input/fn.nr           |   2 +
 tooling/nargo_fmt/tests/input/unsafe.nr       |   8 +
 110 files changed, 943 insertions(+), 406 deletions(-)
 rename noir_stdlib/src/{unsafe.nr => mem.nr} (99%)
 create mode 100644 tooling/nargo_fmt/tests/expected/unsafe.nr
 create mode 100644 tooling/nargo_fmt/tests/input/unsafe.nr

diff --git a/aztec_macros/src/utils/parse_utils.rs b/aztec_macros/src/utils/parse_utils.rs
index 3b3813da6ee..6b5db103c0b 100644
--- a/aztec_macros/src/utils/parse_utils.rs
+++ b/aztec_macros/src/utils/parse_utils.rs
@@ -267,6 +267,9 @@ fn empty_expression(expression: &mut Expression) {
         ExpressionKind::Comptime(block_expression, _span) => {
             empty_block_expression(block_expression);
         }
+        ExpressionKind::Unsafe(block_expression, _span) => {
+            empty_block_expression(block_expression);
+        }
         ExpressionKind::Quote(..) | ExpressionKind::Resolved(_) | ExpressionKind::Error => (),
         ExpressionKind::AsTraitPath(path) => {
             empty_unresolved_type(&mut path.typ);
@@ -325,7 +328,7 @@ fn empty_unresolved_type(unresolved_type: &mut UnresolvedType) {
             empty_unresolved_type(unresolved_type)
         }
         UnresolvedTypeData::Tuple(unresolved_types) => empty_unresolved_types(unresolved_types),
-        UnresolvedTypeData::Function(args, ret, _env) => {
+        UnresolvedTypeData::Function(args, ret, _env, _) => {
             empty_unresolved_types(args);
             empty_unresolved_type(ret);
         }
diff --git a/compiler/noirc_driver/src/abi_gen.rs b/compiler/noirc_driver/src/abi_gen.rs
index 87181b285de..e2692349baa 100644
--- a/compiler/noirc_driver/src/abi_gen.rs
+++ b/compiler/noirc_driver/src/abi_gen.rs
@@ -107,7 +107,7 @@ pub(super) fn abi_type_from_hir_type(context: &Context, typ: &Type) -> AbiType {
         | Type::Forall(..)
         | Type::Quoted(_)
         | Type::Slice(_)
-        | Type::Function(_, _, _) => unreachable!("{typ} cannot be used in the abi"),
+        | Type::Function(_, _, _, _) => unreachable!("{typ} cannot be used in the abi"),
         Type::FmtString(_, _) => unreachable!("format strings cannot be used in the abi"),
         Type::MutableReference(_) => unreachable!("&mut cannot be used in the abi"),
     }
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index e16f6697c70..084584beab3 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -248,7 +248,7 @@ impl<'a> FunctionContext<'a> {
             }
             ast::Type::Unit => panic!("convert_non_tuple_type called on a unit type"),
             ast::Type::Tuple(_) => panic!("convert_non_tuple_type called on a tuple: {typ}"),
-            ast::Type::Function(_, _, _) => Type::Function,
+            ast::Type::Function(_, _, _, _) => Type::Function,
             ast::Type::Slice(_) => panic!("convert_non_tuple_type called on a slice: {typ}"),
             ast::Type::MutableReference(element) => {
                 // Recursive call to panic if element is a tuple
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index aab995c49a1..a3ce069b204 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -36,6 +36,7 @@ pub enum ExpressionKind {
     Quote(Tokens),
     Unquote(Box<Expression>),
     Comptime(BlockExpression, Span),
+    Unsafe(BlockExpression, Span),
     AsTraitPath(AsTraitPath),
 
     // This variant is only emitted when inlining the result of comptime
@@ -587,6 +588,7 @@ impl Display for ExpressionKind {
             Lambda(lambda) => lambda.fmt(f),
             Parenthesized(sub_expr) => write!(f, "({sub_expr})"),
             Comptime(block, _) => write!(f, "comptime {block}"),
+            Unsafe(block, _) => write!(f, "unsafe {block}"),
             Error => write!(f, "Error"),
             Resolved(_) => write!(f, "?Resolved"),
             Unquote(expr) => write!(f, "$({expr})"),
diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index 8e27f0bdda9..7b5b64e7089 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -127,6 +127,7 @@ pub enum UnresolvedTypeData {
         /*args:*/ Vec<UnresolvedType>,
         /*ret:*/ Box<UnresolvedType>,
         /*env:*/ Box<UnresolvedType>,
+        /*unconstrained:*/ bool,
     ),
 
     /// The type of quoted code for metaprogramming
@@ -222,7 +223,11 @@ impl std::fmt::Display for UnresolvedTypeData {
             Bool => write!(f, "bool"),
             String(len) => write!(f, "str<{len}>"),
             FormatString(len, elements) => write!(f, "fmt<{len}, {elements}"),
-            Function(args, ret, env) => {
+            Function(args, ret, env, unconstrained) => {
+                if *unconstrained {
+                    write!(f, "unconstrained ")?;
+                }
+
                 let args = vecmap(args, ToString::to_string).join(", ");
 
                 match &env.as_ref().typ {
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index 5d9a97fa6cf..10ae7a1e62f 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -100,7 +100,9 @@ impl StatementKind {
             StatementKind::Expression(expr) => {
                 match (&expr.kind, semi, last_statement_in_block) {
                     // Semicolons are optional for these expressions
-                    (ExpressionKind::Block(_), semi, _) | (ExpressionKind::If(_), semi, _) => {
+                    (ExpressionKind::Block(_), semi, _)
+                    | (ExpressionKind::Unsafe(..), semi, _)
+                    | (ExpressionKind::If(_), semi, _) => {
                         if semi.is_some() {
                             StatementKind::Semi(expr)
                         } else {
@@ -745,8 +747,10 @@ impl ForRange {
                 let block = ExpressionKind::Block(BlockExpression {
                     statements: vec![let_array, for_loop],
                 });
-                let kind = StatementKind::Expression(Expression::new(block, for_loop_span));
-                Statement { kind, span: for_loop_span }
+                Statement {
+                    kind: StatementKind::Expression(Expression::new(block, for_loop_span)),
+                    span: for_loop_span,
+                }
             }
         }
     }
diff --git a/compiler/noirc_frontend/src/debug/mod.rs b/compiler/noirc_frontend/src/debug/mod.rs
index 598ffed1433..2856bb55276 100644
--- a/compiler/noirc_frontend/src/debug/mod.rs
+++ b/compiler/noirc_frontend/src/debug/mod.rs
@@ -493,7 +493,9 @@ pub fn build_debug_crate_file() -> String {
                 __debug_var_assign_oracle(var_id, value);
             }
             pub fn __debug_var_assign<T>(var_id: u32, value: T) {
-                __debug_var_assign_inner(var_id, value);
+                unsafe {{
+                    __debug_var_assign_inner(var_id, value);
+                }}
             }
 
             #[oracle(__debug_var_drop)]
@@ -502,7 +504,9 @@ pub fn build_debug_crate_file() -> String {
                 __debug_var_drop_oracle(var_id);
             }
             pub fn __debug_var_drop(var_id: u32) {
-                __debug_var_drop_inner(var_id);
+                unsafe {{
+                    __debug_var_drop_inner(var_id);
+                }}
             }
 
             #[oracle(__debug_fn_enter)]
@@ -511,7 +515,9 @@ pub fn build_debug_crate_file() -> String {
                 __debug_fn_enter_oracle(fn_id);
             }
             pub fn __debug_fn_enter(fn_id: u32) {
-                __debug_fn_enter_inner(fn_id);
+                unsafe {{
+                    __debug_fn_enter_inner(fn_id);
+                }}
             }
 
             #[oracle(__debug_fn_exit)]
@@ -520,7 +526,9 @@ pub fn build_debug_crate_file() -> String {
                 __debug_fn_exit_oracle(fn_id);
             }
             pub fn __debug_fn_exit(fn_id: u32) {
-                __debug_fn_exit_inner(fn_id);
+                unsafe {{
+                    __debug_fn_exit_inner(fn_id);
+                }}
             }
 
             #[oracle(__debug_dereference_assign)]
@@ -529,7 +537,9 @@ pub fn build_debug_crate_file() -> String {
                 __debug_dereference_assign_oracle(var_id, value);
             }
             pub fn __debug_dereference_assign<T>(var_id: u32, value: T) {
-                __debug_dereference_assign_inner(var_id, value);
+                unsafe {{
+                    __debug_dereference_assign_inner(var_id, value);
+                }}
             }
         "#
         .to_string(),
@@ -553,7 +563,9 @@ pub fn build_debug_crate_file() -> String {
                     __debug_oracle_member_assign_{n}(var_id, value, {vars});
                 }}
                 pub fn __debug_member_assign_{n}<T, Index>(var_id: u32, value: T, {var_sig}) {{
-                    __debug_inner_member_assign_{n}(var_id, value, {vars});
+                    unsafe {{
+                        __debug_inner_member_assign_{n}(var_id, value, {vars});
+                    }}
                 }}
 
             "#
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index 5ba448f890e..5611c3ce0d0 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -58,6 +58,9 @@ impl<'context> Elaborator<'context> {
             ExpressionKind::Comptime(comptime, _) => {
                 return self.elaborate_comptime_block(comptime, expr.span)
             }
+            ExpressionKind::Unsafe(block_expression, _) => {
+                self.elaborate_unsafe_block(block_expression)
+            }
             ExpressionKind::Resolved(id) => return (id, self.interner.id_type(id)),
             ExpressionKind::Error => (HirExpression::Error, Type::Error),
             ExpressionKind::Unquote(_) => {
@@ -105,6 +108,19 @@ impl<'context> Elaborator<'context> {
         (HirBlockExpression { statements }, block_type)
     }
 
+    fn elaborate_unsafe_block(&mut self, block: BlockExpression) -> (HirExpression, Type) {
+        // Before entering the block we cache the old value of `in_unsafe_block` so it can be restored.
+        let old_in_unsafe_block = self.in_unsafe_block;
+        self.in_unsafe_block = true;
+
+        let (hir_block_expression, typ) = self.elaborate_block_expression(block);
+
+        // Finally, we restore the original value of `self.in_unsafe_block`.
+        self.in_unsafe_block = old_in_unsafe_block;
+
+        (HirExpression::Unsafe(hir_block_expression), typ)
+    }
+
     fn elaborate_literal(&mut self, literal: Literal, span: Span) -> (HirExpression, Type) {
         use HirExpression::Literal as Lit;
         match literal {
@@ -710,7 +726,7 @@ impl<'context> Elaborator<'context> {
 
         let captures = lambda_context.captures;
         let expr = HirExpression::Lambda(HirLambda { parameters, return_type, body, captures });
-        (expr, Type::Function(arg_types, Box::new(body_type), Box::new(env_type)))
+        (expr, Type::Function(arg_types, Box::new(body_type), Box::new(env_type), false))
     }
 
     fn elaborate_quote(&mut self, mut tokens: Tokens) -> (HirExpression, Type) {
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index e60308aaddd..da35ca77316 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -97,6 +97,7 @@ pub struct Elaborator<'context> {
 
     file: FileId,
 
+    in_unsafe_block: bool,
     nested_loops: usize,
 
     /// Contains a mapping of the current struct or functions's generics to
@@ -194,6 +195,7 @@ impl<'context> Elaborator<'context> {
             interner,
             def_maps,
             file: FileId::dummy(),
+            in_unsafe_block: false,
             nested_loops: 0,
             generics: Vec::new(),
             lambda_stack: Vec::new(),
@@ -802,7 +804,12 @@ impl<'context> Elaborator<'context> {
 
         let return_type = Box::new(self.resolve_type(func.return_type()));
 
-        let mut typ = Type::Function(parameter_types, return_type, Box::new(Type::Unit));
+        let mut typ = Type::Function(
+            parameter_types,
+            return_type,
+            Box::new(Type::Unit),
+            func.def.is_unconstrained,
+        );
 
         if !generics.is_empty() {
             typ = Type::Forall(generics, Box::new(typ));
diff --git a/compiler/noirc_frontend/src/elaborator/traits.rs b/compiler/noirc_frontend/src/elaborator/traits.rs
index 1e48fdd07e7..52407746258 100644
--- a/compiler/noirc_frontend/src/elaborator/traits.rs
+++ b/compiler/noirc_frontend/src/elaborator/traits.rs
@@ -145,8 +145,9 @@ impl<'context> Elaborator<'context> {
                     };
 
                     let no_environment = Box::new(Type::Unit);
+                    // TODO: unconstrained
                     let function_type =
-                        Type::Function(arguments, Box::new(return_type), no_environment);
+                        Type::Function(arguments, Box::new(return_type), no_environment, false);
 
                     functions.push(TraitFunction {
                         name: name.clone(),
@@ -345,9 +346,15 @@ fn check_function_type_matches_expected_type(
 ) {
     let mut bindings = TypeBindings::new();
     // Shouldn't need to unify envs, they should always be equal since they're both free functions
-    if let (Type::Function(params_a, ret_a, _env_a), Type::Function(params_b, ret_b, _env_b)) =
-        (expected, actual)
+    if let (
+        Type::Function(params_a, ret_a, _env_a, _unconstrained_a),
+        Type::Function(params_b, ret_b, _env_b, _unconstrained_b),
+    ) = (expected, actual)
     {
+        // TODO: we don't yet allow marking a trait function or a trait impl function as unconstrained,
+        // so both values will always be false here. Once we support that, we should check that both
+        // match (adding a test for it).
+
         if params_a.len() == params_b.len() {
             for (i, (a, b)) in params_a.iter().zip(params_b.iter()).enumerate() {
                 if a.try_unify(b, &mut bindings).is_err() {
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index f8ba994f66b..1f43bdf3ecd 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -125,7 +125,7 @@ impl<'context> Elaborator<'context> {
             Tuple(fields) => {
                 Type::Tuple(vecmap(fields, |field| self.resolve_type_inner(field, kind)))
             }
-            Function(args, ret, env) => {
+            Function(args, ret, env, unconstrained) => {
                 let args = vecmap(args, |arg| self.resolve_type_inner(arg, kind));
                 let ret = Box::new(self.resolve_type_inner(*ret, kind));
 
@@ -139,7 +139,7 @@ impl<'context> Elaborator<'context> {
 
                 match *env {
                     Type::Unit | Type::Tuple(_) | Type::NamedGeneric(_, _, _) => {
-                        Type::Function(args, ret, env)
+                        Type::Function(args, ret, env, unconstrained)
                     }
                     _ => {
                         self.push_err(ResolverError::InvalidClosureEnvironment {
@@ -735,8 +735,8 @@ impl<'context> Elaborator<'context> {
             return Type::Error;
         }
 
-        for (param, (arg, _, arg_span)) in fn_params.iter().zip(callsite_args) {
-            self.unify(arg, param, || TypeCheckError::TypeMismatch {
+        for (param, (arg, arg_expr_id, arg_span)) in fn_params.iter().zip(callsite_args) {
+            self.unify_with_coercions(arg, param, *arg_expr_id, || TypeCheckError::TypeMismatch {
                 expected_typ: param.to_string(),
                 expr_typ: arg.to_string(),
                 expr_span: *arg_span,
@@ -763,7 +763,8 @@ impl<'context> Elaborator<'context> {
                 let ret = self.interner.next_type_variable();
                 let args = vecmap(args, |(arg, _, _)| arg);
                 let env_type = self.interner.next_type_variable();
-                let expected = Type::Function(args, Box::new(ret.clone()), Box::new(env_type));
+                let expected =
+                    Type::Function(args, Box::new(ret.clone()), Box::new(env_type), false);
 
                 if let Err(error) = binding.try_bind(expected, span) {
                     self.push_err(error);
@@ -772,7 +773,7 @@ impl<'context> Elaborator<'context> {
             }
             // The closure env is ignored on purpose: call arguments never place
             // constraints on closure environments.
-            Type::Function(parameters, ret, _env) => {
+            Type::Function(parameters, ret, _env, _unconstrained) => {
                 self.bind_function_type_impl(&parameters, &ret, &args, span)
             }
             Type::Error => Type::Error,
@@ -1128,7 +1129,7 @@ impl<'context> Elaborator<'context> {
         let (method_type, mut bindings) = method.typ.clone().instantiate(self.interner);
 
         match method_type {
-            Type::Function(args, _, _) => {
+            Type::Function(args, _, _, _) => {
                 // We can cheat a bit and match against only the object type here since no operator
                 // overload uses other generic parameters or return types aside from the object type.
                 let expected_object_type = &args[0];
@@ -1314,9 +1315,22 @@ impl<'context> Elaborator<'context> {
 
         let is_current_func_constrained = self.in_constrained_function();
 
-        let is_unconstrained_call = self.is_unconstrained_call(call.func);
+        let func_type_is_unconstrained =
+            if let Type::Function(_args, _ret, _env, unconstrained) = &func_type {
+                *unconstrained
+            } else {
+                false
+            };
+
+        let is_unconstrained_call =
+            func_type_is_unconstrained || self.is_unconstrained_call(call.func);
         let crossing_runtime_boundary = is_current_func_constrained && is_unconstrained_call;
         if crossing_runtime_boundary {
+            if !self.in_unsafe_block {
+                self.push_err(TypeCheckError::Unsafe { span });
+                return Type::Error;
+            }
+
             let called_func_id = self
                 .interner
                 .lookup_function_from_expr(&call.func)
@@ -1373,9 +1387,9 @@ impl<'context> Elaborator<'context> {
         object: &mut ExprId,
     ) {
         let expected_object_type = match function_type {
-            Type::Function(args, _, _) => args.first(),
+            Type::Function(args, _, _, _) => args.first(),
             Type::Forall(_, typ) => match typ.as_ref() {
-                Type::Function(args, _, _) => args.first(),
+                Type::Function(args, _, _, _) => args.first(),
                 typ => unreachable!("Unexpected type for function: {typ}"),
             },
             typ => unreachable!("Unexpected type for function: {typ}"),
@@ -1577,7 +1591,7 @@ impl<'context> Elaborator<'context> {
                 }
             }
 
-            Type::Function(parameters, return_type, _env) => {
+            Type::Function(parameters, return_type, _env, _unconstrained) => {
                 for parameter in parameters {
                     Self::find_numeric_generics_in_type(parameter, found);
                 }
diff --git a/compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs b/compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs
index bc48b2875c8..853697220b3 100644
--- a/compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs
@@ -202,6 +202,9 @@ impl HirExpression {
             HirExpression::Comptime(block) => {
                 ExpressionKind::Comptime(block.to_display_ast(interner), span)
             }
+            HirExpression::Unsafe(block) => {
+                ExpressionKind::Unsafe(block.to_display_ast(interner), span)
+            }
             HirExpression::Quote(block) => ExpressionKind::Quote(block.clone()),
 
             // A macro was evaluated here: return the quoted result
@@ -340,11 +343,11 @@ impl Type {
                 let name = Path::from_single(name.as_ref().clone(), Span::default());
                 UnresolvedTypeData::TraitAsType(name, Vec::new())
             }
-            Type::Function(args, ret, env) => {
+            Type::Function(args, ret, env, unconstrained) => {
                 let args = vecmap(args, |arg| arg.to_display_ast());
                 let ret = Box::new(ret.to_display_ast());
                 let env = Box::new(env.to_display_ast());
-                UnresolvedTypeData::Function(args, ret, env)
+                UnresolvedTypeData::Function(args, ret, env, *unconstrained)
             }
             Type::MutableReference(element) => {
                 let element = Box::new(element.to_display_ast());
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 72b92e288c7..093dc370eb6 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -472,6 +472,7 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
             HirExpression::Lambda(lambda) => self.evaluate_lambda(lambda, id),
             HirExpression::Quote(tokens) => self.evaluate_quote(tokens, id),
             HirExpression::Comptime(block) => self.evaluate_block(block),
+            HirExpression::Unsafe(block) => self.evaluate_block(block),
             HirExpression::Unquote(tokens) => {
                 // An Unquote expression being found is indicative of a macro being
                 // expanded within another comptime fn which we don't currently support.
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs
index 56f6c11974f..482a5e019d4 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs
@@ -357,7 +357,7 @@ where
 
 pub(super) fn replace_func_meta_parameters(typ: &mut Type, parameter_types: Vec<Type>) {
     match typ {
-        Type::Function(parameters, _, _) => {
+        Type::Function(parameters, _, _, _) => {
             *parameters = parameter_types;
         }
         Type::Forall(_, typ) => replace_func_meta_parameters(typ, parameter_types),
@@ -367,7 +367,7 @@ pub(super) fn replace_func_meta_parameters(typ: &mut Type, parameter_types: Vec<
 
 pub(super) fn replace_func_meta_return_type(typ: &mut Type, return_type: Type) {
     match typ {
-        Type::Function(_, ret, _) => {
+        Type::Function(_, ret, _, _) => {
             *ret = Box::new(return_type);
         }
         Type::Forall(_, typ) => replace_func_meta_return_type(typ, return_type),
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 8eba8215f84..380753d8198 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -136,6 +136,8 @@ pub enum TypeCheckError {
     UnconstrainedReferenceToConstrained { span: Span },
     #[error("Slices cannot be returned from an unconstrained runtime to a constrained runtime")]
     UnconstrainedSliceReturnToConstrained { span: Span },
+    #[error("Call to unconstrained function is unsafe and must be in an unconstrained function or unsafe block")]
+    Unsafe { span: Span },
     #[error("Slices must have constant length")]
     NonConstantSliceLength { span: Span },
     #[error("Only sized types may be used in the entry point to a program")]
@@ -356,6 +358,9 @@ impl<'a> From<&'a TypeCheckError> for Diagnostic {
                 let msg = "turbofish (`::<_>`)  usage at this position isn't supported yet";
                 Diagnostic::simple_error(msg.to_string(), "".to_string(), *span)
             },
+            TypeCheckError::Unsafe { span } => {
+                Diagnostic::simple_warning(error.to_string(), String::new(), *span)
+            }
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index e85d30f0c32..8137e74da30 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -37,6 +37,7 @@ pub enum HirExpression {
     Quote(Tokens),
     Unquote(Tokens),
     Comptime(HirBlockExpression),
+    Unsafe(HirBlockExpression),
     Error,
 }
 
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index 6b66cf1ab4a..29b0cb7b8af 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -194,9 +194,9 @@ impl FuncMeta {
     /// Gives the (uninstantiated) return type of this function.
     pub fn return_type(&self) -> &Type {
         match &self.typ {
-            Type::Function(_, ret, _env) => ret,
+            Type::Function(_, ret, _env, _unconstrained) => ret,
             Type::Forall(_, typ) => match typ.as_ref() {
-                Type::Function(_, ret, _env) => ret,
+                Type::Function(_, ret, _env, _unconstrained) => ret,
                 _ => unreachable!(),
             },
             _ => unreachable!(),
diff --git a/compiler/noirc_frontend/src/hir_def/traits.rs b/compiler/noirc_frontend/src/hir_def/traits.rs
index 099c9ea78f7..df6ccc0492c 100644
--- a/compiler/noirc_frontend/src/hir_def/traits.rs
+++ b/compiler/noirc_frontend/src/hir_def/traits.rs
@@ -142,9 +142,9 @@ impl std::fmt::Display for Trait {
 impl TraitFunction {
     pub fn arguments(&self) -> &[Type] {
         match &self.typ {
-            Type::Function(args, _, _) => args,
+            Type::Function(args, _, _, _) => args,
             Type::Forall(_, typ) => match typ.as_ref() {
-                Type::Function(args, _, _) => args,
+                Type::Function(args, _, _, _) => args,
                 _ => unreachable!("Trait function does not have a function type"),
             },
             _ => unreachable!("Trait function does not have a function type"),
@@ -161,9 +161,9 @@ impl TraitFunction {
 
     pub fn return_type(&self) -> &Type {
         match &self.typ {
-            Type::Function(_, return_type, _) => return_type,
+            Type::Function(_, return_type, _, _) => return_type,
             Type::Forall(_, typ) => match typ.as_ref() {
-                Type::Function(_, return_type, _) => return_type,
+                Type::Function(_, return_type, _, _) => return_type,
                 _ => unreachable!("Trait function does not have a function type"),
             },
             _ => unreachable!("Trait function does not have a function type"),
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index c2d55284ef9..d2f499950f1 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -88,7 +88,12 @@ pub enum Type {
     /// the environment should be `Unit` by default,
     /// for closures it should contain a `Tuple` type with the captured
     /// variable types.
-    Function(Vec<Type>, /*return_type:*/ Box<Type>, /*environment:*/ Box<Type>),
+    Function(
+        Vec<Type>,
+        /*return_type:*/ Box<Type>,
+        /*environment:*/ Box<Type>,
+        /*unconstrained*/ bool,
+    ),
 
     /// &mut T
     MutableReference(Box<Type>),
@@ -663,7 +668,11 @@ impl std::fmt::Display for Type {
                 let typevars = vecmap(typevars, |var| var.id().to_string());
                 write!(f, "forall {}. {}", typevars.join(" "), typ)
             }
-            Type::Function(args, ret, env) => {
+            Type::Function(args, ret, env, unconstrained) => {
+                if *unconstrained {
+                    write!(f, "unconstrained ")?;
+                }
+
                 let closure_env_text = match **env {
                     Type::Unit => "".to_string(),
                     _ => format!("[{env}]"),
@@ -855,7 +864,7 @@ impl Type {
             Type::Tuple(fields) => {
                 fields.iter().any(|field| field.contains_numeric_typevar(target_id))
             }
-            Type::Function(parameters, return_type, env) => {
+            Type::Function(parameters, return_type, env, _unconstrained) => {
                 parameters.iter().any(|parameter| parameter.contains_numeric_typevar(target_id))
                     || return_type.contains_numeric_typevar(target_id)
                     || env.contains_numeric_typevar(target_id)
@@ -935,7 +944,7 @@ impl Type {
                     field.find_numeric_type_vars(found_names);
                 }
             }
-            Type::Function(parameters, return_type, env) => {
+            Type::Function(parameters, return_type, env, _unconstrained) => {
                 for parameter in parameters.iter() {
                     parameter.find_numeric_type_vars(found_names);
                 }
@@ -992,7 +1001,7 @@ impl Type {
             Type::FmtString(_, _)
             | Type::TypeVariable(_, _)
             | Type::NamedGeneric(_, _, _)
-            | Type::Function(_, _, _)
+            | Type::Function(_, _, _, _)
             | Type::MutableReference(_)
             | Type::Forall(_, _)
             | Type::Quoted(_)
@@ -1041,7 +1050,7 @@ impl Type {
             Type::FmtString(_, _)
             // To enable this we would need to determine the size of the closure outputs at compile-time.
             // This is possible as long as the output size is not dependent upon a witness condition.
-            | Type::Function(_, _, _)
+            | Type::Function(_, _, _, _)
             | Type::Slice(_)
             | Type::MutableReference(_)
             | Type::Forall(_, _)
@@ -1079,7 +1088,7 @@ impl Type {
             | Type::Slice(_)
             | Type::TypeVariable(_, _)
             | Type::NamedGeneric(_, _, _)
-            | Type::Function(_, _, _)
+            | Type::Function(_, _, _, _)
             | Type::FmtString(_, _)
             | Type::InfixExpr(..)
             | Type::Error => true,
@@ -1210,7 +1219,7 @@ impl Type {
             | Type::TypeVariable(_, _)
             | Type::TraitAsType(..)
             | Type::NamedGeneric(_, _, _)
-            | Type::Function(_, _, _)
+            | Type::Function(_, _, _, _)
             | Type::MutableReference(_)
             | Type::Forall(_, _)
             | Type::Constant(_)
@@ -1578,8 +1587,11 @@ impl Type {
                 }
             }
 
-            (Function(params_a, ret_a, env_a), Function(params_b, ret_b, env_b)) => {
-                if params_a.len() == params_b.len() {
+            (
+                Function(params_a, ret_a, env_a, unconstrained_a),
+                Function(params_b, ret_b, env_b, unconstrained_b),
+            ) => {
+                if unconstrained_a == unconstrained_b && params_a.len() == params_b.len() {
                     for (a, b) in params_a.iter().zip(params_b.iter()) {
                         a.try_unify(b, bindings)?;
                     }
@@ -1770,12 +1782,38 @@ impl Type {
     ) {
         let mut bindings = TypeBindings::new();
 
-        if let Err(UnificationError) = self.try_unify(expected, &mut bindings) {
-            if !self.try_array_to_slice_coercion(expected, expression, interner) {
-                errors.push(make_error());
-            }
-        } else {
+        if let Ok(()) = self.try_unify(expected, &mut bindings) {
             Type::apply_type_bindings(bindings);
+            return;
+        }
+
+        if self.try_array_to_slice_coercion(expected, expression, interner) {
+            return;
+        }
+
+        // Try to coerce `fn (..) -> T` to `unconstrained fn (..) -> T`
+        if let Some(coerced_self) = self.try_fn_to_unconstrained_fn_coercion(expected) {
+            coerced_self.unify_with_coercions(expected, expression, interner, errors, make_error);
+            return;
+        }
+
+        errors.push(make_error());
+    }
+
+    // If `self` and `expected` are function types, tries to coerce `self` to `expected`.
+    // Returns None if no coercion can be applied, otherwise returns `self` coerced to `expected`.
+    fn try_fn_to_unconstrained_fn_coercion(&self, expected: &Type) -> Option<Type> {
+        // If `self` and `expected` are function types, `self` can be coerced to `expected`
+        // if `self` is unconstrained and `expected` is not. The other way around is an error, though.
+        if let (
+            Type::Function(params, ret, env, unconstrained_self),
+            Type::Function(_, _, _, unconstrained_expected),
+        ) = (self.follow_bindings(), expected.follow_bindings())
+        {
+            (!unconstrained_self && unconstrained_expected)
+                .then(|| Type::Function(params, ret, env, unconstrained_expected))
+        } else {
+            None
         }
     }
 
@@ -1791,13 +1829,17 @@ impl Type {
         let target = target.follow_bindings();
 
         if let (Type::Array(_size, element1), Type::Slice(element2)) = (&this, &target) {
-            // Still have to ensure the element types match.
-            // Don't need to issue an error here if not, it will be done in unify_with_coercions
-            let mut bindings = TypeBindings::new();
-            if element1.try_unify(element2, &mut bindings).is_ok() {
-                convert_array_expression_to_slice(expression, this, target, interner);
-                Self::apply_type_bindings(bindings);
-                return true;
+            // We can only do the coercion if the `as_slice` method exists.
+            // This is usually true, but some tests don't have access to the standard library.
+            if let Some(as_slice) = interner.lookup_primitive_method(&this, "as_slice") {
+                // Still have to ensure the element types match.
+                // Don't need to issue an error here if not, it will be done in unify_with_coercions
+                let mut bindings = TypeBindings::new();
+                if element1.try_unify(element2, &mut bindings).is_ok() {
+                    convert_array_expression_to_slice(expression, this, target, as_slice, interner);
+                    Self::apply_type_bindings(bindings);
+                    return true;
+                }
             }
         }
         false
@@ -2072,13 +2114,13 @@ impl Type {
                 let typ = Box::new(typ.substitute_helper(type_bindings, substitute_bound_typevars));
                 Type::Forall(typevars.clone(), typ)
             }
-            Type::Function(args, ret, env) => {
+            Type::Function(args, ret, env, unconstrained) => {
                 let args = vecmap(args, |arg| {
                     arg.substitute_helper(type_bindings, substitute_bound_typevars)
                 });
                 let ret = Box::new(ret.substitute_helper(type_bindings, substitute_bound_typevars));
                 let env = Box::new(env.substitute_helper(type_bindings, substitute_bound_typevars));
-                Type::Function(args, ret, env)
+                Type::Function(args, ret, env, *unconstrained)
             }
             Type::MutableReference(element) => Type::MutableReference(Box::new(
                 element.substitute_helper(type_bindings, substitute_bound_typevars),
@@ -2134,7 +2176,7 @@ impl Type {
             Type::Forall(typevars, typ) => {
                 !typevars.iter().any(|var| var.id() == target_id) && typ.occurs(target_id)
             }
-            Type::Function(args, ret, env) => {
+            Type::Function(args, ret, env, _unconstrained) => {
                 args.iter().any(|arg| arg.occurs(target_id))
                     || ret.occurs(target_id)
                     || env.occurs(target_id)
@@ -2188,11 +2230,11 @@ impl Type {
                 self.clone()
             }
 
-            Function(args, ret, env) => {
+            Function(args, ret, env, unconstrained) => {
                 let args = vecmap(args, |arg| arg.follow_bindings());
                 let ret = Box::new(ret.follow_bindings());
                 let env = Box::new(env.follow_bindings());
-                Function(args, ret, env)
+                Function(args, ret, env, *unconstrained)
             }
 
             MutableReference(element) => MutableReference(Box::new(element.follow_bindings())),
@@ -2284,7 +2326,7 @@ impl Type {
                     *self = Type::TypeVariable(var.clone(), TypeVariableKind::Normal);
                 }
             }
-            Type::Function(args, ret, env) => {
+            Type::Function(args, ret, env, _unconstrained) => {
                 for arg in args {
                     arg.replace_named_generics_with_type_variables();
                 }
@@ -2313,12 +2355,9 @@ fn convert_array_expression_to_slice(
     expression: ExprId,
     array_type: Type,
     target_type: Type,
+    as_slice_method: crate::node_interner::FuncId,
     interner: &mut NodeInterner,
 ) {
-    let as_slice_method = interner
-        .lookup_primitive_method(&array_type, "as_slice")
-        .expect("Expected 'as_slice' method to be present in Noir's stdlib");
-
     let as_slice_id = interner.function_definition_id(as_slice_method);
     let location = interner.expr_location(&expression);
     let as_slice = HirExpression::Ident(HirIdent::non_trait_method(as_slice_id, location), None);
@@ -2339,7 +2378,8 @@ fn convert_array_expression_to_slice(
     interner.push_expr_location(func, location.span, location.file);
     interner.push_expr_type(expression, target_type.clone());
 
-    let func_type = Type::Function(vec![array_type], Box::new(target_type), Box::new(Type::Unit));
+    let func_type =
+        Type::Function(vec![array_type], Box::new(target_type), Box::new(Type::Unit), false);
     interner.push_expr_type(func, func_type);
 }
 
@@ -2431,10 +2471,11 @@ impl From<&Type> for PrintableType {
             Type::TypeVariable(_, _) => unreachable!(),
             Type::NamedGeneric(..) => unreachable!(),
             Type::Forall(..) => unreachable!(),
-            Type::Function(arguments, return_type, env) => PrintableType::Function {
+            Type::Function(arguments, return_type, env, unconstrained) => PrintableType::Function {
                 arguments: arguments.iter().map(|arg| arg.into()).collect(),
                 return_type: Box::new(return_type.as_ref().into()),
                 env: Box::new(env.as_ref().into()),
+                unconstrained: *unconstrained,
             },
             Type::MutableReference(typ) => {
                 PrintableType::MutableReference { typ: Box::new(typ.as_ref().into()) }
@@ -2519,7 +2560,11 @@ impl std::fmt::Debug for Type {
                 let typevars = vecmap(typevars, |var| format!("{:?}", var));
                 write!(f, "forall {}. {:?}", typevars.join(" "), typ)
             }
-            Type::Function(args, ret, env) => {
+            Type::Function(args, ret, env, unconstrained) => {
+                if *unconstrained {
+                    write!(f, "unconstrained ")?;
+                }
+
                 let closure_env_text = match **env {
                     Type::Unit => "".to_string(),
                     _ => format!(" with env {env:?}"),
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index c4145c62791..b9b4bdef9aa 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -930,6 +930,7 @@ pub enum Keyword {
     TypeType,
     Unchecked,
     Unconstrained,
+    Unsafe,
     Use,
     Where,
     While,
@@ -983,6 +984,7 @@ impl fmt::Display for Keyword {
             Keyword::TypeType => write!(f, "Type"),
             Keyword::Unchecked => write!(f, "unchecked"),
             Keyword::Unconstrained => write!(f, "unconstrained"),
+            Keyword::Unsafe => write!(f, "unsafe"),
             Keyword::Use => write!(f, "use"),
             Keyword::Where => write!(f, "where"),
             Keyword::While => write!(f, "while"),
@@ -1039,6 +1041,7 @@ impl Keyword {
             "StructDefinition" => Keyword::StructDefinition,
             "unchecked" => Keyword::Unchecked,
             "unconstrained" => Keyword::Unconstrained,
+            "unsafe" => Keyword::Unsafe,
             "use" => Keyword::Use,
             "where" => Keyword::Where,
             "while" => Keyword::While,
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index f2ed9433e61..f7bcfd58b72 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -288,7 +288,12 @@ pub enum Type {
     Tuple(Vec<Type>),
     Slice(Box<Type>),
     MutableReference(Box<Type>),
-    Function(/*args:*/ Vec<Type>, /*ret:*/ Box<Type>, /*env:*/ Box<Type>),
+    Function(
+        /*args:*/ Vec<Type>,
+        /*ret:*/ Box<Type>,
+        /*env:*/ Box<Type>,
+        /*unconstrained:*/ bool,
+    ),
 }
 
 impl Type {
@@ -419,7 +424,11 @@ impl std::fmt::Display for Type {
                 let elements = vecmap(elements, ToString::to_string);
                 write!(f, "({})", elements.join(", "))
             }
-            Type::Function(args, ret, env) => {
+            Type::Function(args, ret, env, unconstrained) => {
+                if *unconstrained {
+                    write!(f, "unconstrained ")?;
+                }
+
                 let args = vecmap(args, ToString::to_string);
                 let closure_env_text = match **env {
                     Type::Unit => "".to_string(),
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 5ac730db400..510b81d9acb 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -442,6 +442,7 @@ impl<'interner> Monomorphizer<'interner> {
             },
             HirExpression::Literal(HirLiteral::Unit) => ast::Expression::Block(vec![]),
             HirExpression::Block(block) => self.block(block.statements)?,
+            HirExpression::Unsafe(block) => self.block(block.statements)?,
 
             HirExpression::Prefix(prefix) => {
                 let rhs = self.expr(prefix.rhs)?;
@@ -1003,15 +1004,17 @@ impl<'interner> Monomorphizer<'interner> {
                 ast::Type::Tuple(fields)
             }
 
-            HirType::Function(args, ret, env) => {
+            HirType::Function(args, ret, env, unconstrained) => {
                 let args = try_vecmap(args, |x| Self::convert_type(x, location))?;
                 let ret = Box::new(Self::convert_type(ret, location)?);
                 let env = Self::convert_type(env, location)?;
                 match &env {
-                    ast::Type::Unit => ast::Type::Function(args, ret, Box::new(env)),
+                    ast::Type::Unit => {
+                        ast::Type::Function(args, ret, Box::new(env), *unconstrained)
+                    }
                     ast::Type::Tuple(_elements) => ast::Type::Tuple(vec![
                         env.clone(),
-                        ast::Type::Function(args, ret, Box::new(env)),
+                        ast::Type::Function(args, ret, Box::new(env), *unconstrained),
                     ]),
                     _ => {
                         unreachable!(
@@ -1100,7 +1103,7 @@ impl<'interner> Monomorphizer<'interner> {
                 Ok(())
             }
 
-            HirType::Function(args, ret, env) => {
+            HirType::Function(args, ret, env, _) => {
                 for arg in args {
                     Self::check_type(arg, location)?;
                 }
@@ -1122,7 +1125,7 @@ impl<'interner> Monomorphizer<'interner> {
             true
         } else if let ast::Type::Tuple(elements) = t {
             if elements.len() == 2 {
-                matches!(elements[1], ast::Type::Function(_, _, _))
+                matches!(elements[1], ast::Type::Function(_, _, _, _))
             } else {
                 false
             }
@@ -1132,7 +1135,7 @@ impl<'interner> Monomorphizer<'interner> {
     }
 
     fn is_function_closure_type(&self, t: &ast::Type) -> bool {
-        if let ast::Type::Function(_, _, env) = t {
+        if let ast::Type::Function(_, _, env, _) = t {
             let e = (*env).clone();
             matches!(*e, ast::Type::Tuple(_captures))
         } else {
@@ -1499,8 +1502,12 @@ impl<'interner> Monomorphizer<'interner> {
         };
         self.push_function(id, function);
 
-        let typ =
-            ast::Type::Function(parameter_types, Box::new(ret_type), Box::new(ast::Type::Unit));
+        let typ = ast::Type::Function(
+            parameter_types,
+            Box::new(ret_type),
+            Box::new(ast::Type::Unit),
+            false,
+        );
 
         let name = lambda_name.to_owned();
         Ok(ast::Expression::Ident(ast::Ident {
@@ -1568,7 +1575,7 @@ impl<'interner> Monomorphizer<'interner> {
             })?);
 
         let expr_type = self.interner.id_type(expr);
-        let env_typ = if let types::Type::Function(_, _, function_env_type) = expr_type {
+        let env_typ = if let types::Type::Function(_, _, function_env_type, _) = expr_type {
             Self::convert_type(&function_env_type, location)?
         } else {
             unreachable!("expected a Function type for a Lambda node")
@@ -1598,8 +1605,12 @@ impl<'interner> Monomorphizer<'interner> {
         let body = self.expr(lambda.body)?;
         self.lambda_envs_stack.pop();
 
-        let lambda_fn_typ: ast::Type =
-            ast::Type::Function(parameter_types, Box::new(ret_type), Box::new(env_typ.clone()));
+        let lambda_fn_typ: ast::Type = ast::Type::Function(
+            parameter_types,
+            Box::new(ret_type),
+            Box::new(env_typ.clone()),
+            false,
+        );
         let lambda_fn = ast::Expression::Ident(ast::Ident {
             definition: Definition::Function(id),
             mutable: false,
@@ -1649,7 +1660,7 @@ impl<'interner> Monomorphizer<'interner> {
         Ok((block_let_stmt, closure_ident))
     }
 
-    /// Implements std::unsafe::zeroed by returning an appropriate zeroed
+    /// Implements std::unsafe_func::zeroed by returning an appropriate zeroed
     /// ast literal or collection node for the given type. Note that for functions
     /// there is no obvious zeroed value so this should be considered unsafe to use.
     fn zeroed_value_of_type(
@@ -1689,9 +1700,8 @@ impl<'interner> Monomorphizer<'interner> {
             ast::Type::Tuple(fields) => ast::Expression::Tuple(vecmap(fields, |field| {
                 self.zeroed_value_of_type(field, location)
             })),
-            ast::Type::Function(parameter_types, ret_type, env) => {
-                self.create_zeroed_function(parameter_types, ret_type, env, location)
-            }
+            ast::Type::Function(parameter_types, ret_type, env, unconstrained) => self
+                .create_zeroed_function(parameter_types, ret_type, env, *unconstrained, location),
             ast::Type::Slice(element_type) => {
                 ast::Expression::Literal(ast::Literal::Slice(ast::ArrayLiteral {
                     contents: vec![],
@@ -1713,7 +1723,7 @@ impl<'interner> Monomorphizer<'interner> {
     }
 
     // Creating a zeroed function value is almost always an error if it is used later,
-    // Hence why std::unsafe::zeroed is unsafe.
+    // Hence why std::unsafe_func::zeroed is unsafe.
     //
     // To avoid confusing later passes, we arbitrarily choose to construct a function
     // that satisfies the input type by discarding all its parameters and returning a
@@ -1723,6 +1733,7 @@ impl<'interner> Monomorphizer<'interner> {
         parameter_types: &[ast::Type],
         ret_type: &ast::Type,
         env_type: &ast::Type,
+        unconstrained: bool,
         location: noirc_errors::Location,
     ) -> ast::Expression {
         let lambda_name = "zeroed_lambda";
@@ -1737,7 +1748,6 @@ impl<'interner> Monomorphizer<'interner> {
         let return_type = ret_type.clone();
         let name = lambda_name.to_owned();
 
-        let unconstrained = false;
         let function = ast::Function {
             id,
             name,
@@ -1759,6 +1769,7 @@ impl<'interner> Monomorphizer<'interner> {
                 parameter_types.to_owned(),
                 Box::new(ret_type.clone()),
                 Box::new(env_type.clone()),
+                unconstrained,
             ),
         })
     }
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 9b9bfd463b9..9cffebb0cee 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -1204,14 +1204,19 @@ impl NodeInterner {
 
     pub fn id_type_substitute_trait_as_type(&self, def_id: DefinitionId) -> Type {
         let typ = self.definition_type(def_id);
-        if let Type::Function(args, ret, env) = &typ {
+        if let Type::Function(args, ret, env, unconstrained) = &typ {
             let def = self.definition(def_id);
             if let Type::TraitAsType(..) = ret.as_ref() {
                 if let DefinitionKind::Function(func_id) = def.kind {
                     let f = self.function(&func_id);
                     let func_body = f.as_expr();
                     let ret_type = self.id_type(func_body);
-                    let new_type = Type::Function(args.clone(), Box::new(ret_type), env.clone());
+                    let new_type = Type::Function(
+                        args.clone(),
+                        Box::new(ret_type),
+                        env.clone(),
+                        *unconstrained,
+                    );
                     return new_type;
                 }
             }
@@ -1790,7 +1795,7 @@ impl NodeInterner {
                 let the_trait = self.get_trait(trait_id);
                 self.ordering_type = match &the_trait.methods[0].typ {
                     Type::Forall(_, typ) => match typ.as_ref() {
-                        Type::Function(_, return_type, _) => Some(return_type.as_ref().clone()),
+                        Type::Function(_, return_type, _, _) => Some(return_type.as_ref().clone()),
                         other => unreachable!("Expected function type for `cmp`, found {}", other),
                     },
                     other => unreachable!("Expected Forall type for `cmp`, found {}", other),
@@ -1993,7 +1998,7 @@ impl NodeInterner {
         };
 
         let env = Box::new(Type::Unit);
-        (Type::Function(args, Box::new(ret.clone()), env), ret)
+        (Type::Function(args, Box::new(ret.clone()), env, false), ret)
     }
 
     /// Returns the type of a prefix operator (which is always a function), along with its return type.
@@ -2002,7 +2007,7 @@ impl NodeInterner {
         let args = vec![rhs_type];
         let ret = self.id_type(operator_expr);
         let env = Box::new(Type::Unit);
-        (Type::Function(args, Box::new(ret.clone()), env), ret)
+        (Type::Function(args, Box::new(ret.clone()), env, false), ret)
     }
 
     pub fn is_in_lsp_mode(&self) -> bool {
@@ -2043,7 +2048,7 @@ impl Methods {
         // at most 1 matching method in this list.
         for method in self.iter() {
             match interner.function_meta(&method).typ.instantiate(interner).0 {
-                Type::Function(args, _, _) => {
+                Type::Function(args, _, _, _) => {
                     if let Some(object) = args.first() {
                         let mut bindings = TypeBindings::new();
 
@@ -2094,7 +2099,7 @@ fn get_type_method_key(typ: &Type) -> Option<TypeMethodKey> {
         Type::FmtString(_, _) => Some(FmtString),
         Type::Unit => Some(Unit),
         Type::Tuple(_) => Some(Tuple),
-        Type::Function(_, _, _) => Some(Function),
+        Type::Function(_, _, _, _) => Some(Function),
         Type::NamedGeneric(_, _, _) => Some(Generic),
         Type::Quoted(quoted) => Some(Quoted(*quoted)),
         Type::MutableReference(element) => get_type_method_key(element),
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 876fc454565..3de57971beb 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -377,6 +377,7 @@ pub fn block<'a>(
     statement: impl NoirParser<StatementKind> + 'a,
 ) -> impl NoirParser<BlockExpression> + 'a {
     use Token::*;
+
     statement
         .recover_via(statement_recovery())
         .then(just(Semicolon).or_not().map_with_span(|s, span| (s, span)))
@@ -519,6 +520,15 @@ where
         .map(|(block, span)| ExpressionKind::Comptime(block, span))
 }
 
+fn unsafe_expr<'a, S>(statement: S) -> impl NoirParser<ExpressionKind> + 'a
+where
+    S: NoirParser<StatementKind> + 'a,
+{
+    keyword(Keyword::Unsafe)
+        .ignore_then(spanned(block(statement)))
+        .map(|(block, span)| ExpressionKind::Unsafe(block, span))
+}
+
 fn let_statement<'a, P>(
     expr_parser: P,
 ) -> impl NoirParser<((Pattern, UnresolvedType), Expression)> + 'a
@@ -1093,7 +1103,8 @@ where
         },
         lambdas::lambda(expr_parser.clone()),
         block(statement.clone()).map(ExpressionKind::Block),
-        comptime_expr(statement),
+        comptime_expr(statement.clone()),
+        unsafe_expr(statement),
         quote(),
         unquote(expr_parser.clone()),
         variable(),
diff --git a/compiler/noirc_frontend/src/parser/parser/types.rs b/compiler/noirc_frontend/src/parser/parser/types.rs
index 7644c451dff..3db2f24aa58 100644
--- a/compiler/noirc_frontend/src/parser/parser/types.rs
+++ b/compiler/noirc_frontend/src/parser/parser/types.rs
@@ -318,13 +318,17 @@ where
             t.unwrap_or_else(|| UnresolvedTypeData::Unit.with_span(Span::empty(span.end())))
         });
 
-    keyword(Keyword::Fn)
-        .ignore_then(env)
+    keyword(Keyword::Unconstrained)
+        .or_not()
+        .then(keyword(Keyword::Fn))
+        .map(|(unconstrained_token, _fn_token)| unconstrained_token.is_some())
+        .then(env)
         .then(args)
         .then_ignore(just(Token::Arrow))
         .then(type_parser)
-        .map_with_span(|((env, args), ret), span| {
-            UnresolvedTypeData::Function(args, Box::new(ret), Box::new(env)).with_span(span)
+        .map_with_span(|(((unconstrained, env), args), ret), span| {
+            UnresolvedTypeData::Function(args, Box::new(ret), Box::new(env), unconstrained)
+                .with_span(span)
         })
 }
 
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 9124567b4e5..ba39980a0ef 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -2460,6 +2460,158 @@ fn no_super() {
     assert_eq!(span.end(), 9);
 }
 
+#[test]
+fn cannot_call_unconstrained_function_outside_of_unsafe() {
+    let src = r#"
+    fn main() {
+        foo();
+    }
+
+    unconstrained fn foo() {}
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::Unsafe { .. }) = &errors[0].0 else {
+        panic!("Expected an 'unsafe' error, got {:?}", errors[0].0);
+    };
+}
+
+#[test]
+fn cannot_call_unconstrained_first_class_function_outside_of_unsafe() {
+    let src = r#"
+    fn main() {
+        let func = foo;
+        func();
+    }
+
+    unconstrained fn foo() {}
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::Unsafe { .. }) = &errors[0].0 else {
+        panic!("Expected an 'unsafe' error, got {:?}", errors[0].0);
+    };
+}
+
+#[test]
+fn cannot_pass_unconstrained_function_to_regular_function() {
+    let src = r#"
+    fn main() {
+        let func = foo;
+        expect_regular(func);
+    }
+
+    unconstrained fn foo() {}
+
+    fn expect_regular(_func: fn() -> ()) {
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    if let CompilationError::TypeError(TypeCheckError::TypeMismatch {
+        expected_typ,
+        expr_typ,
+        ..
+    }) = &errors[0].0
+    {
+        assert_eq!(expected_typ, "fn() -> ()");
+        assert_eq!(expr_typ, "unconstrained fn() -> ()");
+    } else {
+        panic!("Expected a type mismatch error, got {:?}", errors[0].0);
+    };
+}
+
+#[test]
+fn cannot_assign_unconstrained_and_regular_fn_to_variable() {
+    let src = r#"
+    fn main() {
+        let _func = if true { foo } else { bar };
+    }
+
+    fn foo() {}
+    unconstrained fn bar() {}
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::Context { err, .. }) = &errors[0].0 else {
+        panic!("Expected a context error, got {:?}", errors[0].0);
+    };
+
+    if let TypeCheckError::TypeMismatch { expected_typ, expr_typ, .. } = err.as_ref() {
+        assert_eq!(expected_typ, "fn() -> ()");
+        assert_eq!(expr_typ, "unconstrained fn() -> ()");
+    } else {
+        panic!("Expected a type mismatch error, got {:?}", errors[0].0);
+    };
+}
+
+#[test]
+fn can_pass_regular_function_to_unconstrained_function() {
+    let src = r#"
+    fn main() {
+        let func = foo;
+        expect_unconstrained(func);
+    }
+
+    fn foo() {}
+
+    fn expect_unconstrained(_func: unconstrained fn() -> ()) {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn cannot_pass_unconstrained_function_to_constrained_function() {
+    let src = r#"
+    fn main() {
+        let func = foo;
+        expect_regular(func);
+    }
+
+    unconstrained fn foo() {}
+
+    fn expect_regular(_func: fn() -> ()) {}
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::TypeMismatch { .. }) = &errors[0].0 else {
+        panic!("Expected a type mismatch error, got {:?}", errors[0].0);
+    };
+}
+
+#[test]
+fn can_assign_regular_function_to_unconstrained_function_in_explicitly_typed_var() {
+    let src = r#"
+    fn main() {
+        let _func: unconstrained fn() -> () = foo;
+    }
+
+    fn foo() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn can_assign_regular_function_to_unconstrained_function_in_struct_member() {
+    let src = r#"
+    fn main() {
+        let _ = Foo { func: foo };
+    }
+
+    fn foo() {}
+
+    struct Foo {
+        func: unconstrained fn() -> (),
+    }
+    "#;
+    assert_no_errors(src);
+}
+
 #[test]
 fn trait_impl_generics_count_mismatch() {
     let src = r#"
diff --git a/compiler/noirc_printable_type/src/lib.rs b/compiler/noirc_printable_type/src/lib.rs
index dfecd301b35..5ab04c6f576 100644
--- a/compiler/noirc_printable_type/src/lib.rs
+++ b/compiler/noirc_printable_type/src/lib.rs
@@ -40,6 +40,7 @@ pub enum PrintableType {
         arguments: Vec<PrintableType>,
         return_type: Box<PrintableType>,
         env: Box<PrintableType>,
+        unconstrained: bool,
     },
     MutableReference {
         typ: Box<PrintableType>,
diff --git a/docs/docs/noir/concepts/unconstrained.md b/docs/docs/noir/concepts/unconstrained.md
index 96f824c5e42..b5221b8d2dd 100644
--- a/docs/docs/noir/concepts/unconstrained.md
+++ b/docs/docs/noir/concepts/unconstrained.md
@@ -62,11 +62,13 @@ Those are some nice savings already but we can do better. This code is all const
 
 It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
 
-We can then run u72_to_u8 as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+We can then run `u72_to_u8` as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
 
 ```rust
 fn main(num: u72) -> pub [u8; 8] {
-    let out = u72_to_u8(num);
+    let out = unsafe { 
+        u72_to_u8(num) 
+    };
 
     let mut reconstructed_num: u72 = 0;
     for i in 0..8 {
@@ -92,6 +94,9 @@ Backend circuit size: 2902
 
 This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
 
+Note that in order to invoke unconstrained functions we need to wrap them in an `unsafe` block,
+to make it clear that the call is unconstrained.
+
 Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
 
 ## Break and Continue
diff --git a/noir_stdlib/src/array.nr b/noir_stdlib/src/array.nr
index af2bea12c60..cef79e7c7f6 100644
--- a/noir_stdlib/src/array.nr
+++ b/noir_stdlib/src/array.nr
@@ -11,14 +11,20 @@ impl<T, let N: u32> [T; N] {
     }
 
     pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {
-        let sorted_index = self.get_sorting_index(ordering);
-        let mut result = self;
-        // Ensure the indexes are correct
-        for i in 0..N {
-            let pos = find_index(sorted_index, i);
-            assert(sorted_index[pos] == i);
-        }
+        let sorted_index = unsafe {
+            // Safety: These indices are asserted to be the sorted element indices via `find_index`
+            let sorted_index: [u32; N] = self.get_sorting_index(ordering);
+
+            for i in 0..N {
+                let pos = find_index(sorted_index, i);
+                assert(sorted_index[pos] == i);
+            }
+
+            sorted_index
+        };
+
         // Sort the array using the indexes
+        let mut result = self;
         for i in 0..N {
             result[i] = self[sorted_index[i]];
         }
diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index a56d6f60390..a4c0f642a82 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -7,7 +7,7 @@ struct BoundedVec<T, let MaxLen: u32> {
 
 impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
     pub fn new() -> Self {
-        let zeroed = crate::unsafe::zeroed();
+        let zeroed = crate::mem::zeroed();
         BoundedVec { storage: [zeroed; MaxLen], len: 0 }
     }
 
@@ -106,7 +106,7 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
         self.len -= 1;
 
         let elem = self.storage[self.len];
-        self.storage[self.len] = crate::unsafe::zeroed();
+        self.storage[self.len] = crate::mem::zeroed();
         elem
     }
 
diff --git a/noir_stdlib/src/collections/map.nr b/noir_stdlib/src/collections/map.nr
index 8324583632f..bd50f345356 100644
--- a/noir_stdlib/src/collections/map.nr
+++ b/noir_stdlib/src/collections/map.nr
@@ -168,7 +168,9 @@ impl<K, V, let N: u32, B, H> HashMap<K, V, N, B> {
 
         for slot in self._table {
             if slot.is_valid() {
-                let (_, value) = slot.key_value_unchecked();
+                let (_, value) = unsafe {
+                    slot.key_value_unchecked()
+                };
                 values.push(value);
             }
         }
diff --git a/noir_stdlib/src/collections/umap.nr b/noir_stdlib/src/collections/umap.nr
index fe16ef6bca2..86ae79ea644 100644
--- a/noir_stdlib/src/collections/umap.nr
+++ b/noir_stdlib/src/collections/umap.nr
@@ -119,7 +119,9 @@ impl<K, V, B, H> UHashMap<K, V, B> {
         B: BuildHasher<H>,
         H: Hasher {
         // docs:end:contains_key
-        self.get(key).is_some()
+        unsafe {
+            self.get(key)
+        }.is_some()
     }
 
     // Returns true if the map contains no elements.
@@ -438,7 +440,7 @@ where
                 // Not marked as deleted and has key-value.
                 if equal & slot.is_valid(){
                     let (key, value) = slot.key_value_unchecked();
-                    let other_value = other.get(key);
+                    let other_value = unsafe { other.get(key) };
 
                     if other_value.is_none(){
                         equal = false;
diff --git a/noir_stdlib/src/field/bn254.nr b/noir_stdlib/src/field/bn254.nr
index e8db0a30c38..ed0053694c7 100644
--- a/noir_stdlib/src/field/bn254.nr
+++ b/noir_stdlib/src/field/bn254.nr
@@ -66,13 +66,15 @@ unconstrained fn lte_16_hint(x: Field, y: Field) -> bool {
 fn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {
     let (alo, ahi) = a;
     let (blo, bhi) = b;
-    let borrow = lte_16_hint(alo, blo);
+    unsafe {
+        let borrow = lte_16_hint(alo, blo);
 
-    let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;
-    let rhi = ahi - bhi - (borrow as Field);
+        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;
+        let rhi = ahi - bhi - (borrow as Field);
 
-    rlo.assert_max_bit_size(128);
-    rhi.assert_max_bit_size(128);
+        rlo.assert_max_bit_size(128);
+        rhi.assert_max_bit_size(128);
+    }
 }
 
 /// Decompose a single field into two 16 byte fields.
@@ -80,19 +82,21 @@ pub fn decompose(x: Field) -> (Field, Field) {
     if is_unconstrained() {
         compute_decomposition(x)
     } else {
-        // Take hints of the decomposition
-        let (xlo, xhi) = decompose_hint(x);
+        unsafe {
+            // Take hints of the decomposition
+            let (xlo, xhi) = decompose_hint(x);
 
-        // Range check the limbs
-        xlo.assert_max_bit_size(128);
-        xhi.assert_max_bit_size(128);
+            // Range check the limbs
+            xlo.assert_max_bit_size(128);
+            xhi.assert_max_bit_size(128);
 
-        // Check that the decomposition is correct
-        assert_eq(x, xlo + TWO_POW_128 * xhi);
+            // Check that the decomposition is correct
+            assert_eq(x, xlo + TWO_POW_128 * xhi);
 
-        // Assert that the decomposition of P is greater than the decomposition of x
-        assert_gt_limbs((PLO, PHI), (xlo, xhi));
-        (xlo, xhi)
+            // Assert that the decomposition of P is greater than the decomposition of x
+            assert_gt_limbs((PLO, PHI), (xlo, xhi));
+            (xlo, xhi)
+        }
     }
 }
 
@@ -118,14 +122,16 @@ pub fn gt(a: Field, b: Field) -> bool {
         compute_lt(b, a, 32)
     } else if a == b {
         false
-    } else  {
+    } else {
         // Take a hint of the comparison and verify it
-        if lt_32_hint(a, b) {
-            assert_gt(b, a);
-            false
-        } else {
-            assert_gt(a, b);
-            true
+        unsafe {
+            if lt_32_hint(a, b) {
+                assert_gt(b, a);
+                false
+            } else {
+                assert_gt(a, b);
+                true
+            }
         }
     }
 }
diff --git a/noir_stdlib/src/hash/mod.nr b/noir_stdlib/src/hash/mod.nr
index 88dbf83e5bd..8a546e64309 100644
--- a/noir_stdlib/src/hash/mod.nr
+++ b/noir_stdlib/src/hash/mod.nr
@@ -108,7 +108,9 @@ fn __derive_generators<let N: u32, let M: u32>(
     // does not assert the limbs are 128 bits
     // does not assert the decomposition does not overflow the EmbeddedCurveScalar
     fn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {
-    let (xlo, xhi) = crate::field::bn254::decompose_hint(scalar);
+    let (xlo, xhi) = unsafe {
+        crate::field::bn254::decompose_hint(scalar)
+    };
     // Check that the decomposition is correct
     assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);
     EmbeddedCurveScalar { lo: xlo, hi: xhi }
diff --git a/noir_stdlib/src/lib.nr b/noir_stdlib/src/lib.nr
index 2d559c43162..5c4587b69ac 100644
--- a/noir_stdlib/src/lib.nr
+++ b/noir_stdlib/src/lib.nr
@@ -12,7 +12,6 @@ mod sha256;
 mod sha512;
 mod field;
 mod ec;
-mod unsafe;
 mod collections;
 mod compat;
 mod convert;
@@ -28,18 +27,27 @@ mod bigint;
 mod runtime;
 mod meta;
 mod append;
+mod mem;
 
 // Oracle calls are required to be wrapped in an unconstrained function
 // Thus, the only argument to the `println` oracle is expected to always be an ident
 #[oracle(print)]
 unconstrained fn print_oracle<T>(with_newline: bool, input: T) {}
 
-unconstrained pub fn print<T>(input: T) {
-    print_oracle(false, input);
+unconstrained fn print_unconstrained<T>(with_newline: bool, input: T) {
+    print_oracle(with_newline, input);
 }
 
-unconstrained pub fn println<T>(input: T) {
-    print_oracle(true, input);
+pub fn println<T>(input: T) {
+    unsafe {
+        print_unconstrained(true, input);
+    }
+}
+
+pub fn print<T>(input: T) {
+    unsafe {
+        print_unconstrained(false, input);
+    }
 }
 
 #[foreign(recursive_aggregation)]
diff --git a/noir_stdlib/src/unsafe.nr b/noir_stdlib/src/mem.nr
similarity index 99%
rename from noir_stdlib/src/unsafe.nr
rename to noir_stdlib/src/mem.nr
index 542bd31fa84..88d17e20ee3 100644
--- a/noir_stdlib/src/unsafe.nr
+++ b/noir_stdlib/src/mem.nr
@@ -3,3 +3,4 @@
 /// is no guarantee that all zeroes is a valid bit pattern for every type.
 #[builtin(zeroed)]
 pub fn zeroed<T>() -> T {}
+
diff --git a/noir_stdlib/src/meta/mod.nr b/noir_stdlib/src/meta/mod.nr
index 2763685fd0d..ad9d20cb71a 100644
--- a/noir_stdlib/src/meta/mod.nr
+++ b/noir_stdlib/src/meta/mod.nr
@@ -31,7 +31,9 @@ pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted
     let mut result = quote {};
 
     for trait_to_derive in traits {
-        let handler = HANDLERS.get(trait_to_derive);
+        let handler = unsafe {
+            HANDLERS.get(trait_to_derive)
+        };
         assert(handler.is_some(), f"No derive function registered for `{trait_to_derive}`");
 
         let trait_impl = handler.unwrap()(s);
diff --git a/noir_stdlib/src/option.nr b/noir_stdlib/src/option.nr
index df020e75615..8d6d9ef970d 100644
--- a/noir_stdlib/src/option.nr
+++ b/noir_stdlib/src/option.nr
@@ -10,7 +10,7 @@ struct Option<T> {
 impl<T> Option<T> {
     /// Constructs a None value
     pub fn none() -> Self {
-        Self { _is_some: false, _value: crate::unsafe::zeroed() }
+        Self { _is_some: false, _value: crate::mem::zeroed() }
     }
 
     /// Constructs a Some wrapper around the given value
diff --git a/noir_stdlib/src/slice.nr b/noir_stdlib/src/slice.nr
index 8d3f395f080..f9aa98a9ecd 100644
--- a/noir_stdlib/src/slice.nr
+++ b/noir_stdlib/src/slice.nr
@@ -49,7 +49,7 @@ impl<T> [T] {
     pub fn as_array<let N: u32>(self) -> [T; N] {
         assert(self.len() == N);
 
-        let mut array = [crate::unsafe::zeroed(); N];
+        let mut array = [crate::mem::zeroed(); N];
         for i in 0..N {
             array[i] = self[i];
         }
diff --git a/noir_stdlib/src/uint128.nr b/noir_stdlib/src/uint128.nr
index 7b75cf4cae4..a6d980c7f33 100644
--- a/noir_stdlib/src/uint128.nr
+++ b/noir_stdlib/src/uint128.nr
@@ -103,7 +103,9 @@ impl U128 {
         (if ascii < 58 {
             ascii - 48
         } else {
-            let ascii = ascii + 32 * (U128::uconstrained_check_is_upper_ascii(ascii) as u8);
+            let ascii = ascii + 32 * (unsafe {
+                        U128::uconstrained_check_is_upper_ascii(ascii) as u8
+                    });
             assert(ascii >= 97); // enforce >= 'a'
             assert(ascii <= 102); // enforce <= 'f'
             ascii - 87
@@ -212,21 +214,26 @@ impl Mul for U128 {
 
 impl Div for U128 {
     fn div(self: Self, b: U128) -> U128 {
-        let (q,r) = self.unconstrained_div(b);
-        let a = b * q + r;
-        assert_eq(self, a);
-        assert(r < b);
-        q
+        unsafe {
+            let (q,r) = self.unconstrained_div(b);
+            let a = b * q + r;
+            assert_eq(self, a);
+            assert(r < b);
+            q
+        }
     }
 }
 
 impl Rem for U128 {
     fn rem(self: Self, b: U128) -> U128 {
-        let (q,r) = self.unconstrained_div(b);
-        let a = b * q + r;
-        assert_eq(self, a);
-        assert(r < b);
-        r
+        unsafe {
+            let (q,r) = self.unconstrained_div(b);
+            let a = b * q + r;
+            assert_eq(self, a);
+            assert(r < b);
+            
+            r
+        }
     }
 }
 
@@ -439,31 +446,40 @@ mod tests {
         let b= U128::from_u64s_le(0x0, 0xfffffffffffffffe);
         let c= U128::one();
         let d= U128::from_u64s_le(0x0, 0x1);
-        let (q,r) = a.unconstrained_div(b);
-        assert_eq(q, c);
-        assert_eq(r, d);
+        unsafe {
+            let (q,r) = a.unconstrained_div(b);
+            assert_eq(q, c);
+            assert_eq(r, d);
+        }
 
         let a = U128::from_u64s_le(2, 0);
         let b = U128::one();
         // Check the case where a is a multiple of b
-        let (c,d ) = a.unconstrained_div(b);
-        assert_eq((c, d), (a, U128::zero()));
+        unsafe {
+            let (c, d) = a.unconstrained_div(b);
+            assert_eq((c, d), (a, U128::zero()));
+        }
 
         // Check where b is a multiple of a
-        let (c,d) = b.unconstrained_div(a);
-        assert_eq((c, d), (U128::zero(), b));
+        unsafe {
+            let (c,d) = b.unconstrained_div(a);
+            assert_eq((c, d), (U128::zero(), b));
+        }
 
         // Dividing by zero returns 0,0
         let a = U128::from_u64s_le(0x1, 0x0);
         let b = U128::zero();
-        let (c,d)= a.unconstrained_div(b);
-        assert_eq((c, d), (U128::zero(), U128::zero()));
-
+        unsafe {
+            let (c, d)= a.unconstrained_div(b);
+            assert_eq((c, d), (U128::zero(), U128::zero()));
+        }
         // Dividing 1<<127 by 1<<127 (special case)
         let a = U128::from_u64s_le(0x0, pow63 as u64);
         let b = U128::from_u64s_le(0x0, pow63 as u64);
-        let (c,d )= a.unconstrained_div(b);
-        assert_eq((c, d), (U128::one(), U128::zero()));
+        unsafe {
+            let (c, d) = a.unconstrained_div(b);
+            assert_eq((c, d), (U128::one(), U128::zero()));
+        }
     }
 
     #[test]
diff --git a/test_programs/compile_failure/array_length_defaulting/src/main.nr b/test_programs/compile_failure/array_length_defaulting/src/main.nr
index 40543db2870..16902860a16 100644
--- a/test_programs/compile_failure/array_length_defaulting/src/main.nr
+++ b/test_programs/compile_failure/array_length_defaulting/src/main.nr
@@ -1,5 +1,5 @@
 fn main() {
-    let x = std::unsafe::zeroed();
+    let x = std::mem::zeroed();
     foo(x);
 }
 
diff --git a/test_programs/compile_failure/brillig_mut_ref_from_acir/src/main.nr b/test_programs/compile_failure/brillig_mut_ref_from_acir/src/main.nr
index 473ad8e8d6a..f262635e508 100644
--- a/test_programs/compile_failure/brillig_mut_ref_from_acir/src/main.nr
+++ b/test_programs/compile_failure/brillig_mut_ref_from_acir/src/main.nr
@@ -3,6 +3,8 @@ unconstrained fn mut_ref_identity(value: &mut Field) -> Field {
 }
 
 fn main(mut x: Field, y: pub Field) {
-    let returned_x = mut_ref_identity(&mut x);
+    let returned_x = unsafe {
+        mut_ref_identity(&mut x)
+    };
     assert(returned_x == x);
 }
diff --git a/test_programs/compile_failure/regression_5008/src/main.nr b/test_programs/compile_failure/regression_5008/src/main.nr
index 6d9645ee6eb..cf79c22683f 100644
--- a/test_programs/compile_failure/regression_5008/src/main.nr
+++ b/test_programs/compile_failure/regression_5008/src/main.nr
@@ -13,5 +13,7 @@ impl Foo {
 fn main() {
     let foo = Foo { bar: &mut Bar { value: 0 } };
 
-    foo.crash_fn();
+    unsafe {
+        foo.crash_fn()
+    };
 }
diff --git a/test_programs/compile_failure/turbofish_generic_count/src/main.nr b/test_programs/compile_failure/turbofish_generic_count/src/main.nr
index 4091b2f0581..5dc05a3a5c3 100644
--- a/test_programs/compile_failure/turbofish_generic_count/src/main.nr
+++ b/test_programs/compile_failure/turbofish_generic_count/src/main.nr
@@ -6,7 +6,7 @@ struct Bar<T> {
 
 impl<T> Bar<T> {
     fn zeroed<A>(_self: Self) -> A {
-        std::unsafe::zeroed()
+        std::mem::zeroed()
     }
 }
 
diff --git a/test_programs/compile_failure/unconstrained_ref/src/main.nr b/test_programs/compile_failure/unconstrained_ref/src/main.nr
index 1491badaa49..9a4f42469b5 100644
--- a/test_programs/compile_failure/unconstrained_ref/src/main.nr
+++ b/test_programs/compile_failure/unconstrained_ref/src/main.nr
@@ -4,5 +4,7 @@ unconstrained fn uncon_ref() -> &mut Field {
 }
 
 fn main() {
-    let e = uncon_ref();
+    let e = unsafe {
+        uncon_ref()
+    };
 }
diff --git a/test_programs/compile_success_empty/arithmetic_generics/src/main.nr b/test_programs/compile_success_empty/arithmetic_generics/src/main.nr
index d4f71d38413..6cd13ab0e2f 100644
--- a/test_programs/compile_success_empty/arithmetic_generics/src/main.nr
+++ b/test_programs/compile_success_empty/arithmetic_generics/src/main.nr
@@ -11,7 +11,7 @@ fn main() {
 
 fn split_first<T, let N: u32>(array: [T; N]) -> (T, [T; N - 1]) {
     std::static_assert(N != 0, "split_first called on empty array");
-    let mut new_array: [T; N - 1] = std::unsafe::zeroed();
+    let mut new_array: [T; N - 1] = std::mem::zeroed();
 
     for i in 0..N - 1 {
         new_array[i] = array[i + 1];
@@ -21,7 +21,7 @@ fn split_first<T, let N: u32>(array: [T; N]) -> (T, [T; N - 1]) {
 }
 
 fn push<let N: u32>(array: [Field; N], element: Field) -> [Field; N + 1] {
-    let mut result: [_; N + 1] = std::unsafe::zeroed();
+    let mut result: [_; N + 1] = std::mem::zeroed();
     result[array.len()] = element;
 
     for i in 0..array.len() {
diff --git a/test_programs/compile_success_empty/brillig_cast/src/main.nr b/test_programs/compile_success_empty/brillig_cast/src/main.nr
index ecb832468ba..f2bede99d4c 100644
--- a/test_programs/compile_success_empty/brillig_cast/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_cast/src/main.nr
@@ -2,11 +2,13 @@
 // 
 // The features being tested are cast operations on brillig
 fn main() {
-    bool_casts();
-    field_casts();
-    uint_casts();
-    int_casts();
-    mixed_casts();
+    unsafe {
+        bool_casts();
+        field_casts();
+        uint_casts();
+        int_casts();
+        mixed_casts();
+    }
 }
 
 unconstrained fn bool_casts() {
diff --git a/test_programs/compile_success_empty/brillig_field_binary_operations/src/main.nr b/test_programs/compile_success_empty/brillig_field_binary_operations/src/main.nr
index 54f06858846..fedfe48cb0d 100644
--- a/test_programs/compile_success_empty/brillig_field_binary_operations/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_field_binary_operations/src/main.nr
@@ -1,11 +1,13 @@
 // Tests arithmetic operations on fields
 fn main() {
-    let x = 4;
-    let y = 2;
-    assert((x + y) == add(x, y));
-    assert((x - y) == sub(x, y));
-    assert((x * y) == mul(x, y));
-    assert((x / y) == div(x, y));
+    unsafe {
+        let x = 4;
+        let y = 2;
+        assert((x + y) == add(x, y));
+        assert((x - y) == sub(x, y));
+        assert((x * y) == mul(x, y));
+        assert((x / y) == div(x, y));
+    }
 }
 
 unconstrained fn add(x: Field, y: Field) -> Field {
diff --git a/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr b/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr
index 7d3f9459598..7ecc21dbd2f 100644
--- a/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr
@@ -3,28 +3,30 @@ fn main() {
     let x: u32 = 6;
     let y: u32 = 2;
 
-    assert((x + y) == add(x, y));
+    unsafe {
+        assert((x + y) == add(x, y));
 
-    assert((x - y) == sub(x, y));
+        assert((x - y) == sub(x, y));
 
-    assert((x * y) == mul(x, y));
+        assert((x * y) == mul(x, y));
 
-    assert((x / y) == div(x, y));
-    // TODO SSA => ACIR has some issues with i32 ops
-    assert(check_signed_div(6, 2, 3));
+        assert((x / y) == div(x, y));
+        // TODO SSA => ACIR has some issues with i32 ops
+        assert(check_signed_div(6, 2, 3));
 
-    assert(eq(1, 2) == false);
-    assert(eq(1, 1));
+        assert(eq(1, 2) == false);
+        assert(eq(1, 1));
 
-    assert(lt(x, y) == false);
-    assert(lt(y, x));
+        assert(lt(x, y) == false);
+        assert(lt(y, x));
 
-    assert((x & y) == and(x, y));
-    assert((x | y) == or(x, y));
-    // TODO SSA => ACIR has some issues with xor ops
-    assert(check_xor(x, y, 4));
-    assert((x >> y as u8) == shr(x, y as u8));
-    assert((x << y as u8) == shl(x, y as u8));
+        assert((x & y) == and(x, y));
+        assert((x | y) == or(x, y));
+        // TODO SSA => ACIR has some issues with xor ops
+        assert(check_xor(x, y, 4));
+        assert((x >> y as u8) == shr(x, y as u8));
+        assert((x << y as u8) == shl(x, y as u8));
+    }
 }
 
 unconstrained fn add(x: u32, y: u32) -> u32 {
diff --git a/test_programs/compile_success_empty/brillig_modulo/src/main.nr b/test_programs/compile_success_empty/brillig_modulo/src/main.nr
index 195ed31fb08..dff5eadcb55 100644
--- a/test_programs/compile_success_empty/brillig_modulo/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_modulo/src/main.nr
@@ -2,20 +2,22 @@
 // 
 // The features being tested is modulo operations on brillig
 fn main() {
-    assert(modulo(47, 3) == 2);
-    assert(modulo(2, 3) == 2);
-    assert(signed_modulo(5, 3) == 2);
-    assert(signed_modulo(2, 3) == 2);
+    unsafe {
+        assert(modulo(47, 3) == 2);
+        assert(modulo(2, 3) == 2);
+        assert(signed_modulo(5, 3) == 2);
+        assert(signed_modulo(2, 3) == 2);
 
-    let minus_two: i8 = -2; // 254
-    let minus_three: i8 = -3; // 253
-    let minus_five: i8 = -5; // 251
-    // (5 / -3) * -3 + 2 = -1 * -3 + 2 = 3 + 2 = 5
-    assert(signed_modulo(5, minus_three) == 2);
-    // (-5 / 3) * 3 - 2 = -1 * 3 - 2 = -3 - 2 = -5
-    assert(signed_modulo(minus_five, 3) == minus_two);
-    // (-5 / -3) * -3 - 2 = 1 * -3 - 2 = -3 - 2 = -5
-    assert(signed_modulo(minus_five, minus_three) == minus_two);
+        let minus_two: i8 = -2; // 254
+        let minus_three: i8 = -3; // 253
+        let minus_five: i8 = -5; // 251
+        // (5 / -3) * -3 + 2 = -1 * -3 + 2 = 3 + 2 = 5
+        assert(signed_modulo(5, minus_three) == 2);
+        // (-5 / 3) * 3 - 2 = -1 * 3 - 2 = -3 - 2 = -5
+        assert(signed_modulo(minus_five, 3) == minus_two);
+        // (-5 / -3) * -3 - 2 = 1 * -3 - 2 = -3 - 2 = -5
+        assert(signed_modulo(minus_five, minus_three) == minus_two);
+    }
 }
 
 unconstrained fn modulo(x: u32, y: u32) -> u32 {
diff --git a/test_programs/compile_success_empty/brillig_slice_input/src/main.nr b/test_programs/compile_success_empty/brillig_slice_input/src/main.nr
index 8403cb7d4a0..596f364b49f 100644
--- a/test_programs/compile_success_empty/brillig_slice_input/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_slice_input/src/main.nr
@@ -25,8 +25,10 @@ fn main() {
             y: 8,
         }
     ]);
-    let brillig_sum = sum_slice(slice);
-    assert_eq(brillig_sum, 55);
+    unsafe {
+        let brillig_sum = sum_slice(slice);
+        assert_eq(brillig_sum, 55);
+    }
 
     slice = slice.push_back([
         Point {
@@ -38,6 +40,8 @@ fn main() {
             y: 13,
         }
     ]);
-    let brillig_sum = sum_slice(slice);
-    assert_eq(brillig_sum, 100);
+    unsafe {
+        let brillig_sum = sum_slice(slice);
+        assert_eq(brillig_sum, 100);
+    }
 }
diff --git a/test_programs/compile_success_empty/comptime_fmt_strings/src/main.nr b/test_programs/compile_success_empty/comptime_fmt_strings/src/main.nr
index 19572fd15a1..705a1b2ab4e 100644
--- a/test_programs/compile_success_empty/comptime_fmt_strings/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_fmt_strings/src/main.nr
@@ -7,7 +7,7 @@ fn main() {
         // Can't print these at compile-time here since printing to stdout while
         // compiling breaks the test runner.
         let s1 = f"x is {x}, fake interpolation: \{y}, y is {y}";
-        let s2 = std::unsafe::zeroed::<fmtstr<4, ()>>();
+        let s2 = std::mem::zeroed::<fmtstr<4, ()>>();
         (s1, s2)
     };
     assert_eq(s1, "x is 4, fake interpolation: {y}, y is 5");
diff --git a/test_programs/compile_success_empty/macros_in_comptime/src/main.nr b/test_programs/compile_success_empty/macros_in_comptime/src/main.nr
index 52567025e23..31d08d2762d 100644
--- a/test_programs/compile_success_empty/macros_in_comptime/src/main.nr
+++ b/test_programs/compile_success_empty/macros_in_comptime/src/main.nr
@@ -4,7 +4,9 @@ use std::meta::unquote;
 fn main() {
     comptime
     {
-        foo::<3>(5);
+        unsafe {
+            foo::<3>(5)
+        };
         submodule::bar();
     }
 }
diff --git a/test_programs/compile_success_empty/zeroed_slice/src/main.nr b/test_programs/compile_success_empty/zeroed_slice/src/main.nr
index 44ccb2bd595..b35afdbc6c6 100644
--- a/test_programs/compile_success_empty/zeroed_slice/src/main.nr
+++ b/test_programs/compile_success_empty/zeroed_slice/src/main.nr
@@ -1,3 +1,3 @@
 fn main() {
-    let _: [u8] = std::unsafe::zeroed();
+    let _: [u8] = std::mem::zeroed();
 }
diff --git a/test_programs/compile_success_no_bug/check_uncostrained_regression/src/main.nr b/test_programs/compile_success_no_bug/check_uncostrained_regression/src/main.nr
index e93e068f432..33b84c2b702 100644
--- a/test_programs/compile_success_no_bug/check_uncostrained_regression/src/main.nr
+++ b/test_programs/compile_success_no_bug/check_uncostrained_regression/src/main.nr
@@ -15,7 +15,9 @@ unconstrained fn convert(trigger: Trigger) -> ResultType {
 }
 impl Trigger {
     fn execute(self) -> ResultType {
-        let result = convert(self);
+        let result = unsafe {
+            convert(self)
+        };
         assert(result.a == self.x + 1);
         assert(result.b == self.y - 1 + self.z[2]);
         assert(result.c[1] == 0);
diff --git a/test_programs/execution_failure/brillig_assert_fail/src/main.nr b/test_programs/execution_failure/brillig_assert_fail/src/main.nr
index da9d4ec1ac8..07256f0c398 100644
--- a/test_programs/execution_failure/brillig_assert_fail/src/main.nr
+++ b/test_programs/execution_failure/brillig_assert_fail/src/main.nr
@@ -2,7 +2,11 @@
 // 
 // The features being tested is using assert on brillig
 fn main(x: Field) {
-    assert(1 == conditional(x as bool));
+    assert(
+        1 == unsafe {
+            conditional(x as bool)
+        }
+    );
 }
 
 unconstrained fn conditional(x: bool) -> Field {
diff --git a/test_programs/execution_failure/brillig_assert_msg_runtime/src/main.nr b/test_programs/execution_failure/brillig_assert_msg_runtime/src/main.nr
index bd77551e304..4dd06ceb743 100644
--- a/test_programs/execution_failure/brillig_assert_msg_runtime/src/main.nr
+++ b/test_programs/execution_failure/brillig_assert_msg_runtime/src/main.nr
@@ -1,5 +1,9 @@
 fn main(x: Field) {
-    assert(1 == conditional(x));
+    assert(
+        1 == unsafe {
+            conditional(x)
+        }
+    );
 }
 
 unconstrained fn conditional(x: Field) -> Field {
diff --git a/test_programs/execution_failure/fold_nested_brillig_assert_fail/src/main.nr b/test_programs/execution_failure/fold_nested_brillig_assert_fail/src/main.nr
index 0a5038c179b..21fd4006c2a 100644
--- a/test_programs/execution_failure/fold_nested_brillig_assert_fail/src/main.nr
+++ b/test_programs/execution_failure/fold_nested_brillig_assert_fail/src/main.nr
@@ -13,7 +13,9 @@ fn fold_conditional_wrapper(x: bool) -> Field {
 
 #[fold]
 fn fold_conditional(x: bool) -> Field {
-    conditional_wrapper(x)
+    unsafe {
+        conditional_wrapper(x)
+    }
 }
 
 unconstrained fn conditional_wrapper(x: bool) -> Field {
diff --git a/test_programs/execution_failure/regression_5202/src/main.nr b/test_programs/execution_failure/regression_5202/src/main.nr
index 45ffafca4c7..fbcdba43355 100644
--- a/test_programs/execution_failure/regression_5202/src/main.nr
+++ b/test_programs/execution_failure/regression_5202/src/main.nr
@@ -13,11 +13,15 @@ unconstrained fn should_i_assert() -> bool {
 }
 
 fn get_magical_boolean() -> bool {
-    let option = get_unconstrained_option();
+    let option = unsafe {
+        get_unconstrained_option()
+    };
 
     let pre_assert = option.is_some().to_field();
 
-    if should_i_assert() {
+    if unsafe {
+        should_i_assert()
+    } {
         // Note that `should_i_assert` is unconstrained, so Noir should not be able to infer
         // any behavior from the contents of this block. In this case it is actually false, so the
         // assertion below is not even executed (if it did it'd fail since the values are not equal).
diff --git a/test_programs/execution_success/acir_inside_brillig_recursion/src/main.nr b/test_programs/execution_success/acir_inside_brillig_recursion/src/main.nr
index 92f8524a771..49b7c00b6b9 100644
--- a/test_programs/execution_success/acir_inside_brillig_recursion/src/main.nr
+++ b/test_programs/execution_success/acir_inside_brillig_recursion/src/main.nr
@@ -1,5 +1,7 @@
 fn main() {
-    assert_eq(fibonacci(3), fibonacci_hint(3));
+    unsafe {
+        assert_eq(fibonacci(3), fibonacci_hint(3));
+    }
 }
 
 unconstrained fn fibonacci_hint(x: u32) -> u32 {
diff --git a/test_programs/execution_success/aes128_encrypt/src/main.nr b/test_programs/execution_success/aes128_encrypt/src/main.nr
index cd7fb4772e2..9cf07841b9e 100644
--- a/test_programs/execution_success/aes128_encrypt/src/main.nr
+++ b/test_programs/execution_success/aes128_encrypt/src/main.nr
@@ -31,12 +31,19 @@ unconstrained fn cipher(plaintext: [u8; 12], iv: [u8; 16], key: [u8; 16]) -> [u8
 
 fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) {
     let result = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes());
-    let output_bytes: [u8; 16] = decode_hex(output);
-    for i in 0..16 {
-        assert(result[i] == output_bytes[i]);
-    }
-    let unconstrained_result = cipher(inputs.as_bytes(), iv.as_bytes(), key.as_bytes());
-    for i in 0..16 {
-        assert(unconstrained_result[i] == output_bytes[i]);
+
+    let output_bytes: [u8; 16] = unsafe {
+        let output_bytes: [u8; 16] = decode_hex(output);
+        for i in 0..16 {
+            assert(result[i] == output_bytes[i]);
+        }
+        output_bytes
+    };
+
+    unsafe {
+        let unconstrained_result = cipher(inputs.as_bytes(), iv.as_bytes(), key.as_bytes());
+        for i in 0..16 {
+            assert(unconstrained_result[i] == output_bytes[i]);
+        }
     }
 }
diff --git a/test_programs/execution_success/array_to_slice_constant_length/src/main.nr b/test_programs/execution_success/array_to_slice_constant_length/src/main.nr
index e81dd4a0c5f..5668a9ff388 100644
--- a/test_programs/execution_success/array_to_slice_constant_length/src/main.nr
+++ b/test_programs/execution_success/array_to_slice_constant_length/src/main.nr
@@ -5,6 +5,8 @@ unconstrained fn return_array(val: Field) -> [Field; 1] {
 }
 
 fn main(val: Field) {
-    let array = return_array(val);
-    assert_constant(array.as_slice().len());
+    unsafe {
+        let array = return_array(val);
+        assert_constant(array.as_slice().len());
+    }
 }
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index 9385b39e847..188ccd01131 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -17,7 +17,9 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
     let c = if x[0] != 0 {
         test_unconstrained1(a, b)
     } else {
-        test_unconstrained2(a, b)
+        unsafe {
+            test_unconstrained2(a, b)
+        }
     };
     assert(c.array[0] == std::wrapping_mul(x[0], y[0]));
 
diff --git a/test_programs/execution_success/brillig_acir_as_brillig/src/main.nr b/test_programs/execution_success/brillig_acir_as_brillig/src/main.nr
index 5bd6ce0adb2..1a595ecfb38 100644
--- a/test_programs/execution_success/brillig_acir_as_brillig/src/main.nr
+++ b/test_programs/execution_success/brillig_acir_as_brillig/src/main.nr
@@ -1,7 +1,9 @@
 fn main(x: u32) {
-    assert(entry_point(x) == 2);
-    swap_entry_point(x, x + 1);
-    assert(deep_entry_point(x) == 4);
+    unsafe {
+        assert(entry_point(x) == 2);
+        swap_entry_point(x, x + 1);
+        assert(deep_entry_point(x) == 4);
+    }
 }
 
 fn inner(x: u32) -> u32 {
diff --git a/test_programs/execution_success/brillig_array_to_slice/src/main.nr b/test_programs/execution_success/brillig_array_to_slice/src/main.nr
index 262d3b5d86a..f54adb39963 100644
--- a/test_programs/execution_success/brillig_array_to_slice/src/main.nr
+++ b/test_programs/execution_success/brillig_array_to_slice/src/main.nr
@@ -10,9 +10,11 @@ unconstrained fn brillig_as_slice(x: Field) -> (u32, Field, Field) {
 }
 
 fn main(x: Field) {
-    let (slice_len, dynamic_0, slice_0) = brillig_as_slice(x);
-    assert(slice_len == 1);
-    assert(dynamic_0 == 2);
-    assert(slice_0 == 2);
+    unsafe {
+        let (slice_len, dynamic_0, slice_0) = brillig_as_slice(x);
+        assert(slice_len == 1);
+        assert(dynamic_0 == 2);
+        assert(slice_0 == 2);
+    }
 }
 
diff --git a/test_programs/execution_success/brillig_arrays/src/main.nr b/test_programs/execution_success/brillig_arrays/src/main.nr
index e535b6001a4..c7f0757f31e 100644
--- a/test_programs/execution_success/brillig_arrays/src/main.nr
+++ b/test_programs/execution_success/brillig_arrays/src/main.nr
@@ -2,8 +2,10 @@
 // 
 // The features being tested are array reads and writes
 fn main(x: [Field; 3]) {
-    read_array(x);
-    read_write_array(x);
+    unsafe {
+        read_array(x);
+        read_write_array(x);
+    }
 }
 
 unconstrained fn read_array(x: [Field; 3]) {
diff --git a/test_programs/execution_success/brillig_assert/src/main.nr b/test_programs/execution_success/brillig_assert/src/main.nr
index 16fe7b29061..c6c39b61bc9 100644
--- a/test_programs/execution_success/brillig_assert/src/main.nr
+++ b/test_programs/execution_success/brillig_assert/src/main.nr
@@ -2,7 +2,9 @@
 // 
 // The features being tested is using assert on brillig
 fn main(x: Field) {
-    assert(1 == conditional(x as bool));
+    unsafe {
+        assert(1 == conditional(x as bool));
+    }
 }
 
 unconstrained fn conditional(x: bool) -> Field {
diff --git a/test_programs/execution_success/brillig_blake2s/src/main.nr b/test_programs/execution_success/brillig_blake2s/src/main.nr
index 2743e02e920..122142a9c80 100644
--- a/test_programs/execution_success/brillig_blake2s/src/main.nr
+++ b/test_programs/execution_success/brillig_blake2s/src/main.nr
@@ -2,7 +2,9 @@
 // 
 // The features being tested is blake2s in brillig
 fn main(x: [u8; 5], result: [u8; 32]) {
-    assert(blake2s(x) == result);
+    unsafe {
+        assert(blake2s(x) == result);
+    }
 }
 
 unconstrained fn blake2s(x: [u8; 5]) -> [u8; 32] {
diff --git a/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr b/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr
index 2809668c574..6ddfc03622a 100644
--- a/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr
+++ b/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr
@@ -38,11 +38,11 @@ struct Outer {
 // If we don't take into account block parameter liveness, this function will need 5*500=2500 stack items
 unconstrained fn main(conditions: [bool; 5]) -> pub Outer {
     let out0 = if conditions[0] {
-        let mut outer: Outer = std::unsafe::zeroed();
+        let mut outer: Outer = std::mem::zeroed();
         outer.middle_a.inner_a.a = 1;
         outer
     } else {
-        let mut outer: Outer= std::unsafe::zeroed();
+        let mut outer: Outer = std::mem::zeroed();
         outer.middle_f.inner_c.d = 2;
         outer
     };
diff --git a/test_programs/execution_success/brillig_calls/src/main.nr b/test_programs/execution_success/brillig_calls/src/main.nr
index 5c39713f5bb..3e23da53b18 100644
--- a/test_programs/execution_success/brillig_calls/src/main.nr
+++ b/test_programs/execution_success/brillig_calls/src/main.nr
@@ -2,10 +2,12 @@
 // 
 // The features being tested is brillig calls
 fn main(x: u32) {
-    assert(entry_point(x) == 2);
-    swap_entry_point(x, x + 1);
-    assert(deep_entry_point(x) == 4);
-    multiple_values_entry_point(x);
+    unsafe {
+        assert(entry_point(x) == 2);
+        swap_entry_point(x, x + 1);
+        assert(deep_entry_point(x) == 4);
+        multiple_values_entry_point(x);
+    }
 }
 
 unconstrained fn returns_multiple_values(x: u32) -> (u32, u32, u32, u32) {
diff --git a/test_programs/execution_success/brillig_calls_array/src/main.nr b/test_programs/execution_success/brillig_calls_array/src/main.nr
index 1b1d89f6366..8b27a9bb202 100644
--- a/test_programs/execution_success/brillig_calls_array/src/main.nr
+++ b/test_programs/execution_success/brillig_calls_array/src/main.nr
@@ -2,8 +2,10 @@
 // 
 // The features being tested is brillig calls passing arrays around
 fn main(x: [u32; 3]) {
-    assert(entry_point(x) == 9);
-    another_entry_point(x);
+    unsafe {
+        assert(entry_point(x) == 9);
+        another_entry_point(x);
+    }
 }
 
 unconstrained fn inner(x: [u32; 3]) -> [u32; 3] {
diff --git a/test_programs/execution_success/brillig_calls_conditionals/src/main.nr b/test_programs/execution_success/brillig_calls_conditionals/src/main.nr
index 0a1718d0171..318da4caf72 100644
--- a/test_programs/execution_success/brillig_calls_conditionals/src/main.nr
+++ b/test_programs/execution_success/brillig_calls_conditionals/src/main.nr
@@ -2,10 +2,12 @@
 // 
 // The features being tested is brillig calls with conditionals
 fn main(x: [u32; 3]) {
-    assert(entry_point(x[0]) == 7);
-    assert(entry_point(x[1]) == 8);
-    assert(entry_point(x[2]) == 9);
-    assert(entry_point(42) == 0);
+    unsafe {
+        assert(entry_point(x[0]) == 7);
+        assert(entry_point(x[1]) == 8);
+        assert(entry_point(x[2]) == 9);
+        assert(entry_point(42) == 0);
+    }
 }
 
 unconstrained fn inner_1() -> u32 {
diff --git a/test_programs/execution_success/brillig_conditional/src/main.nr b/test_programs/execution_success/brillig_conditional/src/main.nr
index a59336a877b..8ababf82319 100644
--- a/test_programs/execution_success/brillig_conditional/src/main.nr
+++ b/test_programs/execution_success/brillig_conditional/src/main.nr
@@ -2,7 +2,9 @@
 // 
 // The features being tested is basic conditonal on brillig
 fn main(x: Field) {
-    assert(4 == conditional(x == 1));
+    unsafe {
+        assert(4 == conditional(x == 1));
+    }
 }
 
 unconstrained fn conditional(x: bool) -> Field {
diff --git a/test_programs/execution_success/brillig_ecdsa_secp256k1/src/main.nr b/test_programs/execution_success/brillig_ecdsa_secp256k1/src/main.nr
index 78343dcd26c..45f13c79637 100644
--- a/test_programs/execution_success/brillig_ecdsa_secp256k1/src/main.nr
+++ b/test_programs/execution_success/brillig_ecdsa_secp256k1/src/main.nr
@@ -2,7 +2,9 @@
 // 
 // The features being tested is ecdsa in brillig
 fn main(hashed_message: [u8; 32], pub_key_x: [u8; 32], pub_key_y: [u8; 32], signature: [u8; 64]) {
-    assert(ecdsa(hashed_message, pub_key_x, pub_key_y, signature));
+    unsafe {
+        assert(ecdsa(hashed_message, pub_key_x, pub_key_y, signature));
+    }
 }
 
 unconstrained fn ecdsa(
diff --git a/test_programs/execution_success/brillig_ecdsa_secp256r1/src/main.nr b/test_programs/execution_success/brillig_ecdsa_secp256r1/src/main.nr
index 48debadb012..32b562ec50c 100644
--- a/test_programs/execution_success/brillig_ecdsa_secp256r1/src/main.nr
+++ b/test_programs/execution_success/brillig_ecdsa_secp256r1/src/main.nr
@@ -2,7 +2,9 @@
 // 
 // The features being tested is ecdsa in brillig
 fn main(hashed_message: [u8; 32], pub_key_x: [u8; 32], pub_key_y: [u8; 32], signature: [u8; 64]) {
-    assert(ecdsa(hashed_message, pub_key_x, pub_key_y, signature));
+    unsafe {
+        assert(ecdsa(hashed_message, pub_key_x, pub_key_y, signature));
+    }
 }
 
 unconstrained fn ecdsa(
diff --git a/test_programs/execution_success/brillig_fns_as_values/src/main.nr b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
index 1476c447431..55b9d307905 100644
--- a/test_programs/execution_success/brillig_fns_as_values/src/main.nr
+++ b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
@@ -1,18 +1,20 @@
 struct MyStruct {
-    operation: fn (u32) -> u32,
+    operation: unconstrained fn (u32) -> u32,
 }
 
 fn main(x: u32) {
-    assert(wrapper(increment, x) == x + 1);
-    assert(wrapper(increment_acir, x) == x + 1);
-    assert(wrapper(decrement, x) == x - 1);
-    assert(wrapper_with_struct(MyStruct { operation: increment }, x) == x + 1);
-    assert(wrapper_with_struct(MyStruct { operation: decrement }, x) == x - 1);
-    // https://github.com/noir-lang/noir/issues/1975
-    assert(increment(x) == x + 1);
+    unsafe {
+        assert(wrapper(increment, x) == x + 1);
+        assert(wrapper(increment_acir, x) == x + 1);
+        assert(wrapper(decrement, x) == x - 1);
+        assert(wrapper_with_struct(MyStruct { operation: increment }, x) == x + 1);
+        assert(wrapper_with_struct(MyStruct { operation: decrement }, x) == x - 1);
+        // https://github.com/noir-lang/noir/issues/1975
+        assert(increment(x) == x + 1);
+    }
 }
 
-unconstrained fn wrapper(func: fn(u32) -> u32, param: u32) -> u32 {
+unconstrained fn wrapper(func: unconstrained fn(u32) -> u32, param: u32) -> u32 {
     func(param)
 }
 
diff --git a/test_programs/execution_success/brillig_hash_to_field/src/main.nr b/test_programs/execution_success/brillig_hash_to_field/src/main.nr
index 78759bd84c6..d1ea635d49a 100644
--- a/test_programs/execution_success/brillig_hash_to_field/src/main.nr
+++ b/test_programs/execution_success/brillig_hash_to_field/src/main.nr
@@ -2,7 +2,9 @@
 // 
 // The features being tested is hash_to_field in brillig
 fn main(input: Field) -> pub Field {
-    hash_to_field(input)
+    unsafe {
+        hash_to_field(input)
+    }
 }
 
 unconstrained fn hash_to_field(input: Field) -> Field {
diff --git a/test_programs/execution_success/brillig_identity_function/src/main.nr b/test_programs/execution_success/brillig_identity_function/src/main.nr
index f41188b1f0d..c2759fe054f 100644
--- a/test_programs/execution_success/brillig_identity_function/src/main.nr
+++ b/test_programs/execution_success/brillig_identity_function/src/main.nr
@@ -6,17 +6,19 @@ struct myStruct {
 // 
 // The features being tested is the identity function in Brillig
 fn main(x: Field) {
-    assert(x == identity(x));
-    // TODO: add support for array comparison
-    let arr = identity_array([x, x]);
-    assert(x == arr[0]);
-    assert(x == arr[1]);
+    unsafe {
+        assert(x == identity(x));
+        // TODO: add support for array comparison
+        let arr = identity_array([x, x]);
+        assert(x == arr[0]);
+        assert(x == arr[1]);
 
-    let s = myStruct { foo: x, foo_arr: [x, x] };
-    let identity_struct = identity_struct(s);
-    assert(x == identity_struct.foo);
-    assert(x == identity_struct.foo_arr[0]);
-    assert(x == identity_struct.foo_arr[1]);
+        let s = myStruct { foo: x, foo_arr: [x, x] };
+        let identity_struct = identity_struct(s);
+        assert(x == identity_struct.foo);
+        assert(x == identity_struct.foo_arr[0]);
+        assert(x == identity_struct.foo_arr[1]);
+    }
 }
 
 unconstrained fn identity(x: Field) -> Field {
diff --git a/test_programs/execution_success/brillig_keccak/src/main.nr b/test_programs/execution_success/brillig_keccak/src/main.nr
index 9150e38f208..dd339208659 100644
--- a/test_programs/execution_success/brillig_keccak/src/main.nr
+++ b/test_programs/execution_success/brillig_keccak/src/main.nr
@@ -2,21 +2,23 @@
 // 
 // The features being tested is keccak256 in brillig
 fn main(x: Field, result: [u8; 32]) {
-    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
-    // The padding is taken care of by the program
-    let digest = keccak256([x as u8], 1);
-    assert(digest == result);
-    //#1399: variable message size
-    let message_size = 4;
-    let hash_a = keccak256([1, 2, 3, 4], message_size);
-    let hash_b = keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+    unsafe {
+        // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+        // The padding is taken care of by the program
+        let digest = keccak256([x as u8], 1);
+        assert(digest == result);
+        //#1399: variable message size
+        let message_size = 4;
+        let hash_a = keccak256([1, 2, 3, 4], message_size);
+        let hash_b = keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
 
-    assert(hash_a == hash_b);
+        assert(hash_a == hash_b);
 
-    let message_size_big = 8;
-    let hash_c = keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+        let message_size_big = 8;
+        let hash_c = keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
 
-    assert(hash_a != hash_c);
+        assert(hash_a != hash_c);
+    }
 }
 
 unconstrained fn keccak256<N>(data: [u8; N], msg_len: u32) -> [u8; 32] {
diff --git a/test_programs/execution_success/brillig_loop/src/main.nr b/test_programs/execution_success/brillig_loop/src/main.nr
index 05d35469342..770660bb2a1 100644
--- a/test_programs/execution_success/brillig_loop/src/main.nr
+++ b/test_programs/execution_success/brillig_loop/src/main.nr
@@ -2,8 +2,10 @@
 // 
 // The features being tested is basic looping on brillig
 fn main(sum: u32) {
-    assert(loop(4) == sum);
-    assert(plain_loop() == sum);
+    unsafe {
+        assert(loop(4) == sum);
+        assert(plain_loop() == sum);
+    }
 }
 
 unconstrained fn loop(x: u32) -> u32 {
diff --git a/test_programs/execution_success/brillig_nested_arrays/src/main.nr b/test_programs/execution_success/brillig_nested_arrays/src/main.nr
index 5a5657246a8..77ab4ea19a6 100644
--- a/test_programs/execution_success/brillig_nested_arrays/src/main.nr
+++ b/test_programs/execution_success/brillig_nested_arrays/src/main.nr
@@ -28,14 +28,16 @@ unconstrained fn create_and_assert_inside_brillig(x: Field, y: Field) {
 }
 
 fn main(x: Field, y: Field) {
-    let header = Header { params: [1, 2, 3] };
-    let note0 = MyNote { array: [1, 2], plain: 3, header };
-    let note1 = MyNote { array: [4, 5], plain: 6, header };
+    unsafe {
+        let header = Header { params: [1, 2, 3] };
+        let note0 = MyNote { array: [1, 2], plain: 3, header };
+        let note1 = MyNote { array: [4, 5], plain: 6, header };
 
-    assert(access_nested([note0, note1], x, y) == (2 + 4 + 3 + 1));
+        assert(access_nested([note0, note1], x, y) == (2 + 4 + 3 + 1));
 
-    let notes = create_inside_brillig();
-    assert_inside_brillig(notes, x, y);
-    create_and_assert_inside_brillig(x, y);
+        let notes = create_inside_brillig();
+        assert_inside_brillig(notes, x, y);
+        create_and_assert_inside_brillig(x, y);
+    }
 }
 
diff --git a/test_programs/execution_success/brillig_not/src/main.nr b/test_programs/execution_success/brillig_not/src/main.nr
index d34b3edb4b6..557d1e2e31f 100644
--- a/test_programs/execution_success/brillig_not/src/main.nr
+++ b/test_programs/execution_success/brillig_not/src/main.nr
@@ -2,8 +2,10 @@
 // 
 // The features being tested is not instruction on brillig
 fn main(x: Field, y: Field) {
-    assert(false == not_operator(x as bool));
-    assert(true == not_operator(y as bool));
+    unsafe {
+        assert(false == not_operator(x as bool));
+        assert(true == not_operator(y as bool));
+    }
 }
 
 unconstrained fn not_operator(x: bool) -> bool {
diff --git a/test_programs/execution_success/brillig_oracle/src/main.nr b/test_programs/execution_success/brillig_oracle/src/main.nr
index 0305cb06978..93465b87389 100644
--- a/test_programs/execution_success/brillig_oracle/src/main.nr
+++ b/test_programs/execution_success/brillig_oracle/src/main.nr
@@ -3,21 +3,23 @@ use std::test::OracleMock;
 
 // Tests oracle usage in brillig/unconstrained functions
 fn main(_x: Field) {
-    let size = 20;
-    // TODO: Add a method along the lines of `(0..size).to_array()`.
-    let mut mock_oracle_response = [0; 20];
-    // TODO: Add an `array.reverse()` method.
-    let mut reversed_mock_oracle_response = [0; 20];
-    for i in 0..size {
-        mock_oracle_response[i] = i;
-        reversed_mock_oracle_response[19 - i] = i;
+    unsafe {
+        let size = 20;
+        // TODO: Add a method along the lines of `(0..size).to_array()`.
+        let mut mock_oracle_response = [0; 20];
+        // TODO: Add an `array.reverse()` method.
+        let mut reversed_mock_oracle_response = [0; 20];
+        for i in 0..size {
+            mock_oracle_response[i] = i;
+            reversed_mock_oracle_response[19 - i] = i;
+        }
+
+        // TODO: this method of returning a slice feels hacky.
+        let _ = OracleMock::mock("get_number_sequence").with_params(size).returns((20, mock_oracle_response));
+        let _ = OracleMock::mock("get_reverse_number_sequence").with_params(size).returns((20, reversed_mock_oracle_response));
+
+        get_number_sequence_wrapper(size as Field);
     }
-
-    // TODO: this method of returning a slice feels hacky.
-    let _ = OracleMock::mock("get_number_sequence").with_params(size).returns((20, mock_oracle_response));
-    let _ = OracleMock::mock("get_reverse_number_sequence").with_params(size).returns((20, reversed_mock_oracle_response));
-
-    get_number_sequence_wrapper(size as Field);
 }
 
 // Define oracle functions which we have mocked above
diff --git a/test_programs/execution_success/brillig_recursion/src/main.nr b/test_programs/execution_success/brillig_recursion/src/main.nr
index a87ef28bc56..c69468013b1 100644
--- a/test_programs/execution_success/brillig_recursion/src/main.nr
+++ b/test_programs/execution_success/brillig_recursion/src/main.nr
@@ -2,7 +2,9 @@
 // 
 // The feature being tested is brillig recursion
 fn main(x: u32) {
-    assert(fibonacci(x) == 55);
+    unsafe {
+        assert(fibonacci(x) == 55);
+    }
 }
 
 unconstrained fn fibonacci(x: u32) -> u32 {
diff --git a/test_programs/execution_success/brillig_sha256/src/main.nr b/test_programs/execution_success/brillig_sha256/src/main.nr
index fcc01978a0a..5519fb2da64 100644
--- a/test_programs/execution_success/brillig_sha256/src/main.nr
+++ b/test_programs/execution_success/brillig_sha256/src/main.nr
@@ -2,7 +2,9 @@
 // 
 // The features being tested is sha256 in brillig
 fn main(x: Field, result: [u8; 32]) {
-    assert(result == sha256(x));
+    unsafe {
+        assert(result == sha256(x));
+    }
 }
 
 unconstrained fn sha256(x: Field) -> [u8; 32] {
diff --git a/test_programs/execution_success/brillig_unitialised_arrays/src/main.nr b/test_programs/execution_success/brillig_unitialised_arrays/src/main.nr
index 5ec657b0d35..d4b74162cfb 100644
--- a/test_programs/execution_success/brillig_unitialised_arrays/src/main.nr
+++ b/test_programs/execution_success/brillig_unitialised_arrays/src/main.nr
@@ -1,6 +1,8 @@
 fn main(x: Field, y: Field) -> pub Field {
-    let notes = create_notes(x, y);
-    sum_x(notes, x, y)
+    unsafe {
+        let notes = create_notes(x, y);
+        sum_x(notes, x, y)
+    }
 }
 
 fn sum_x(notes: [Field; 2], x: Field, y: Field) -> Field {
diff --git a/test_programs/execution_success/databus/src/main.nr b/test_programs/execution_success/databus/src/main.nr
index 1e4aa141eea..ecc7794cf9e 100644
--- a/test_programs/execution_success/databus/src/main.nr
+++ b/test_programs/execution_success/databus/src/main.nr
@@ -1,6 +1,8 @@
 fn main(mut x: u32, y: call_data(0) u32, z: call_data(0) [u32; 4]) -> return_data u32 {
     let a = z[x];
-    a + foo(y)
+    unsafe {
+        a + foo(y)
+    }
 }
 
 // Use an unconstrained function to force the compiler to avoid inlining
diff --git a/test_programs/execution_success/generics/src/main.nr b/test_programs/execution_success/generics/src/main.nr
index f754fb96292..75a7f8a3154 100644
--- a/test_programs/execution_success/generics/src/main.nr
+++ b/test_programs/execution_success/generics/src/main.nr
@@ -34,7 +34,7 @@ impl Bar<Field> {
 impl<T> Bar<T> {
     // This is to test that we can use turbofish on methods as well
     fn zeroed<A>(_self: Self) -> A {
-        std::unsafe::zeroed()
+        std::mem::zeroed()
     }
 }
 
diff --git a/test_programs/execution_success/global_consts/src/main.nr b/test_programs/execution_success/global_consts/src/main.nr
index 52ffe3e823b..966be2741d6 100644
--- a/test_programs/execution_success/global_consts/src/main.nr
+++ b/test_programs/execution_success/global_consts/src/main.nr
@@ -25,7 +25,7 @@ unconstrained fn calculate_global_value() -> Field {
 }
 
 // Regression test for https://github.com/noir-lang/noir/issues/4318
-global CALCULATED_GLOBAL: Field = calculate_global_value();
+global CALCULATED_GLOBAL: Field = unsafe { calculate_global_value() };
 
 fn main(
     a: [Field; M + N - N],
diff --git a/test_programs/execution_success/is_unconstrained/src/main.nr b/test_programs/execution_success/is_unconstrained/src/main.nr
index ddafc73c598..d06366cf642 100644
--- a/test_programs/execution_success/is_unconstrained/src/main.nr
+++ b/test_programs/execution_success/is_unconstrained/src/main.nr
@@ -9,6 +9,8 @@ unconstrained fn unconstrained_intermediate() {
 }
 
 fn main() {
-    unconstrained_intermediate();
+    unsafe {
+        unconstrained_intermediate();
+    }
     check(false);
 }
diff --git a/test_programs/execution_success/nested_arrays_from_brillig/src/main.nr b/test_programs/execution_success/nested_arrays_from_brillig/src/main.nr
index 1bcbd7d5421..9664b4d1ce6 100644
--- a/test_programs/execution_success/nested_arrays_from_brillig/src/main.nr
+++ b/test_programs/execution_success/nested_arrays_from_brillig/src/main.nr
@@ -20,7 +20,9 @@ unconstrained fn create_inside_brillig(values: [Field; 6]) -> [MyNote; 2] {
 }
 
 fn main(values: [Field; 6]) {
-    let notes = create_inside_brillig(values);
+    let notes = unsafe {
+        create_inside_brillig(values)
+    };
     assert(access_nested(notes) == (2 + 4 + 3 + 1));
 }
 
diff --git a/test_programs/execution_success/regression_4124/src/main.nr b/test_programs/execution_success/regression_4124/src/main.nr
index 6caea017798..7b5060062da 100644
--- a/test_programs/execution_success/regression_4124/src/main.nr
+++ b/test_programs/execution_success/regression_4124/src/main.nr
@@ -11,7 +11,7 @@ impl MyDeserialize<1> for Field {
 }
 
 pub fn storage_read<let N: u32>() -> [Field; N] {
-    std::unsafe::zeroed()
+    std::mem::zeroed()
 }
 
 struct PublicMutable<T> {
diff --git a/test_programs/execution_success/regression_5435/src/main.nr b/test_programs/execution_success/regression_5435/src/main.nr
index 65f13c5b201..d8aeb76356b 100644
--- a/test_programs/execution_success/regression_5435/src/main.nr
+++ b/test_programs/execution_success/regression_5435/src/main.nr
@@ -3,7 +3,9 @@ fn main(input: Field, enable: bool) {
         let hash = no_predicate_function(input);
         // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,
         // resulting in execution failure.
-        fail(hash);
+        unsafe {
+            fail(hash)
+        };
     }
 }
 
diff --git a/test_programs/execution_success/slice_regex/src/main.nr b/test_programs/execution_success/slice_regex/src/main.nr
index 43bd4433c69..2382f5b0f2f 100644
--- a/test_programs/execution_success/slice_regex/src/main.nr
+++ b/test_programs/execution_success/slice_regex/src/main.nr
@@ -327,7 +327,7 @@ fn main() {
 //
 // impl<T, let N: u32> Bvec<T, N> {
 //     fn empty() -> Self {
-//         Self { inner: [std::unsafe::zeroed(); N], offset: 0, len: 0 }
+//         Self { inner: [std::mem::zeroed(); N], offset: 0, len: 0 }
 //     }
 //
 //     fn new(array: [T; N]) -> Self {
@@ -559,7 +559,7 @@ fn main() {
 // }
 //
 // fn reverse_array<T, let N: u32>(input: [T; N]) -> [T; N] {
-//     let mut output = [std::unsafe::zeroed(); N];
+//     let mut output = [std::mem::zeroed(); N];
 //     for i in 0..N {
 //         output[i] = input[N - (i + 1)];
 //     }
@@ -587,7 +587,7 @@ fn main() {
 //     assert_eq(xs, ys);
 //
 //     // test that pop_front gives all contents, in order,
-//     // followed by std::unsafe::zeroed()
+//     // followed by std::mem::zeroed()
 //     println(xs);
 //     let (x, new_xs) = xs.pop_front();
 //     assert_eq(x, 0);
@@ -606,7 +606,7 @@ fn main() {
 //     println(xs);
 //     if xs.len != 0 {
 //         let (x, _new_xs) = xs.pop_front();
-//         assert_eq(x, std::unsafe::zeroed());
+//         assert_eq(x, std::mem::zeroed());
 //     }
 //
 //     assert_eq(new_xs, Bvec { inner: [0, 1, 2], offset: 3, len: 0 });
diff --git a/test_programs/execution_success/u16_support/src/main.nr b/test_programs/execution_success/u16_support/src/main.nr
index e8b418f16da..ca41c708077 100644
--- a/test_programs/execution_success/u16_support/src/main.nr
+++ b/test_programs/execution_success/u16_support/src/main.nr
@@ -1,6 +1,8 @@
 fn main(x: u16) {
     test_u16(x);
-    test_u16_unconstrained(x);
+    unsafe {
+        test_u16_unconstrained(x);
+    }
 }
 
 unconstrained fn test_u16_unconstrained(x: u16) {
diff --git a/test_programs/execution_success/uhashmap/src/main.nr b/test_programs/execution_success/uhashmap/src/main.nr
index 395ed21b6b0..f2ca6813713 100644
--- a/test_programs/execution_success/uhashmap/src/main.nr
+++ b/test_programs/execution_success/uhashmap/src/main.nr
@@ -294,7 +294,9 @@ unconstrained fn doc_tests() {
 
 // docs:start:get_example
 fn get_example(map: UHashMap<Field, Field, BuildHasherDefault<Poseidon2Hasher>>) {
-    let x = map.get(12);
+    let x = unsafe {
+        map.get(12)
+    };
 
     if x.is_some() {
         assert(x.unwrap() == 42);
@@ -320,7 +322,9 @@ fn entries_examples(map: UHashMap<Field, Field, BuildHasherDefault<Poseidon2Hash
     let keys = map.keys();
 
     for key in keys {
-        let value = map.get(key).unwrap_unchecked();
+        let value = unsafe {
+            map.get(key)
+        }.unwrap_unchecked();
         println(f"{key} -> {value}");
     }
     // docs:end:keys_example
diff --git a/test_programs/execution_success/unit_value/src/main.nr b/test_programs/execution_success/unit_value/src/main.nr
index a488f267b4c..18c7e5f4f7d 100644
--- a/test_programs/execution_success/unit_value/src/main.nr
+++ b/test_programs/execution_success/unit_value/src/main.nr
@@ -1,5 +1,5 @@
 fn get_transaction() {
-    std::unsafe::zeroed()
+    std::mem::zeroed()
 }
 
 fn main() {
diff --git a/test_programs/noir_test_success/mock_oracle/src/main.nr b/test_programs/noir_test_success/mock_oracle/src/main.nr
index 4d3dd8d030b..1b427043e91 100644
--- a/test_programs/noir_test_success/mock_oracle/src/main.nr
+++ b/test_programs/noir_test_success/mock_oracle/src/main.nr
@@ -34,68 +34,84 @@ unconstrained fn struct_field(point: Point, array: [Field; 4]) -> Field {
 
 #[test(should_fail)]
 fn test_mock_no_returns() {
-    OracleMock::mock("void_field");
-    void_field(); // Some return value must be set
+    unsafe {
+        OracleMock::mock("void_field");
+        void_field(); // Some return value must be set
+    }
 }
 
 #[test]
 fn test_mock() {
-    OracleMock::mock("void_field").returns(10);
-    assert_eq(void_field(), 10);
+    unsafe {
+        OracleMock::mock("void_field").returns(10);
+        assert_eq(void_field(), 10);
+    }
 }
 
 #[test]
 fn test_multiple_mock() {
-    let first_mock = OracleMock::mock("void_field").returns(10);
-    OracleMock::mock("void_field").returns(42);
+    unsafe {
+        let first_mock = OracleMock::mock("void_field").returns(10);
+        OracleMock::mock("void_field").returns(42);
 
-    // The mocks are searched for in creation order, so the first one prevents the second from being called.
-    assert_eq(void_field(), 10);
+        // The mocks are searched for in creation order, so the first one prevents the second from being called.
+        assert_eq(void_field(), 10);
 
-    first_mock.clear();
-    assert_eq(void_field(), 42);
+        first_mock.clear();
+        assert_eq(void_field(), 42);
+    }
 }
 
 #[test]
 fn test_multiple_mock_times() {
-    OracleMock::mock("void_field").returns(10).times(2);
-    OracleMock::mock("void_field").returns(42);
+    unsafe {
+        OracleMock::mock("void_field").returns(10).times(2);
+        OracleMock::mock("void_field").returns(42);
 
-    assert_eq(void_field(), 10);
-    assert_eq(void_field(), 10);
-    assert_eq(void_field(), 42);
+        assert_eq(void_field(), 10);
+        assert_eq(void_field(), 10);
+        assert_eq(void_field(), 42);
+    }
 }
 
 #[test]
 fn test_mock_with_params() {
-    OracleMock::mock("field_field").with_params((5,)).returns(10);
-    assert_eq(field_field(5), 10);
+    unsafe {
+        OracleMock::mock("field_field").with_params((5,)).returns(10);
+        assert_eq(field_field(5), 10);
+    }
 }
 
 #[test]
 fn test_multiple_mock_with_params() {
-    OracleMock::mock("field_field").with_params((5,)).returns(10);
-    OracleMock::mock("field_field").with_params((7,)).returns(14);
+    unsafe {
+        OracleMock::mock("field_field").with_params((5,)).returns(10);
+        OracleMock::mock("field_field").with_params((7,)).returns(14);
 
-    assert_eq(field_field(5), 10);
-    assert_eq(field_field(7), 14);
+        assert_eq(field_field(5), 10);
+        assert_eq(field_field(7), 14);
+    }
 }
 
 #[test]
 fn test_mock_last_params() {
-    let mock = OracleMock::mock("field_field").returns(10);
-    assert_eq(field_field(5), 10);
+    unsafe {
+        let mock = OracleMock::mock("field_field").returns(10);
+        assert_eq(field_field(5), 10);
 
-    assert_eq(mock.get_last_params(), 5);
+        assert_eq(mock.get_last_params(), 5);
+    }
 }
 
 #[test]
 fn test_mock_last_params_many_calls() {
-    let mock = OracleMock::mock("field_field").returns(10);
-    assert_eq(field_field(5), 10);
-    assert_eq(field_field(7), 10);
+    unsafe {
+        let mock = OracleMock::mock("field_field").returns(10);
+        assert_eq(field_field(5), 10);
+        assert_eq(field_field(7), 10);
 
-    assert_eq(mock.get_last_params(), 7);
+        assert_eq(mock.get_last_params(), 7);
+    }
 }
 
 #[test]
@@ -106,25 +122,25 @@ fn test_mock_struct_field() {
     let another_array = [4, 3, 2, 1];
     let point = Point { x: 14, y: 27 };
 
-    OracleMock::mock("struct_field").returns(42).times(2);
-    let timeless_mock = OracleMock::mock("struct_field").returns(0);
-
-    assert_eq(42, struct_field(point, array));
-    assert_eq(42, struct_field(point, array));
-    // The times(2) mock is now cleared
-
-    assert_eq(0, struct_field(point, array));
-
-    let last_params: (Point, [Field; 4]) = timeless_mock.get_last_params();
-    assert_eq(last_params.0, point);
-    assert_eq(last_params.1, array);
-
-    // We clear the mock with no times() to allow other mocks to be callable
-    timeless_mock.clear();
-
-    OracleMock::mock("struct_field").with_params((point, array)).returns(10);
-    OracleMock::mock("struct_field").with_params((point, another_array)).returns(20);
-    assert_eq(10, struct_field(point, array));
-    assert_eq(20, struct_field(point, another_array));
+    unsafe {
+        OracleMock::mock("struct_field").returns(42).times(2);
+        let timeless_mock = OracleMock::mock("struct_field").returns(0);
+        assert_eq(42, struct_field(point, array));
+        assert_eq(42, struct_field(point, array));
+        // The times(2) mock is now cleared
+
+        assert_eq(0, struct_field(point, array));
+        let last_params: (Point, [Field; 4]) = timeless_mock.get_last_params();
+        assert_eq(last_params.0, point);
+        assert_eq(last_params.1, array);
+
+        // We clear the mock with no times() to allow other mocks to be callable
+        timeless_mock.clear();
+
+        OracleMock::mock("struct_field").with_params((point, array)).returns(10);
+        OracleMock::mock("struct_field").with_params((point, another_array)).returns(20);
+        assert_eq(10, struct_field(point, array));
+        assert_eq(20, struct_field(point, another_array));
+    }
 }
 
diff --git a/test_programs/noir_test_success/out_of_bounds_alignment/src/main.nr b/test_programs/noir_test_success/out_of_bounds_alignment/src/main.nr
index a47ab37eb31..fb90e3d96c5 100644
--- a/test_programs/noir_test_success/out_of_bounds_alignment/src/main.nr
+++ b/test_programs/noir_test_success/out_of_bounds_alignment/src/main.nr
@@ -13,5 +13,7 @@ fn test_acir() {
 
 #[test(should_fail)]
 fn test_brillig() {
-    assert_eq(out_of_bounds_unconstrained_wrapper([0; 50], [0; 50]), 0);
+    unsafe {
+        assert_eq(out_of_bounds_unconstrained_wrapper([0; 50], [0; 50]), 0);
+    }
 }
diff --git a/test_programs/noir_test_success/regression_4561/src/main.nr b/test_programs/noir_test_success/regression_4561/src/main.nr
index ad40941ff51..6a8b4bd61fb 100644
--- a/test_programs/noir_test_success/regression_4561/src/main.nr
+++ b/test_programs/noir_test_success/regression_4561/src/main.nr
@@ -12,7 +12,7 @@ unconstrained fn simple_nested_return_unconstrained() -> TReturn {
 }
 
 #[test]
-fn test_simple_nested_return() {
+unconstrained fn test_simple_nested_return() {
     OracleMock::mock("simple_nested_return").returns([1, 2, 3, 4, 5, 6]);
     assert_eq(simple_nested_return_unconstrained(), [[1, 2, 3], [4, 5, 6]]);
 }
@@ -25,7 +25,7 @@ unconstrained fn nested_with_fields_return_unconstrained() -> (Field, TReturn, F
 }
 
 #[test]
-fn test_nested_with_fields_return() {
+unconstrained fn test_nested_with_fields_return() {
     OracleMock::mock("nested_with_fields_return").returns((0, [1, 2, 3, 4, 5, 6], 7));
     assert_eq(nested_with_fields_return_unconstrained(), (0, [[1, 2, 3], [4, 5, 6]], 7));
 }
@@ -38,7 +38,7 @@ unconstrained fn two_nested_return_unconstrained() -> (Field, TReturn, Field, TR
 }
 
 #[test]
-fn two_nested_return() {
+unconstrained fn two_nested_return() {
     OracleMock::mock("two_nested_return").returns((0, [1, 2, 3, 4, 5, 6], 7, [1, 2, 3, 4, 5, 6]));
     assert_eq(two_nested_return_unconstrained(), (0, [[1, 2, 3], [4, 5, 6]], 7, [[1, 2, 3], [4, 5, 6]]));
 }
@@ -57,7 +57,7 @@ struct TestTypeFoo {
 }
 
 #[test]
-fn complexe_struct_return() {
+unconstrained fn complexe_struct_return() {
     OracleMock::mock("foo_return").returns(
         (
             0, [1, 2, 3, 4, 5, 6], 7, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [1, 2, 3, 4, 5, 6]
diff --git a/tooling/lsp/src/requests/completion.rs b/tooling/lsp/src/requests/completion.rs
index 028bbcd6b28..78b49a55be7 100644
--- a/tooling/lsp/src/requests/completion.rs
+++ b/tooling/lsp/src/requests/completion.rs
@@ -544,6 +544,9 @@ impl<'a> NodeFinder<'a> {
 
                 self.local_variables = old_local_variables;
             }
+            noirc_frontend::ast::ExpressionKind::Unsafe(block_expression, _) => {
+                self.find_in_block_expression(block_expression);
+            }
             noirc_frontend::ast::ExpressionKind::AsTraitPath(as_trait_path) => {
                 self.find_in_as_trait_path(as_trait_path);
             }
@@ -707,7 +710,7 @@ impl<'a> NodeFinder<'a> {
             noirc_frontend::ast::UnresolvedTypeData::Tuple(unresolved_types) => {
                 self.find_in_unresolved_types(unresolved_types);
             }
-            noirc_frontend::ast::UnresolvedTypeData::Function(args, ret, env) => {
+            noirc_frontend::ast::UnresolvedTypeData::Function(args, ret, env, _) => {
                 self.find_in_unresolved_types(args);
                 self.find_in_unresolved_type(ret);
                 self.find_in_unresolved_type(env);
@@ -1012,7 +1015,7 @@ impl<'a> NodeFinder<'a> {
             | Type::TypeVariable(_, _)
             | Type::TraitAsType(_, _, _)
             | Type::NamedGeneric(_, _, _)
-            | Type::Function(_, _, _)
+            | Type::Function(..)
             | Type::Forall(_, _)
             | Type::Constant(_)
             | Type::Quoted(_)
@@ -1557,8 +1560,11 @@ fn func_meta_type_to_string(func_meta: &FuncMeta, has_self_type: bool) -> String
         typ = typ_;
     }
 
-    if let Type::Function(args, ret, _env) = typ {
+    if let Type::Function(args, ret, _env, unconstrained) = typ {
         let mut string = String::new();
+        if *unconstrained {
+            string.push_str("unconstrained ");
+        }
         string.push_str("fn(");
         for (index, arg) in args.iter().enumerate() {
             if index > 0 {
diff --git a/tooling/lsp/src/requests/completion/builtins.rs b/tooling/lsp/src/requests/completion/builtins.rs
index 00f7717046c..7f88c9b3c73 100644
--- a/tooling/lsp/src/requests/completion/builtins.rs
+++ b/tooling/lsp/src/requests/completion/builtins.rs
@@ -53,6 +53,7 @@ pub(super) fn keyword_builtin_type(keyword: &Keyword) -> Option<&'static str> {
         | Keyword::Type
         | Keyword::Unchecked
         | Keyword::Unconstrained
+        | Keyword::Unsafe
         | Keyword::Use
         | Keyword::Where
         | Keyword::While => None,
@@ -122,6 +123,7 @@ pub(super) fn keyword_builtin_function(keyword: &Keyword) -> Option<BuiltInFunct
         | Keyword::TypeType
         | Keyword::Unchecked
         | Keyword::Unconstrained
+        | Keyword::Unsafe
         | Keyword::Use
         | Keyword::Where
         | Keyword::While => None,
diff --git a/tooling/lsp/src/requests/hover.rs b/tooling/lsp/src/requests/hover.rs
index b6fdc6f7842..aa97def8274 100644
--- a/tooling/lsp/src/requests/hover.rs
+++ b/tooling/lsp/src/requests/hover.rs
@@ -431,7 +431,7 @@ impl<'a> TypeLinksGatherer<'a> {
             Type::NamedGeneric(var, _, _) => {
                 self.gather_type_variable_links(var);
             }
-            Type::Function(args, return_type, env) => {
+            Type::Function(args, return_type, env, _) => {
                 for arg in args {
                     self.gather_type_links(arg);
                 }
diff --git a/tooling/lsp/src/requests/inlay_hint.rs b/tooling/lsp/src/requests/inlay_hint.rs
index 8c3d8a05652..8dd63963b5d 100644
--- a/tooling/lsp/src/requests/inlay_hint.rs
+++ b/tooling/lsp/src/requests/inlay_hint.rs
@@ -293,6 +293,9 @@ impl<'a> InlayHintCollector<'a> {
             ExpressionKind::Comptime(block_expression, _span) => {
                 self.collect_in_block_expression(block_expression);
             }
+            ExpressionKind::Unsafe(block_expression, _span) => {
+                self.collect_in_block_expression(block_expression);
+            }
             ExpressionKind::AsTraitPath(path) => {
                 self.collect_in_ident(&path.impl_item, true);
             }
@@ -589,7 +592,11 @@ fn push_type_parts(typ: &Type, parts: &mut Vec<InlayHintLabelPart>, files: &File
                 parts.push(string_part(">"));
             }
         }
-        Type::Function(args, return_type, _env) => {
+        Type::Function(args, return_type, _env, unconstrained) => {
+            if *unconstrained {
+                parts.push(string_part("unconstrained "));
+            }
+
             parts.push(string_part("fn("));
             for (index, arg) in args.iter().enumerate() {
                 push_type_parts(arg, parts, files);
@@ -686,6 +693,7 @@ fn get_expression_name(expression: &Expression) -> Option<String> {
         | ExpressionKind::Comptime(..)
         | ExpressionKind::Resolved(..)
         | ExpressionKind::Literal(..)
+        | ExpressionKind::Unsafe(..)
         | ExpressionKind::Error => None,
     }
 }
diff --git a/tooling/nargo_fmt/src/rewrite/expr.rs b/tooling/nargo_fmt/src/rewrite/expr.rs
index 41b15069546..4fee7d3e197 100644
--- a/tooling/nargo_fmt/src/rewrite/expr.rs
+++ b/tooling/nargo_fmt/src/rewrite/expr.rs
@@ -168,6 +168,9 @@ pub(crate) fn rewrite(
         ExpressionKind::Comptime(block, block_span) => {
             format!("comptime {}", rewrite_block(visitor, block, block_span))
         }
+        ExpressionKind::Unsafe(block, block_span) => {
+            format!("unsafe {}", rewrite_block(visitor, block, block_span))
+        }
         ExpressionKind::Error => unreachable!(),
         ExpressionKind::Resolved(_) => {
             unreachable!("ExpressionKind::Resolved should only emitted by the comptime interpreter")
diff --git a/tooling/nargo_fmt/src/rewrite/typ.rs b/tooling/nargo_fmt/src/rewrite/typ.rs
index b586f32a6fe..86cc618eb33 100644
--- a/tooling/nargo_fmt/src/rewrite/typ.rs
+++ b/tooling/nargo_fmt/src/rewrite/typ.rs
@@ -37,7 +37,9 @@ pub(crate) fn rewrite(visitor: &FmtVisitor, _shape: Shape, typ: UnresolvedType)
                 format!("({types})")
             }
         }
-        UnresolvedTypeData::Function(args, return_type, env) => {
+        UnresolvedTypeData::Function(args, return_type, env, unconstrained) => {
+            let unconstrained = if unconstrained { "unconstrained " } else { "" };
+
             let env = if span_is_empty(env.span.unwrap()) {
                 "".into()
             } else {
@@ -53,7 +55,7 @@ pub(crate) fn rewrite(visitor: &FmtVisitor, _shape: Shape, typ: UnresolvedType)
 
             let return_type = rewrite(visitor, _shape, *return_type);
 
-            format!("fn{env}({args}) -> {return_type}")
+            format!("{unconstrained}fn{env}({args}) -> {return_type}")
         }
         UnresolvedTypeData::Resolved(_) => {
             unreachable!("Unexpected macro expansion of a type in nargo fmt input")
diff --git a/tooling/nargo_fmt/tests/expected/fn.nr b/tooling/nargo_fmt/tests/expected/fn.nr
index 4dde9a1b3ec..73248d0c04f 100644
--- a/tooling/nargo_fmt/tests/expected/fn.nr
+++ b/tooling/nargo_fmt/tests/expected/fn.nr
@@ -69,3 +69,5 @@ fn id_two<T, let I: Field>(x: [Field; I]) -> [Field; I] {}
 fn whitespace_before_generics<T>(foo: T) {}
 
 fn more_whitespace_before_generics<T>(foo: T) {}
+
+fn with_unconstrained(x: unconstrained fn() -> ()) {}
diff --git a/tooling/nargo_fmt/tests/expected/unsafe.nr b/tooling/nargo_fmt/tests/expected/unsafe.nr
new file mode 100644
index 00000000000..7d733c203de
--- /dev/null
+++ b/tooling/nargo_fmt/tests/expected/unsafe.nr
@@ -0,0 +1,8 @@
+fn main(x: pub u8, y: u8) {
+    unsafe {}
+
+    unsafe {
+        assert_eq(x, y);
+    }
+}
+
diff --git a/tooling/nargo_fmt/tests/input/fn.nr b/tooling/nargo_fmt/tests/input/fn.nr
index 16ed95a540d..8db6022808f 100644
--- a/tooling/nargo_fmt/tests/input/fn.nr
+++ b/tooling/nargo_fmt/tests/input/fn.nr
@@ -54,3 +54,5 @@ fn whitespace_before_generics <    T   >  (foo: T) {}
 
 fn more_whitespace_before_generics   <    
 T   >  (foo: T) {}
+
+fn with_unconstrained(x: unconstrained fn() -> ()) {}
diff --git a/tooling/nargo_fmt/tests/input/unsafe.nr b/tooling/nargo_fmt/tests/input/unsafe.nr
new file mode 100644
index 00000000000..6e12ef975ee
--- /dev/null
+++ b/tooling/nargo_fmt/tests/input/unsafe.nr
@@ -0,0 +1,8 @@
+fn main(x: pub u8, y: u8) {
+    unsafe { }
+
+    unsafe {
+        assert_eq(x, y);
+    }
+}
+