feat: TypeDefinition::as_type_with_generics

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

@@ -215,6 +215,9 @@ impl Interpreter<'_, '_> {
             "type_def_add_attribute" => type_def_add_attribute(interner, arguments, location),
             "type_def_add_generic" => type_def_add_generic(interner, arguments, location),
             "type_def_as_type" => type_def_as_type(interner, arguments, location),
+            "type_def_as_type_with_generics" => {
+                type_def_as_type_with_generics(interner, arguments, return_type, location)
+            }
             "type_def_eq" => type_def_eq(arguments, location),
             "type_def_fields" => type_def_fields(interner, arguments, location, call_stack),
             "type_def_fields_as_written" => {
@@ -474,6 +477,31 @@ fn type_def_as_type(
     Ok(Value::Type(Type::DataType(type_def_rc, generics)))
 }
 
+/// `fn as_type_with_generics(self, generics: [Type]) -> Option<Type>`
+fn type_def_as_type_with_generics(
+    interner: &NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    return_type: Type,
+    location: Location,
+) -> IResult<Value> {
+    let (type_def, generics) = check_two_arguments(arguments, location)?;
+    let type_id = get_type_id(type_def)?;
+    let type_def_rc = interner.get_type(type_id);
+    let type_def = type_def_rc.borrow();
+
+    let generics_location = generics.1;
+    let (generics, _) = get_slice(interner, generics)?;
+    let generics = try_vecmap(generics, |generic| get_type((generic, generics_location)))?;
+
+    let correct_generic_count = type_def.generics.len() == generics.len();
+    drop(type_def);
+
+    let type_result =
+        correct_generic_count.then(|| Value::Type(Type::DataType(type_def_rc, generics)));
+
+    Ok(option(return_type, type_result, location))
+}
+
 /// fn generics(self) -> [(Type, `Option<Type>`)]
 fn type_def_generics(
     interner: &NodeInterner,

compiler/noirc_frontend/src/hir/comptime/value.rs

@@ -367,7 +367,6 @@ impl Value {
         location: Location,
     ) -> IResult<ExprId> {
         let typ = self.get_type().into_owned();
-
         let expression = match self {
             Value::Unit => HirExpression::Literal(HirLiteral::Unit),
             Value::Bool(value) => HirExpression::Literal(HirLiteral::Bool(value)),

docs/docs/noir/standard_library/meta/struct_def.md

@@ -39,6 +39,13 @@ Example:
 Returns this type definition as a type in the source program. If this definition has
 any generics, the generics are also included as-is.
 
+### as_type_with_generics
+
+#include_code as_type_with_generics noir_stdlib/src/meta/type_def.nr rust
+
+Returns a type from this type definition using the given generic arguments. Returns `Option::none()`
+if an incorrect amount of generic arguments are given for this type.
+
 ### generics
 
 #include_code generics noir_stdlib/src/meta/type_def.nr rust

noir_stdlib/src/meta/type_def.nr

@@ -12,12 +12,23 @@ impl TypeDefinition {
     // docs:end:add_generic
 
     /// Return a syntactic version of this type definition as a type.
-    /// For example, `as_type(quote { type Foo<A, B> { ... } })` would return `Foo<A, B>`
+    /// For example, `type Foo<A, B> { ... })` would return `Foo<A, B>` when called with this method.
     #[builtin(type_def_as_type)]
     // docs:start:as_type
     pub comptime fn as_type(self) -> Type {}
     // docs:end:as_type
 
+    /// Return this type applied to the given generic arguments.
+    /// For example, given `type Foo<A, B> { ... })` could be applied to `&[quote[i32].as_type(), quote[Field].as_type()]`
+    /// to return `Foo<i32, Field>`.
+    ///
+    /// If an incorrect number of generic arguments are given, this function will return None.
+    /// Otherwise, this function returns Some with the resulting type inside.
+    #[builtin(type_def_as_type_with_generics)]
+    // docs:start:as_type_with_generics
+    pub comptime fn as_type_with_generics(self, generics: [Type]) -> Option<Type> {}
+    // docs:end:as_type_with_generics
+
     #[builtin(type_def_has_named_attribute)]
     // docs:start:has_named_attribute
     pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}

test_programs/compile_success_empty/comptime_struct_definition/src/main.nr

@@ -77,5 +77,14 @@ fn main() {
 
         assert_eq(visibility1, quote {});
         assert_eq(visibility2, quote {});
+
+        // Test TypeDefinition::as_type_with_generics
+        let i32_type = quote [i32].as_type();
+
+        let applied = struct_def.as_type_with_generics(&[i32_type, i32_type, i32_type]);
+        let invalid = struct_def.as_type_with_generics(&[i32_type, i32_type]); // invalid generic count
+
+        assert_eq(applied.unwrap(), quote [MyType<i32, i32, i32>].as_type());
+        assert(invalid.is_none());
     }
 }