fix: more test and issues with scoping/names

crates/aiken-lang/src/expr.rs

@@ -241,6 +241,10 @@ impl TypedExpr {
         )
     }
 
+    pub fn is_error_term(&self) -> bool {
+        matches!(self, Self::ErrorTerm { .. })
+    }
+
     /// Returns `true` if the typed expr is [`Assignment`].
     pub fn is_assignment(&self) -> bool {
         matches!(self, Self::Assignment { .. })

crates/aiken-lang/src/tests/check.rs

@@ -318,19 +318,17 @@ fn mark_constructors_as_used_via_field_access() {
         bar: Int,
       }
 
-      validator foo {
-        spend(d: Datum, _r, _c) {
+      fn spend(d: Datum, _r, _c) {
         when d is {
           D0(params) -> params.foo == 1
           D1(_params) -> False
         }
       }
-      }
     "#;
 
-    let (warnings, _) = check_validator(parse(source_code)).unwrap();
+    let (warnings, _) = check(parse(source_code)).unwrap();
 
-    assert_eq!(warnings.len(), 1)
+    assert_eq!(warnings.len(), 2)
 }
 
 #[test]
@@ -2506,27 +2504,6 @@ fn validator_public() {
     assert!(check_validator(parse(source_code)).is_ok())
 }
 
-#[test]
-fn validator_private_everything() {
-    let source_code = r#"
-        type Datum {
-          foo: Int,
-        }
-
-        type Redeemer {
-          bar: Int,
-        }
-
-        validator bar {
-          spend(datum: Datum, redeemer: Redeemer, _ctx) {
-            datum.foo == redeemer.bar
-          }
-        }
-    "#;
-
-    assert!(check_validator(parse(source_code)).is_ok())
-}
-
 #[test]
 fn tuple_access_on_call() {
     let source_code = r#"

crates/aiken-lang/src/tipo/environment.rs

@@ -309,29 +309,43 @@ impl<'a> Environment<'a> {
                 end_position,
                 handlers,
                 name,
-                fallback,
+                mut fallback,
                 location,
                 params,
             }) => {
                 let handlers = handlers
                     .into_iter()
-                    .map(|fun| {
-                        let Definition::Fn(fun) =
+                    .map(|mut fun| {
+                        let handler_name = format!("{}_{}", &name, &fun.name);
+
+                        let old_name = fun.name;
+                        fun.name = handler_name;
+
+                        let Definition::Fn(mut fun) =
                             self.generalise_definition(Definition::Fn(fun), module_name)
                         else {
                             unreachable!()
                         };
 
+                        fun.name = old_name;
+
                         fun
                     })
                     .collect();
 
-                let Definition::Fn(fallback) =
+                let fallback_name = format!("{}_{}", &name, &fallback.name);
+
+                let old_name = fallback.name;
+                fallback.name = fallback_name;
+
+                let Definition::Fn(mut fallback) =
                     self.generalise_definition(Definition::Fn(fallback), module_name)
                 else {
                     unreachable!()
                 };
 
+                fallback.name = old_name;
+
                 Definition::Validator(Validator {
                     doc,
                     name,

crates/aiken-lang/src/tipo/infer.rs

@@ -178,6 +178,11 @@ fn infer_definition(
         }) => {
             let params_length = params.len();
 
+            environment.in_new_scope(|environment| {
+                let fallback_name = format!("{}_{}", &name, &fallback.name);
+
+                put_params_in_scope(&fallback_name, environment, &params);
+
                 let mut typed_handlers = vec![];
 
                 for mut handler in handlers {
@@ -185,11 +190,16 @@ fn infer_definition(
                         let temp_params = params.iter().cloned().chain(handler.arguments);
                         handler.arguments = temp_params.collect();
 
-                    put_params_in_scope(&handler.name, environment, &params);
+                        let handler_name = format!("{}_{}", &name, &handler.name);
+
+                        let old_name = handler.name;
+                        handler.name = handler_name;
 
                         let mut typed_fun =
                             infer_function(&handler, module_name, hydrators, environment, tracing)?;
 
+                        typed_fun.name = old_name;
+
                         if !typed_fun.return_type.is_bool() {
                             return Err(Error::ValidatorMustReturnBool {
                                 return_type: typed_fun.return_type.clone(),
@@ -224,12 +234,16 @@ fn infer_definition(
                     let temp_params = params.iter().cloned().chain(fallback.arguments);
                     fallback.arguments = temp_params.collect();
 
-                put_params_in_scope(&fallback.name, environment, &params);
+                    let old_name = fallback.name;
+                    fallback.name = fallback_name;
 
                     let mut typed_fallback =
                         infer_function(&fallback, module_name, hydrators, environment, tracing)?;
 
-                if !typed_fallback.return_type.is_bool() {
+                    typed_fallback.name = old_name;
+
+                    if !typed_fallback.body.is_error_term() && !typed_fallback.return_type.is_bool()
+                    {
                         return Err(Error::ValidatorMustReturnBool {
                             return_type: typed_fallback.return_type.clone(),
                             location: typed_fallback.location,
@@ -274,6 +288,7 @@ fn infer_definition(
                     location,
                     params: typed_params,
                 }))
+            })
         }
 
         Definition::Test(f) => {

crates/aiken-project/src/blueprint/validator.rs

@@ -550,8 +550,8 @@ mod tests {
 
             type UUID { UUID }
 
-            validator {
-              fn opaque_singleton_variants(redeemer: Dict<UUID, Int>, ctx: Void) {
+            validator opaque_singleton_variants {
+              spend(redeemer: Dict<UUID, Int>, ctx: Void) {
                 True
               }
             }
@@ -568,8 +568,8 @@ mod tests {
               denominator: Int,
             }
 
-            validator {
-              fn opaque_singleton_multi_variants(redeemer: Rational, ctx: Void) {
+            validator opaque_singleton_multi_variants {
+              spend(redeemer: Rational, ctx: Void) {
                 True
               }
             }
@@ -585,8 +585,8 @@ mod tests {
                 foo: Data
             }
 
-            validator {
-              fn nested_data(datum: Foo, redeemer: Int, ctx: Void) {
+            validator nested_data {
+              spend(datum: Foo, redeemer: Int, ctx: Void) {
                 True
               }
             }
@@ -604,8 +604,8 @@ mod tests {
               Mul(Expr, Expr)
             }
 
-            validator {
-              fn recursive_types(redeemer: Expr, ctx: Void) {
+            validator recursive_types {
+              spend(redeemer: Expr, ctx: Void) {
                 True
               }
             }
@@ -632,8 +632,8 @@ mod tests {
                 }
             }
 
-            validator {
-              fn recursive_generic_types(datum: Foo, redeemer: LinkedList<Int>, ctx: Void) {
+            validator recursive_generic_types {
+              spend(datum: Foo, redeemer: LinkedList<Int>, ctx: Void) {
                 True
               }
             }
@@ -649,8 +649,8 @@ mod tests {
                 foo: Int
             }
 
-            validator {
-                fn annotated_data(datum: Data<Foo>, redeemer: Data, ctx: Void) {
+            validator annotated_data {
+                spend(datum: Data<Foo>, redeemer: Data, ctx: Void) {
                     True
                 }
             }

crates/aiken-project/src/tests/gen_uplc.rs

@@ -3687,8 +3687,8 @@ fn when_tuple_deconstruction() {
         Buy
       }
 
-      validator {
-        fn spend(dat: Datum, red: RedSpend, ctx: Data) {
+      validator thing {
+        spend(dat: Datum, red: RedSpend, ctx: Data) {
           when (dat, red) is {
             (A(a), Spend(x)) ->
               (a.idx == x)?
@@ -4046,8 +4046,8 @@ fn generic_validator_type_test() {
         something: Void,
       }
 
-      validator {
-        fn err_example(r: A<B>, _ctx: Data) -> Bool {
+      validator err_example {
+        spend(r: A<B>, _ctx: Data) -> Bool {
           when r is {
             NoA ->
               False
@@ -5562,8 +5562,8 @@ fn opaque_value_in_datum() {
       }
 
 
-      validator {
-        fn spend(dat: Dat, red: Data, ctx: Data) {
+      validator foo {
+        spend(dat: Dat, red: Data, ctx: Data) {
           let val = dat.a
 
           expect [Pair(_, amount)] = val.inner.inner