From d9273c4c2683a892be88f96469402f752a03a85b Mon Sep 17 00:00:00 2001
From: Jake Fecher <jfecher11@gmail.com>
Date: Thu, 25 Jul 2024 15:47:25 -0500
Subject: [PATCH 1/6] Remove 'same crate' restriction

---
 compiler/noirc_frontend/src/elaborator/mod.rs | 143 ++++++------------
 .../noirc_frontend/src/elaborator/traits.rs   |  29 ++--
 .../noirc_frontend/src/hir/comptime/errors.rs |  10 +-
 .../src/hir/comptime/interpreter.rs           |  10 +-
 .../comptime_traits/src/main.nr               |   4 +-
 5 files changed, 64 insertions(+), 132 deletions(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index f103e3a7954..01298947ce0 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -11,7 +11,7 @@ use crate::{
         def_collector::{
             dc_crate::{
                 filter_literal_globals, CompilationError, ImplMap, UnresolvedGlobal,
-                UnresolvedStruct, UnresolvedTypeAlias,
+                UnresolvedStruct, UnresolvedTrait, UnresolvedTypeAlias,
             },
             dc_mod,
         },
@@ -251,15 +251,7 @@ impl<'context> Elaborator<'context> {
         debug_comptime_in_file: Option<FileId>,
     ) -> Self {
         let mut this = Self::from_context(context, crate_id, debug_comptime_in_file);
-
-        // Filter out comptime items to execute their functions first if needed.
-        // This step is why comptime items can only refer to other comptime items
-        // in the same crate, but can refer to any item in dependencies. Trying to
-        // run these at the same time as other items would lead to them seeing empty
-        // function bodies from functions that have yet to be elaborated.
-        let (comptime_items, runtime_items) = Self::filter_comptime_items(items);
-        this.elaborate_items(comptime_items);
-        this.elaborate_items(runtime_items);
+        this.elaborate_items(items);
         this.check_and_pop_function_context();
         this
     }
@@ -284,11 +276,11 @@ impl<'context> Elaborator<'context> {
         }
 
         // Must resolve structs before we resolve globals.
-        let mut generated_items = self.collect_struct_definitions(items.types);
+        self.collect_struct_definitions(&items.types);
 
         self.define_function_metas(&mut items.functions, &mut items.impls, &mut items.trait_impls);
 
-        self.collect_traits(items.traits, &mut generated_items);
+        self.collect_traits(&items.traits);
 
         // Before we resolve any function symbols we must go through our impls and
         // re-collect the methods within into their proper module. This cannot be
@@ -312,7 +304,7 @@ impl<'context> Elaborator<'context> {
 
         // We have to run any comptime attributes on functions before the function is elaborated
         // since the generated items are checked beforehand as well.
-        self.run_attributes_on_functions(&items.functions, &mut generated_items);
+        let generated_items = self.run_attributes(&items.traits, &items.types, &items.functions);
 
         // After everything is collected, we can elaborate our generated items.
         // It may be better to inline these within `items` entirely since elaborating them
@@ -1119,30 +1111,20 @@ impl<'context> Elaborator<'context> {
         self.generics.clear();
     }
 
-    fn collect_struct_definitions(
-        &mut self,
-        structs: BTreeMap<StructId, UnresolvedStruct>,
-    ) -> CollectedItems {
+    fn collect_struct_definitions(&mut self, structs: &BTreeMap<StructId, UnresolvedStruct>) {
         // This is necessary to avoid cloning the entire struct map
         // when adding checks after each struct field is resolved.
         let struct_ids = structs.keys().copied().collect::<Vec<_>>();
 
-        // This will contain any additional top-level items that are generated at compile-time
-        // via macros. This often includes derived trait impls.
-        let mut generated_items = CollectedItems::default();
-
         // Resolve each field in each struct.
         // Each struct should already be present in the NodeInterner after def collection.
-        for (type_id, mut typ) in structs {
+        for (type_id, typ) in structs {
             self.file = typ.file_id;
             self.local_module = typ.module_id;
 
-            let attributes = std::mem::take(&mut typ.struct_def.attributes);
-            let span = typ.struct_def.span;
-
-            let fields = self.resolve_struct_fields(typ.struct_def, type_id);
+            let fields = self.resolve_struct_fields(&typ.struct_def, *type_id);
             let fields_len = fields.len();
-            self.interner.update_struct(type_id, |struct_def| {
+            self.interner.update_struct(*type_id, |struct_def| {
                 struct_def.set_fields(fields);
 
                 // TODO(https://github.com/noir-lang/noir/issues/5156): Remove this with implicit numeric generics
@@ -1169,12 +1151,11 @@ impl<'context> Elaborator<'context> {
             });
 
             for field_index in 0..fields_len {
-                self.interner
-                    .add_definition_location(ReferenceId::StructMember(type_id, field_index), None);
+                self.interner.add_definition_location(
+                    ReferenceId::StructMember(*type_id, field_index),
+                    None,
+                );
             }
-
-            let item = Value::StructDefinition(type_id);
-            self.run_comptime_attributes_on_item(&attributes, item, span, &mut generated_items);
         }
 
         // Check whether the struct fields have nested slices
@@ -1196,8 +1177,6 @@ impl<'context> Elaborator<'context> {
                 }
             }
         }
-
-        generated_items
     }
 
     fn run_comptime_attributes_on_item(
@@ -1314,7 +1293,7 @@ impl<'context> Elaborator<'context> {
 
     pub fn resolve_struct_fields(
         &mut self,
-        unresolved: NoirStruct,
+        unresolved: &NoirStruct,
         struct_id: StructId,
     ) -> Vec<(Ident, Type)> {
         self.recover_generics(|this| {
@@ -1325,7 +1304,9 @@ impl<'context> Elaborator<'context> {
             let struct_def = this.interner.get_struct(struct_id);
             this.add_existing_generics(&unresolved.generics, &struct_def.borrow().generics);
 
-            let fields = vecmap(unresolved.fields, |(ident, typ)| (ident, this.resolve_type(typ)));
+            let fields = vecmap(&unresolved.fields, |(ident, typ)| {
+                (ident.clone(), this.resolve_type(typ.clone()))
+            });
 
             this.resolving_ids.remove(&struct_id);
 
@@ -1504,66 +1485,6 @@ impl<'context> Elaborator<'context> {
         })
     }
 
-    /// Filters out comptime items from non-comptime items.
-    /// Returns a pair of (comptime items, non-comptime items)
-    fn filter_comptime_items(mut items: CollectedItems) -> (CollectedItems, CollectedItems) {
-        let mut function_sets = Vec::with_capacity(items.functions.len());
-        let mut comptime_function_sets = Vec::new();
-
-        for function_set in items.functions {
-            let mut functions = Vec::with_capacity(function_set.functions.len());
-            let mut comptime_functions = Vec::new();
-
-            for function in function_set.functions {
-                if function.2.def.is_comptime {
-                    comptime_functions.push(function);
-                } else {
-                    functions.push(function);
-                }
-            }
-
-            let file_id = function_set.file_id;
-            let self_type = function_set.self_type;
-            let trait_id = function_set.trait_id;
-
-            if !comptime_functions.is_empty() {
-                comptime_function_sets.push(UnresolvedFunctions {
-                    functions: comptime_functions,
-                    file_id,
-                    trait_id,
-                    self_type: self_type.clone(),
-                });
-            }
-
-            function_sets.push(UnresolvedFunctions { functions, file_id, trait_id, self_type });
-        }
-
-        let (comptime_trait_impls, trait_impls) =
-            items.trait_impls.into_iter().partition(|trait_impl| trait_impl.is_comptime);
-
-        let (comptime_structs, structs) =
-            items.types.into_iter().partition(|typ| typ.1.struct_def.is_comptime);
-
-        let (comptime_globals, globals) =
-            items.globals.into_iter().partition(|global| global.stmt_def.comptime);
-
-        let comptime = CollectedItems {
-            functions: comptime_function_sets,
-            types: comptime_structs,
-            type_aliases: BTreeMap::new(),
-            traits: BTreeMap::new(),
-            trait_impls: comptime_trait_impls,
-            globals: comptime_globals,
-            impls: rustc_hash::FxHashMap::default(),
-        };
-
-        items.functions = function_sets;
-        items.trait_impls = trait_impls;
-        items.types = structs;
-        items.globals = globals;
-        (comptime, items)
-    }
-
     fn add_items(
         &mut self,
         items: Vec<TopLevelStatement>,
@@ -1676,6 +1597,36 @@ impl<'context> Elaborator<'context> {
         }
     }
 
+    /// Run all the attributes on each item. The ordering is unspecified to users but currently
+    /// must run trait attributes first to (e.g.) register derive handlers before derive is
+    /// called on structs.
+    /// Returns any new items generated by attributes.
+    fn run_attributes(
+        &mut self,
+        traits: &BTreeMap<TraitId, UnresolvedTrait>,
+        types: &BTreeMap<StructId, UnresolvedStruct>,
+        functions: &[UnresolvedFunctions],
+    ) -> CollectedItems {
+        let mut generated_items = CollectedItems::default();
+
+        for (trait_id, trait_) in traits {
+            let attributes = &trait_.trait_def.attributes;
+            let item = Value::TraitDefinition(*trait_id);
+            let span = trait_.trait_def.span;
+            self.run_comptime_attributes_on_item(attributes, item, span, &mut generated_items);
+        }
+
+        for (struct_id, struct_def) in types {
+            let attributes = &struct_def.struct_def.attributes;
+            let item = Value::StructDefinition(*struct_id);
+            let span = struct_def.struct_def.span;
+            self.run_comptime_attributes_on_item(attributes, item, span, &mut generated_items);
+        }
+
+        self.run_attributes_on_functions(functions, &mut generated_items);
+        generated_items
+    }
+
     fn run_attributes_on_functions(
         &mut self,
         function_sets: &[UnresolvedFunctions],
diff --git a/compiler/noirc_frontend/src/elaborator/traits.rs b/compiler/noirc_frontend/src/elaborator/traits.rs
index a00e770218e..1e48fdd07e7 100644
--- a/compiler/noirc_frontend/src/elaborator/traits.rs
+++ b/compiler/noirc_frontend/src/elaborator/traits.rs
@@ -8,9 +8,7 @@ use crate::{
         FunctionKind, TraitItem, UnresolvedGeneric, UnresolvedGenerics, UnresolvedTraitConstraint,
     },
     hir::{
-        def_collector::dc_crate::{
-            CollectedItems, CompilationError, UnresolvedTrait, UnresolvedTraitImpl,
-        },
+        def_collector::dc_crate::{CompilationError, UnresolvedTrait, UnresolvedTraitImpl},
         type_check::TypeCheckError,
     },
     hir_def::{
@@ -29,14 +27,10 @@ use crate::{
 use super::Elaborator;
 
 impl<'context> Elaborator<'context> {
-    pub fn collect_traits(
-        &mut self,
-        traits: BTreeMap<TraitId, UnresolvedTrait>,
-        generated_items: &mut CollectedItems,
-    ) {
+    pub fn collect_traits(&mut self, traits: &BTreeMap<TraitId, UnresolvedTrait>) {
         for (trait_id, unresolved_trait) in traits {
             self.recover_generics(|this| {
-                let resolved_generics = this.interner.get_trait(trait_id).generics.clone();
+                let resolved_generics = this.interner.get_trait(*trait_id).generics.clone();
                 this.add_existing_generics(
                     &unresolved_trait.trait_def.generics,
                     &resolved_generics,
@@ -44,28 +38,23 @@ impl<'context> Elaborator<'context> {
 
                 // Resolve order
                 // 1. Trait Types ( Trait constants can have a trait type, therefore types before constants)
-                let _ = this.resolve_trait_types(&unresolved_trait);
+                let _ = this.resolve_trait_types(unresolved_trait);
                 // 2. Trait Constants ( Trait's methods can use trait types & constants, therefore they should be after)
-                let _ = this.resolve_trait_constants(&unresolved_trait);
+                let _ = this.resolve_trait_constants(unresolved_trait);
                 // 3. Trait Methods
-                let methods = this.resolve_trait_methods(trait_id, &unresolved_trait);
+                let methods = this.resolve_trait_methods(*trait_id, unresolved_trait);
 
-                this.interner.update_trait(trait_id, |trait_def| {
+                this.interner.update_trait(*trait_id, |trait_def| {
                     trait_def.set_methods(methods);
                 });
-
-                let attributes = &unresolved_trait.trait_def.attributes;
-                let item = crate::hir::comptime::Value::TraitDefinition(trait_id);
-                let span = unresolved_trait.trait_def.span;
-                this.run_comptime_attributes_on_item(attributes, item, span, generated_items);
             });
 
             // This check needs to be after the trait's methods are set since
             // the interner may set `interner.ordering_type` based on the result type
             // of the Cmp trait, if this is it.
             if self.crate_id.is_stdlib() {
-                self.interner.try_add_infix_operator_trait(trait_id);
-                self.interner.try_add_prefix_operator_trait(trait_id);
+                self.interner.try_add_infix_operator_trait(*trait_id);
+                self.interner.try_add_prefix_operator_trait(*trait_id);
             }
         }
     }
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
index 010c41d2385..505aa6c67c8 100644
--- a/compiler/noirc_frontend/src/hir/comptime/errors.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -49,7 +49,7 @@ pub enum InterpreterError {
     DebugEvaluateComptime { diagnostic: CustomDiagnostic, location: Location },
     FailedToParseMacro { error: ParserError, tokens: Rc<Tokens>, rule: &'static str, file: FileId },
     UnsupportedTopLevelItemUnquote { item: String, location: Location },
-    NonComptimeFnCallInSameCrate { function: String, location: Location },
+    ComptimeDependencyCycle { function: String, location: Location },
     NoImpl { location: Location },
     NoMatchingImplFound { error: NoMatchingImplFoundError, file: FileId },
     ImplMethodTypeMismatch { expected: Type, actual: Type, location: Location },
@@ -112,7 +112,7 @@ impl InterpreterError {
             | InterpreterError::CannotInlineMacro { location, .. }
             | InterpreterError::UnquoteFoundDuringEvaluation { location, .. }
             | InterpreterError::UnsupportedTopLevelItemUnquote { location, .. }
-            | InterpreterError::NonComptimeFnCallInSameCrate { location, .. }
+            | InterpreterError::ComptimeDependencyCycle { location, .. }
             | InterpreterError::Unimplemented { location, .. }
             | InterpreterError::NoImpl { location, .. }
             | InterpreterError::ImplMethodTypeMismatch { location, .. }
@@ -342,10 +342,10 @@ impl<'a> From<&'a InterpreterError> for CustomDiagnostic {
                 error.add_note(format!("Unquoted item was:\n{item}"));
                 error
             }
-            InterpreterError::NonComptimeFnCallInSameCrate { function, location } => {
-                let msg = format!("`{function}` cannot be called in a `comptime` context here");
+            InterpreterError::ComptimeDependencyCycle { function, location } => {
+                let msg = format!("Comptime dependency cycle while resolving `{function}`");
                 let secondary =
-                    "This function must be `comptime` or in a separate crate to be called".into();
+                    "This function uses comptime code internally which calls into itself".into();
                 CustomDiagnostic::simple_error(msg, secondary, location.span)
             }
             InterpreterError::Unimplemented { item, location } => {
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index c1622d1fed0..17b451f62c3 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -100,14 +100,6 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
             });
         }
 
-        let is_comptime = self.elaborator.interner.function_modifiers(&function).is_comptime;
-        if !is_comptime && meta.source_crate == self.crate_id {
-            // Calling non-comptime functions from within the current crate is restricted
-            // as non-comptime items will have not been elaborated yet.
-            let function = self.elaborator.interner.function_name(&function).to_owned();
-            return Err(InterpreterError::NonComptimeFnCallInSameCrate { function, location });
-        }
-
         if meta.kind != FunctionKind::Normal {
             let return_type = meta.return_type().follow_bindings();
             return self.call_special(function, arguments, return_type, location);
@@ -159,7 +151,7 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
                     self.get_function_body(function, location)
                 } else {
                     let function = self.elaborator.interner.function_name(&function).to_owned();
-                    Err(InterpreterError::NonComptimeFnCallInSameCrate { function, location })
+                    Err(InterpreterError::ComptimeDependencyCycle { function, location })
                 }
             }
         }
diff --git a/test_programs/compile_success_empty/comptime_traits/src/main.nr b/test_programs/compile_success_empty/comptime_traits/src/main.nr
index 8b1f81e6594..7d1e116dd0c 100644
--- a/test_programs/compile_success_empty/comptime_traits/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_traits/src/main.nr
@@ -20,8 +20,8 @@ struct MyType {
     value: i32,
 }
 
-comptime impl Neg for MyType {
-    comptime fn neg(self) -> Self {
+impl Neg for MyType {
+    fn neg(self) -> Self {
         self
     }
 }

From a753290996f8ddd1b849192965e88ae545a6b324 Mon Sep 17 00:00:00 2001
From: jfecher <jake@aztecprotocol.com>
Date: Thu, 25 Jul 2024 15:53:19 -0500
Subject: [PATCH 2/6] Update compiler/noirc_frontend/src/elaborator/mod.rs

---
 compiler/noirc_frontend/src/elaborator/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 01298947ce0..8ee7af76214 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -1598,7 +1598,7 @@ impl<'context> Elaborator<'context> {
     }
 
     /// Run all the attributes on each item. The ordering is unspecified to users but currently
-    /// must run trait attributes first to (e.g.) register derive handlers before derive is
+    /// we run trait attributes first to (e.g.) register derive handlers before derive is
     /// called on structs.
     /// Returns any new items generated by attributes.
     fn run_attributes(

From 10022fffd60f614434846a4435329787ced815a9 Mon Sep 17 00:00:00 2001
From: Jake Fecher <jfecher11@gmail.com>
Date: Thu, 25 Jul 2024 15:57:04 -0500
Subject: [PATCH 3/6] Remove 'is_comptime' field of trait impls

---
 compiler/noirc_frontend/src/ast/traits.rs                | 2 --
 compiler/noirc_frontend/src/elaborator/mod.rs            | 1 -
 .../noirc_frontend/src/hir/def_collector/dc_crate.rs     | 1 -
 compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs  | 1 -
 compiler/noirc_frontend/src/parser/parser/traits.rs      | 9 +++------
 5 files changed, 3 insertions(+), 11 deletions(-)

diff --git a/compiler/noirc_frontend/src/ast/traits.rs b/compiler/noirc_frontend/src/ast/traits.rs
index b23fbaede61..f3c89d6e8de 100644
--- a/compiler/noirc_frontend/src/ast/traits.rs
+++ b/compiler/noirc_frontend/src/ast/traits.rs
@@ -70,8 +70,6 @@ pub struct NoirTraitImpl {
     pub where_clause: Vec<UnresolvedTraitConstraint>,
 
     pub items: Vec<TraitImplItem>,
-
-    pub is_comptime: bool,
 }
 
 /// Represents a simple trait constraint such as `where Foo: TraitY<U, V>`
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 01298947ce0..2958f569402 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -1533,7 +1533,6 @@ impl<'context> Elaborator<'context> {
                     methods,
                     generics: trait_impl.impl_generics,
                     where_clause: trait_impl.where_clause,
-                    is_comptime: trait_impl.is_comptime,
 
                     // These last fields are filled in later
                     trait_id: None,
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 4aa61b50e55..60489660762 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -80,7 +80,6 @@ pub struct UnresolvedTraitImpl {
     pub methods: UnresolvedFunctions,
     pub generics: UnresolvedGenerics,
     pub where_clause: Vec<UnresolvedTraitConstraint>,
-    pub is_comptime: bool,
 
     // Every field after this line is filled in later in the elaborator
     pub trait_id: Option<TraitId>,
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 1dca6ded786..9eef1d7b77e 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -188,7 +188,6 @@ impl<'a> ModCollector<'a> {
                 generics: trait_impl.impl_generics,
                 where_clause: trait_impl.where_clause,
                 trait_generics: trait_impl.trait_generics,
-                is_comptime: trait_impl.is_comptime,
 
                 // These last fields are filled later on
                 trait_id: None,
diff --git a/compiler/noirc_frontend/src/parser/parser/traits.rs b/compiler/noirc_frontend/src/parser/parser/traits.rs
index 8115255368f..ffcf7e07629 100644
--- a/compiler/noirc_frontend/src/parser/parser/traits.rs
+++ b/compiler/noirc_frontend/src/parser/parser/traits.rs
@@ -3,7 +3,6 @@ use chumsky::prelude::*;
 use super::attributes::{attributes, validate_secondary_attributes};
 use super::function::function_return_type;
 use super::path::path_no_turbofish;
-use super::types::maybe_comp_time;
 use super::{block, expression, fresh_statement, function, function_declaration_parameters};
 
 use crate::ast::{
@@ -105,9 +104,8 @@ fn trait_type_declaration() -> impl NoirParser<TraitItem> {
 ///
 /// trait_implementation: 'impl' generics ident generic_args for type '{' trait_implementation_body '}'
 pub(super) fn trait_implementation() -> impl NoirParser<TopLevelStatement> {
-    maybe_comp_time()
-        .then_ignore(keyword(Keyword::Impl))
-        .then(function::generics())
+    keyword(Keyword::Impl)
+        .ignore_then(function::generics())
         .then(path_no_turbofish())
         .then(generic_type_args(parse_type()))
         .then_ignore(keyword(Keyword::For))
@@ -118,7 +116,7 @@ pub(super) fn trait_implementation() -> impl NoirParser<TopLevelStatement> {
         .then_ignore(just(Token::RightBrace))
         .map(|args| {
             let (((other_args, object_type), where_clause), items) = args;
-            let (((is_comptime, impl_generics), trait_name), trait_generics) = other_args;
+            let ((impl_generics, trait_name), trait_generics) = other_args;
 
             TopLevelStatement::TraitImpl(NoirTraitImpl {
                 impl_generics,
@@ -127,7 +125,6 @@ pub(super) fn trait_implementation() -> impl NoirParser<TopLevelStatement> {
                 object_type,
                 items,
                 where_clause,
-                is_comptime,
             })
         })
 }

From 985d536fedd9874a6301cab764e32d2715d655c5 Mon Sep 17 00:00:00 2001
From: Jake Fecher <jfecher11@gmail.com>
Date: Thu, 25 Jul 2024 16:12:33 -0500
Subject: [PATCH 4/6] Remove it from structs as well

---
 compiler/noirc_frontend/src/ast/structure.rs              | 1 -
 compiler/noirc_frontend/src/parser/parser/structs.rs      | 5 +----
 .../comptime_trait_constraint/src/main.nr                 | 8 ++++----
 3 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/compiler/noirc_frontend/src/ast/structure.rs b/compiler/noirc_frontend/src/ast/structure.rs
index 112747e09fb..732cbee9232 100644
--- a/compiler/noirc_frontend/src/ast/structure.rs
+++ b/compiler/noirc_frontend/src/ast/structure.rs
@@ -14,7 +14,6 @@ pub struct NoirStruct {
     pub generics: UnresolvedGenerics,
     pub fields: Vec<(Ident, UnresolvedType)>,
     pub span: Span,
-    pub is_comptime: bool,
 }
 
 impl Display for NoirStruct {
diff --git a/compiler/noirc_frontend/src/parser/parser/structs.rs b/compiler/noirc_frontend/src/parser/parser/structs.rs
index 9a3adf74d7f..f15bbd6e61c 100644
--- a/compiler/noirc_frontend/src/parser/parser/structs.rs
+++ b/compiler/noirc_frontend/src/parser/parser/structs.rs
@@ -1,7 +1,6 @@
 use chumsky::prelude::*;
 
 use crate::ast::{Ident, NoirStruct, UnresolvedType};
-use crate::parser::parser::types::maybe_comp_time;
 use crate::{
     parser::{
         parser::{
@@ -29,12 +28,11 @@ pub(super) fn struct_definition() -> impl NoirParser<TopLevelStatement> {
         .or(just(Semicolon).to(Vec::new()));
 
     attributes()
-        .then(maybe_comp_time())
         .then_ignore(keyword(Struct))
         .then(ident())
         .then(function::generics())
         .then(fields)
-        .validate(|((((attributes, is_comptime), name), generics), fields), span, emit| {
+        .validate(|(((attributes, name), generics), fields), span, emit| {
             let attributes = validate_secondary_attributes(attributes, span, emit);
             TopLevelStatement::Struct(NoirStruct {
                 name,
@@ -42,7 +40,6 @@ pub(super) fn struct_definition() -> impl NoirParser<TopLevelStatement> {
                 generics,
                 fields,
                 span,
-                is_comptime,
             })
         })
 }
diff --git a/test_programs/compile_success_empty/comptime_trait_constraint/src/main.nr b/test_programs/compile_success_empty/comptime_trait_constraint/src/main.nr
index 5c99f8c587e..2f2ca89cfb5 100644
--- a/test_programs/compile_success_empty/comptime_trait_constraint/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_trait_constraint/src/main.nr
@@ -24,16 +24,16 @@ fn main() {
     }
 }
 
-comptime struct TestHasher {
+struct TestHasher {
     result: Field,
 }
 
-comptime impl Hasher for TestHasher {
-    comptime fn finish(self) -> Field {
+impl Hasher for TestHasher {
+    fn finish(self) -> Field {
         self.result
     }
     
-    comptime fn write(&mut self, input: Field) {
+    fn write(&mut self, input: Field) {
         self.result += input;
     }
 }

From 126502ceae8b6e61424918390c1daf31d4a2bdc7 Mon Sep 17 00:00:00 2001
From: Jake Fecher <jfecher11@gmail.com>
Date: Thu, 25 Jul 2024 16:17:18 -0500
Subject: [PATCH 5/6] Remove comptime from another test

---
 compiler/noirc_frontend/src/parser/parser/structs.rs     | 8 +-------
 .../non_comptime_local_fn_call/Nargo.toml                | 7 -------
 .../non_comptime_local_fn_call/src/main.nr               | 9 ---------
 .../compile_success_empty/quoted_as_type/src/main.nr     | 2 +-
 4 files changed, 2 insertions(+), 24 deletions(-)
 delete mode 100644 test_programs/compile_failure/non_comptime_local_fn_call/Nargo.toml
 delete mode 100644 test_programs/compile_failure/non_comptime_local_fn_call/src/main.nr

diff --git a/compiler/noirc_frontend/src/parser/parser/structs.rs b/compiler/noirc_frontend/src/parser/parser/structs.rs
index f15bbd6e61c..58bf1693eee 100644
--- a/compiler/noirc_frontend/src/parser/parser/structs.rs
+++ b/compiler/noirc_frontend/src/parser/parser/structs.rs
@@ -34,13 +34,7 @@ pub(super) fn struct_definition() -> impl NoirParser<TopLevelStatement> {
         .then(fields)
         .validate(|(((attributes, name), generics), fields), span, emit| {
             let attributes = validate_secondary_attributes(attributes, span, emit);
-            TopLevelStatement::Struct(NoirStruct {
-                name,
-                attributes,
-                generics,
-                fields,
-                span,
-            })
+            TopLevelStatement::Struct(NoirStruct { name, attributes, generics, fields, span })
         })
 }
 
diff --git a/test_programs/compile_failure/non_comptime_local_fn_call/Nargo.toml b/test_programs/compile_failure/non_comptime_local_fn_call/Nargo.toml
deleted file mode 100644
index 8bdefbbbd21..00000000000
--- a/test_programs/compile_failure/non_comptime_local_fn_call/Nargo.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[package]
-name = "non_comptime_local_fn_call"
-type = "bin"
-authors = [""]
-compiler_version = ">=0.23.0"
-
-[dependencies]
diff --git a/test_programs/compile_failure/non_comptime_local_fn_call/src/main.nr b/test_programs/compile_failure/non_comptime_local_fn_call/src/main.nr
deleted file mode 100644
index d75bb1a922a..00000000000
--- a/test_programs/compile_failure/non_comptime_local_fn_call/src/main.nr
+++ /dev/null
@@ -1,9 +0,0 @@
-fn main() {
-    comptime {
-        let _a = id(3);
-    }
-}
-
-fn id(x: Field) -> Field {
-    x
-}
diff --git a/test_programs/compile_success_empty/quoted_as_type/src/main.nr b/test_programs/compile_success_empty/quoted_as_type/src/main.nr
index c48ac717bc0..e06294592ca 100644
--- a/test_programs/compile_success_empty/quoted_as_type/src/main.nr
+++ b/test_programs/compile_success_empty/quoted_as_type/src/main.nr
@@ -7,7 +7,7 @@ comptime fn macro() -> Quoted {
     quote { let foo: $typ = Foo {}; foo }
 }
 
-comptime struct Foo<T> {}
+struct Foo<T> {}
 
 // Ensure we call the Foo<Field> impl
 impl Foo<u32> {

From 94b933f474fd21a6bdc4fc2e5dc88aa20d978617 Mon Sep 17 00:00:00 2001
From: Jake Fecher <jfecher11@gmail.com>
Date: Fri, 26 Jul 2024 14:20:06 -0500
Subject: [PATCH 6/6] Remove is_comptime on TypeImpl

---
 aztec_macros/src/transforms/note_interface.rs | 1 -
 aztec_macros/src/transforms/storage.rs        | 1 -
 compiler/noirc_frontend/src/ast/traits.rs     | 1 -
 compiler/noirc_frontend/src/parser/parser.rs  | 8 +++-----
 4 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/aztec_macros/src/transforms/note_interface.rs b/aztec_macros/src/transforms/note_interface.rs
index d3af76f09d9..f8825f93832 100644
--- a/aztec_macros/src/transforms/note_interface.rs
+++ b/aztec_macros/src/transforms/note_interface.rs
@@ -74,7 +74,6 @@ pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), Azt
                 generics: vec![],
                 methods: vec![],
                 where_clause: vec![],
-                is_comptime: false,
             };
             module.impls.push(default_impl.clone());
             module.impls.last_mut().unwrap()
diff --git a/aztec_macros/src/transforms/storage.rs b/aztec_macros/src/transforms/storage.rs
index 073152a297b..6999234919f 100644
--- a/aztec_macros/src/transforms/storage.rs
+++ b/aztec_macros/src/transforms/storage.rs
@@ -246,7 +246,6 @@ pub fn generate_storage_implementation(
         methods: vec![(init, Span::default())],
 
         where_clause: vec![],
-        is_comptime: false,
     };
     module.impls.push(storage_impl);
 
diff --git a/compiler/noirc_frontend/src/ast/traits.rs b/compiler/noirc_frontend/src/ast/traits.rs
index f3c89d6e8de..f8f8ef667b4 100644
--- a/compiler/noirc_frontend/src/ast/traits.rs
+++ b/compiler/noirc_frontend/src/ast/traits.rs
@@ -53,7 +53,6 @@ pub struct TypeImpl {
     pub generics: UnresolvedGenerics,
     pub where_clause: Vec<UnresolvedTraitConstraint>,
     pub methods: Vec<(NoirFunction, Span)>,
-    pub is_comptime: bool,
 }
 
 /// Ast node for an implementation of a trait for a particular type
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index 0f7377044f6..b17947c4452 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -217,9 +217,8 @@ fn top_level_statement<'a>(
 ///
 /// implementation: 'impl' generics type '{' function_definition ... '}'
 fn implementation() -> impl NoirParser<TopLevelStatement> {
-    maybe_comp_time()
-        .then_ignore(keyword(Keyword::Impl))
-        .then(function::generics())
+    keyword(Keyword::Impl)
+        .ignore_then(function::generics())
         .then(parse_type().map_with_span(|typ, span| (typ, span)))
         .then(where_clause())
         .then_ignore(just(Token::LeftBrace))
@@ -227,14 +226,13 @@ fn implementation() -> impl NoirParser<TopLevelStatement> {
         .then_ignore(just(Token::RightBrace))
         .map(|args| {
             let ((other_args, where_clause), methods) = args;
-            let ((is_comptime, generics), (object_type, type_span)) = other_args;
+            let (generics, (object_type, type_span)) = other_args;
             TopLevelStatement::Impl(TypeImpl {
                 generics,
                 object_type,
                 type_span,
                 where_clause,
                 methods,
-                is_comptime,
             })
         })
 }