feat: add Type::implements

compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs

@@ -91,6 +91,7 @@
             "type_as_struct" => type_as_struct(arguments, return_type, location),
             "type_as_tuple" => type_as_tuple(arguments, return_type, location),
             "type_eq" => type_eq(arguments, location),
+            "type_implements" => type_implements(interner, arguments, location),
             "type_is_bool" => type_is_bool(arguments, location),
             "type_is_field" => type_is_field(arguments, location),
             "type_of" => type_of(arguments, location),
@@ -356,7 +357,7 @@
     let argument = check_one_argument(arguments, location)?;
     let typ = parse(argument, parser::parse_type(), "a type")?;
     let typ =
         interpreter.elaborate_item(interpreter.current_function, |elab| elab.resolve_type(typ));
     Ok(Value::Type(typ))
 }
 
@@ -490,6 +491,21 @@
     Ok(Value::Bool(self_type == other_type))
 }
 
+// fn implements(self, constraint: TraitConstraint) -> bool
+fn type_implements(
+    interner: &NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+) -> IResult<Value> {
+    let (typ, constraint) = check_two_arguments(arguments, location)?;
+
+    let typ = get_type(typ)?;
+    let (trait_id, generics) = get_trait_constraint(constraint)?;
+
+    let implements = interner.try_lookup_trait_implementation(&typ, trait_id, &generics).is_ok();
+    Ok(Value::Bool(implements))
+}
+
 // fn is_bool(self) -> bool
 fn type_is_bool(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
     let value = check_one_argument(arguments, location)?;

noir_stdlib/src/meta/typ.nr

@@ -20,6 +20,9 @@ impl Type {
     #[builtin(type_as_tuple)]
     fn as_tuple(self) -> Option<[Type]> {}
 
+    #[builtin(type_implements)]
+    fn implements(self, constraint: TraitConstraint) -> bool {}
+
     #[builtin(type_is_bool)]
     fn is_bool(self) -> bool {}
 

test_programs/compile_success_empty/comptime_type/src/main.nr

@@ -4,6 +4,21 @@ struct Foo<T> {
     x: T
 }
 
+trait SomeTrait {
+
+}
+struct StructImplementsSomeTrait {
+
+}
+
+impl SomeTrait for StructImplementsSomeTrait {
+
+}
+
+struct StructDoesNotImplementSomeTrait {
+
+}
+
 fn main() {
     comptime
     {
@@ -82,5 +97,11 @@ fn main() {
 
         assert_eq(generics.len(), 1);
         assert_eq(generics[0], field_type_1);
+
+        let some_trait = quote { SomeTrait }.as_trait_constraint();
+        let struct_implements_some_trait = quote { StructImplementsSomeTrait }.as_type();
+        let struct_does_not_implement_some_trait = quote { StructDoesNotImplementSomeTrait }.as_type();
+        assert(struct_implements_some_trait.implements(some_trait));
+        assert(!struct_does_not_implement_some_trait.implements(some_trait));
     }
 }