Structs: Fields check

ast/src/analyzed/display.rs

@@ -64,9 +64,7 @@ impl<T: Display> Display for Analyzed<T> {
                         if matches!(
                             definition,
                             Some(FunctionValueDefinition::TypeConstructor(_, _))
-                        ) || matches!(
-                            definition,
-                            Some(FunctionValueDefinition::TraitFunction(_, _))
+                                | Some(FunctionValueDefinition::TraitFunction(_, _))
                         ) {
                             // These are printed as part of the enum / trait.
                             continue;

pil-analyzer/src/expression_processor.rs

@@ -4,8 +4,9 @@ use powdr_ast::{
     parsed::{
         self, asm::SymbolPath, types::Type, ArrayExpression, ArrayLiteral, BinaryOperation,
         BlockExpression, IfExpression, LambdaExpression, LetStatementInsideBlock, MatchArm,
-        MatchExpression, NamespacedPolynomialReference, Number, Pattern, SelectedExpressions,
-        StatementInsideBlock, SymbolCategory, UnaryOperation,
+        MatchExpression, NamedExpression, NamespacedPolynomialReference, Number, Pattern,
+        SelectedExpressions, StatementInsideBlock, StructExpression, SymbolCategory,
+        UnaryOperation,
     },
 };
 
@@ -189,7 +190,34 @@ impl<'a, D: AnalysisDriver> ExpressionProcessor<'a, D> {
                 self.process_block_expression(statements, expr, src)
             }
             PExpression::FreeInput(_, _) => panic!(),
-            PExpression::StructExpression(_, _) => unimplemented!("Structs are not supported yet"),
+            PExpression::StructExpression(
+                src,
+                StructExpression {
+                    name: reference,
+                    fields,
+                },
+            ) => {
+                let type_args = reference
+                    .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),
+                            type_args,
+                        }),
+                        fields: fields
+                            .into_iter()
+                            .map(|named_expr| NamedExpression {
+                                name: named_expr.name,
+                                body: Box::new(self.process_expression(*named_expr.body)),
+                            })
+                            .collect(),
+                    },
+                )
+            }
         }
     }
 

pil-analyzer/src/pil_analyzer.rs

@@ -13,8 +13,8 @@ use powdr_ast::parsed::asm::{
 use powdr_ast::parsed::types::Type;
 use powdr_ast::parsed::visitor::{AllChildren, Children};
 use powdr_ast::parsed::{
-    self, FunctionKind, LambdaExpression, PILFile, PilStatement, SymbolCategory,
-    TraitImplementation,
+    self, FunctionKind, LambdaExpression, PILFile, PilStatement, StructDeclaration, SymbolCategory,
+    TraitImplementation, TypeDeclaration,
 };
 use powdr_number::{FieldElement, GoldilocksField};
 
@@ -56,6 +56,7 @@ fn analyze<T: FieldElement>(files: Vec<PILFile>) -> Result<Analyzed<T>, Vec<Erro
     let mut analyzer = PILAnalyzer::new();
     analyzer.process(files)?;
     analyzer.side_effect_check()?;
+    analyzer.structs_check()?;
     analyzer.type_check()?;
     // TODO should use Result here as well.
     let solved_impls = analyzer.resolve_trait_impls();
@@ -257,6 +258,69 @@ impl PILAnalyzer {
         }
     }
 
+    pub fn structs_check(&self) -> Result<(), Vec<Error>> {
+        let mut errors = vec![];
+        let struct_declarations: HashMap<String, StructDeclaration> = self
+            .definitions
+            .iter()
+            .filter_map(|(name, (_, value))| {
+                if let Some(FunctionValueDefinition::TypeDeclaration(TypeDeclaration::Struct(
+                    struct_decl,
+                ))) = value
+                {
+                    Some((name.clone(), struct_decl.clone()))
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        for (_, def) in self.definitions.values() {
+            let Some(def) = def else { continue };
+
+            def.all_children().for_each(|expr| {
+                if let Expression::StructExpression(sr, struct_expr) = expr {
+                    let Some(struct_decl) = struct_declarations.get(&struct_expr.name.to_string())
+                    else {
+                        errors.push(sr.with_error(format!(
+                            "Struct '{}' has not been declared",
+                            struct_expr.name
+                        )));
+                        return;
+                    };
+
+                    let mut used_fields = HashSet::new();
+
+                    for named_expr in &struct_expr.fields {
+                        if !struct_decl.fields.iter().any(|f| f.name == named_expr.name) {
+                            errors.push(sr.with_error(format!(
+                                "Field '{}' not found in struct '{}'",
+                                named_expr.name, struct_expr.name
+                            )));
+                        } else {
+                            used_fields.insert(named_expr.name.clone());
+                        }
+                    }
+
+                    for field in &struct_decl.fields {
+                        if !used_fields.contains(&field.name) {
+                            errors.push(sr.with_error(format!(
+                                "Field '{}' is declared but never used in struct '{}' initialization",
+                                field.name, struct_expr.name
+                            )));
+                        }
+                    }
+                }
+            });
+        }
+
+        if errors.is_empty() {
+            Ok(())
+        } else {
+            Err(errors)
+        }
+    }
+
     pub fn type_check(&mut self) -> Result<(), Vec<Error>> {
         let query_type: Type = parse_type("int -> std::prelude::Query").unwrap().into();
         let mut expressions = vec![];

pil-analyzer/tests/types.rs

@@ -734,3 +734,39 @@ fn prover_functions() {
     ";
     type_check(input, &[("a", "", "int"), ("b", "", "()[]")]);
 }
+
+#[test]
+#[should_panic = "Type symbol not found: NotADot"]
+fn wrong_struct() {
+    let input = "
+    struct Dot { x: int, y: int }
+    let f: int -> Dot = |i| NotADot{x: 0, y: i};
+    let x = f(0);
+    ";
+    type_check(input, &[]);
+}
+
+#[test]
+#[should_panic = "Field 'a' not found in struct 'Dot'"]
+fn struct_wrong_fields() {
+    let input = "
+    struct Dot { x: int, y: int }
+    let f: int -> Dot = |i| Dot{a: 0, y: i};
+    let x = f(0);
+    ";
+    type_check(input, &[]);
+}
+
+#[test]
+#[should_panic = "Field 'z' is declared but never used in struct 'Point' initialization"]
+fn test_struct_unused_fields() {
+    let input = "    struct Point {
+        x: int,
+        y: int,
+        z: int,
+    }
+    let p: Point = Point{ y: 0, x: 2 };
+";
+
+    type_check(input, &[]);
+}