Structs: Type inference

pil-analyzer/src/expression_processor.rs

@@ -190,22 +190,16 @@ impl<'a, D: AnalysisDriver> ExpressionProcessor<'a, D> {
                 self.process_block_expression(statements, expr, src)
             }
             PExpression::FreeInput(_, _) => panic!(),
-            PExpression::StructExpression(
-                src,
-                StructExpression {
-                    name: reference,
-                    fields,
-                },
-            ) => {
-                let type_args = reference
+            PExpression::StructExpression(src, StructExpression { name, fields }) => {
+                let type_args = name
                     .type_args
                     .map(|args| args.into_iter().map(|t| self.process_type(t)).collect());
 
                 Expression::StructExpression(
                     src,
                     StructExpression {
                         name: Reference::Poly(PolynomialReference {
-                            name: self.driver.resolve_type_ref(&reference.path),
+                            name: self.driver.resolve_type_ref(&name.path),
                             type_args,
                         }),
                         fields: fields

pil-analyzer/src/type_inference.rs

@@ -1,13 +1,9 @@
-use std::{
-    collections::{BTreeSet, HashMap},
-    str::FromStr,
-};
+use std::collections::{BTreeSet, HashMap};
 
 use itertools::Itertools;
 use powdr_ast::{
     analyzed::{Expression, PolynomialReference, Reference},
     parsed::{
-        asm::SymbolPath,
         display::format_type_scheme_around_name,
         types::{ArrayType, FunctionType, TupleType, Type, TypeBounds, TypeScheme},
         visitor::ExpressionVisitable,
@@ -738,11 +734,33 @@ impl TypeChecker {
                 result?
             }
             Expression::StructExpression(sr, StructExpression { name, fields }) => {
-                let Reference::Poly(PolynomialReference { name, .. }) = name else {
+                let Reference::Poly(PolynomialReference { name, type_args }) = name else {
                     unreachable!()
                 };
                 let struct_decl = self.struct_declarations.get(name).unwrap();
 
+                let scheme = TypeScheme {
+                    ty: Type::TypeVar(struct_decl.name.clone()),
+                    vars: struct_decl.type_vars.clone(),
+                };
+                let (ty, args) = self.unifier.instantiate_scheme(scheme);
+                if let Some(requested_type_args) = type_args {
+                    if requested_type_args.len() != args.len() {
+                        return Err(sr.with_error(format!(
+                            "Expected {} type arguments for struct {name}, but got {}: {}",
+                            args.len(),
+                            requested_type_args.len(),
+                            requested_type_args.iter().join(", ")
+                        )));
+                    }
+                    for (requested, inferred) in requested_type_args.iter_mut().zip(&args) {
+                        requested.substitute_type_vars(&self.declared_type_vars);
+                        self.unifier
+                            .unify_types(requested.clone(), inferred.clone())
+                            .map_err(|err| sr.with_error(err))?;
+                    }
+                }
+
                 let field_types: HashMap<_, _> = fields
                     .iter()
                     .map(|named_expr| {
@@ -752,15 +770,11 @@ impl TypeChecker {
                     .collect();
 
                 for named_expr in fields.iter_mut() {
-                    if let Some(field_type) = field_types.get(&named_expr.name) {
-                        self.expect_type(field_type, named_expr.body.as_mut())?;
-                    }
+                    let field_type = field_types.get(&named_expr.name).unwrap();
+                    self.expect_type(field_type, named_expr.body.as_mut())?;
                 }
 
-                match SymbolPath::from_str(name) {
-                    Ok(named_type) => Ok(Type::NamedType(named_type, None)),
-                    Err(err) => Err(sr.with_error(err))?,
-                }?
+                ty
             }
         })
     }

pil-analyzer/tests/types.rs

@@ -744,3 +744,13 @@ fn simple_struct() {
     ";
     type_check(input, &[("x", "", "Dot")]);
 }
+
+#[test]
+fn simple_struct_type_arg() {
+    let input = "
+    struct Dot<T> { x: int, y: T }
+    let f: int -> Dot = |i| Dot{x: 0, y: i};
+    let x = f(0);
+    ";
+    type_check(input, &[("x", "", "Dot")]);
+}