30ae945 | plum

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

30ae945 — Peter John 2026-07-24T11:36:01+05:30

test(plum-checker): migrate test fixtures to bracket generics syntax

Files changed (2) hide show

plum-checker/tests/checker_tests.rs +24 -24
plum-checker/tests/monomorphize_tests.rs +26 -26

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -213,7 +213,7 @@ isNone(o: Option) -> Bool = o == None
 fn variant_construction_checks_arg_count_and_types() {
     let src = "\
 enum Option =
-  | Some(Int)
+  | Some[Int]
   | None
 makeSome(v: Int) -> Option =
@@ -243,8 +243,8 @@ bad() -> Option =
 fn variant_construction_wrong_arg_count_is_error() {
     let src = "\
 enum Shape =
-  | Rect(Float, Float)
+  | Rect[Float, Float]
-  | Circle(Float)
+  | Circle[Float]
 bad() -> Shape =
   Rect(1.0)
@@ -258,8 +258,8 @@ bad() -> Shape =
 fn constructor_pattern_binds_fields_to_declared_types() {
     let src = "\
 enum Shape =
-  | Rect(Float, Float)
+  | Rect[Float, Float]
-  | Circle(Float)
+  | Circle[Float]
 area(s: Shape) -> Float =
   match s
@@ -277,8 +277,8 @@ area(s: Shape) -> Float =
 fn constructor_pattern_wrong_field_count_is_error() {
     let src = "\
 enum Shape =
-  | Rect(Float, Float)
+  | Rect[Float, Float]
-  | Circle(Float)
+  | Circle[Float]
 bad(s: Shape) -> Float =
   match s
@@ -319,8 +319,8 @@ enum Animal =
 #[test]
 fn generic_class_instantiated_at_two_concrete_types_type_checks() {
     let src = "\
-type Box(a) =
+type Box[T] =
-  value: a
+  value: T
 makeIntBox() -> Box =
   Box(value: 5)
@@ -336,7 +336,7 @@ makeStrBox() -> Box =
 #[test]
 fn generic_function_called_with_different_concrete_types_per_site_type_checks() {
     let src = "\
-wrap(value: a) -> Bool =
+wrap(value: T) -> Bool =
   True
 useInt() -> Bool =
@@ -353,7 +353,7 @@ useStr() -> Bool =
 #[test]
 fn generic_function_with_two_independent_type_params_type_checks() {
     let src = "\
-pair(first: a, second: b) -> Bool =
+pair(first: T, second: U) -> Bool =
   True
 use() -> Bool =
@@ -372,7 +372,7 @@ fn generic_function_with_internally_inconsistent_body_is_rejected_after_speciali
     // behavior — rewriting `wrong$Str`'s `-> Int` to `-> Str` — would make the
     // whole program type-check, masking the real `expected Int, found Str` error.
     let src = "\
-wrong(x: a) -> Int =
+wrong(x: T) -> Int =
   \"hello\"
 useIt() -> Str =
@@ -392,7 +392,7 @@ fn generic_enum_single_instantiation_type_checks() {
     // matched, must resolve end-to-end via check_source.
     let src = "\
 enum Option =
-  | Some(a)
+  | Some[T]
   | None
 get() -> Int =
@@ -435,7 +435,7 @@ fn generic_enum_multiple_instantiations_coexist_and_type_check() {
     // behavior this task adds (previously this was a documented, rejected limitation).
     let src = "\
 enum Option =
-  | Some(a)
+  | Some[T]
   | None
 useInt() -> Int =
@@ -473,10 +473,10 @@ useStr() -> Str =
 #[test]
 fn generic_method_on_generic_class_type_checks() {
     let src = "\
-type Box(a) =
+type Box[T] =
-  value: a
+  value: T
-getValue<Box>() -> a =
+getValue<Box>() -> T =
   self.value
 use() -> Int =
@@ -499,10 +499,10 @@ fn unbounded_recursive_generic_instantiation_is_a_clear_error() {
     // declaration, which is never itself a call site and so never reaches the
     // worklist at all) and must fail with a clear, bounded error rather than hang.
     let src = "\
-type Box(a) =
+type Box[T] =
-  value: a
+  value: T
-recurse(v: a) -> Int =
+recurse(v: T) -> Int =
   b = Box(value: v)
   recurse(b)
@@ -525,7 +525,7 @@ fn ordinary_function_with_bare_generic_enum_param_type_checks() {
     // function taking a bare generic-enum-typed parameter.
     let src = "\
 enum Option =
-  | Some(a)
+  | Some[T]
   | None
 unwrapOr(o: Option, default: Int) -> Int =
@@ -556,10 +556,10 @@ fn ordinary_function_with_bare_generic_class_param_type_checks() {
     // now, but the identical root cause: `Box` is dropped from the monomorphized
     // output, so a bare `Box`-typed param would otherwise reference nothing.
     let src = "\
-type Box(a) =
+type Box[T] =
-  value: a
+  value: T
-getBoxValue<Box>() -> a =
+getBoxValue<Box>() -> T =
   self.value
 sumBox(b: Box) -> Int =

plum-checker/tests/monomorphize_tests.rs CHANGED Viewed

@@ -3,12 +3,12 @@ use plum_checker::types::PlumType;
 use plum_core::ast;
 #[test]
-fn is_generic_param_name_accepts_single_lowercase_letters_only() {
+fn is_generic_param_name_accepts_single_uppercase_letters_only() {
-    assert!(is_generic_param_name("a"));
+    assert!(is_generic_param_name("T"));
-    assert!(is_generic_param_name("d"));
+    assert!(is_generic_param_name("W"));
     assert!(!is_generic_param_name("Int"));
+    assert!(!is_generic_param_name("TU"));
-    assert!(!is_generic_param_name("ab"));
+    assert!(!is_generic_param_name("a"));
-    assert!(!is_generic_param_name("A"));
     assert!(!is_generic_param_name(""));
 }
@@ -17,37 +17,37 @@ fn class_generic_params_reads_declared_generics_list() {
     let c = ast::Class {
         name: "Box".to_string(),
         implements: vec![],
-        generics: vec![ast::GenericParam { name: "a".to_string(), bounds: vec![] }],
+        generics: vec![ast::GenericParam { name: "T".to_string(), bounds: vec![] }],
-        fields: vec![ast::Field { name: "value".to_string(), ty: ast::Type { name: "a".to_string(), generics: vec![] } }],
+        fields: vec![ast::Field { name: "value".to_string(), ty: ast::Type { name: "T".to_string(), generics: vec![] } }],
     };
-    assert_eq!(class_generic_params(&c), vec!["a".to_string()]);
+    assert_eq!(class_generic_params(&c), vec!["T".to_string()]);
 }
 #[test]
-fn fn_generic_params_detects_implicit_lowercase_letter_types_in_order() {
+fn fn_generic_params_detects_implicit_uppercase_letter_types_in_order() {
     let f = ast::Fn {
         name: "pair".to_string(),
         type_param: None,
         params: vec![
-            ast::Param { name: "first".to_string(), ty: ast::ParamType::Type(ast::Type { name: "a".to_string(), generics: vec![] }), default: None },
+            ast::Param { name: "first".to_string(), ty: ast::ParamType::Type(ast::Type { name: "T".to_string(), generics: vec![] }), default: None },
-            ast::Param { name: "second".to_string(), ty: ast::ParamType::Type(ast::Type { name: "b".to_string(), generics: vec![] }), default: None },
+            ast::Param { name: "second".to_string(), ty: ast::ParamType::Type(ast::Type { name: "U".to_string(), generics: vec![] }), default: None },
         ],
-        returns: Some(ast::ReturnType { name: "Bool".to_string(), generics: vec![] }),
+        returns: Some(ast::Type { name: "Bool".to_string(), generics: vec![] }),
         body: ast::FnBody::Block(ast::Block { stmts: vec![] }),
     };
-    assert_eq!(fn_generic_params(&f), vec!["a".to_string(), "b".to_string()]);
+    assert_eq!(fn_generic_params(&f), vec!["T".to_string(), "U".to_string()]);
 }
 #[test]
-fn enum_generic_params_detects_implicit_lowercase_letter_variant_fields() {
+fn enum_generic_params_detects_implicit_uppercase_letter_variant_fields() {
     let e = ast::Enum {
         name: "Option".to_string(),
         variants: vec![
-            ast::EnumVariant { name: "Some".to_string(), fields: vec!["a".to_string()] },
+            ast::EnumVariant { name: "Some".to_string(), fields: vec!["T".to_string()] },
             ast::EnumVariant { name: "None".to_string(), fields: vec![] },
         ],
     };
-    assert_eq!(enum_generic_params(&e), vec!["a".to_string()]);
+    assert_eq!(enum_generic_params(&e), vec!["T".to_string()]);
 }
 #[test]
@@ -62,11 +62,11 @@ fn specialize_class_substitutes_generic_field_types_and_clears_generics_list() {
     let c = ast::Class {
         name: "Box".to_string(),
         implements: vec![],
-        generics: vec![ast::GenericParam { name: "a".to_string(), bounds: vec![] }],
+        generics: vec![ast::GenericParam { name: "T".to_string(), bounds: vec![] }],
-        fields: vec![ast::Field { name: "value".to_string(), ty: ast::Type { name: "a".to_string(), generics: vec![] } }],
+        fields: vec![ast::Field { name: "value".to_string(), ty: ast::Type { name: "T".to_string(), generics: vec![] } }],
     };
     let mut bindings = std::collections::BTreeMap::new();
-    bindings.insert("a".to_string(), PlumType::TInt);
+    bindings.insert("T".to_string(), PlumType::TInt);
     let specialized = specialize_class(&c, &Substitution(bindings), "Box$Int");
     assert_eq!(specialized.name, "Box$Int");
     assert!(specialized.generics.is_empty());
@@ -78,12 +78,12 @@ fn specialize_fn_substitutes_generic_param_and_return_types() {
     let f = ast::Fn {
         name: "wrap".to_string(),
         type_param: None,
-        params: vec![ast::Param { name: "value".to_string(), ty: ast::ParamType::Type(ast::Type { name: "a".to_string(), generics: vec![] }), default: None }],
+        params: vec![ast::Param { name: "value".to_string(), ty: ast::ParamType::Type(ast::Type { name: "T".to_string(), generics: vec![] }), default: None }],
-        returns: Some(ast::ReturnType { name: "a".to_string(), generics: vec![] }),
+        returns: Some(ast::Type { name: "T".to_string(), generics: vec![] }),
         body: ast::FnBody::Expr(ast::Expr::Var("value".to_string())),
     };
     let mut bindings = std::collections::BTreeMap::new();
-    bindings.insert("a".to_string(), PlumType::TInt);
+    bindings.insert("T".to_string(), PlumType::TInt);
     let specialized = specialize_fn(&f, &Substitution(bindings), "wrap$Int", None);
     assert_eq!(specialized.name, "wrap$Int");
     match &specialized.params[0].ty {
@@ -99,11 +99,11 @@ fn specialize_fn_sets_new_receiver_for_a_method() {
         name: "getValue".to_string(),
         type_param: Some("Box".to_string()),
         params: vec![],
-        returns: Some(ast::ReturnType { name: "a".to_string(), generics: vec![] }),
+        returns: Some(ast::Type { name: "T".to_string(), generics: vec![] }),
         body: ast::FnBody::Expr(ast::Expr::Self_),
     };
     let mut bindings = std::collections::BTreeMap::new();
-    bindings.insert("a".to_string(), PlumType::TStr);
+    bindings.insert("T".to_string(), PlumType::TStr);
     let specialized = specialize_fn(&f, &Substitution(bindings), "getValue", Some("Box$Str".to_string()));
     assert_eq!(specialized.name, "getValue");
     assert_eq!(specialized.type_param, Some("Box$Str".to_string()));
@@ -115,12 +115,12 @@ fn specialize_enum_substitutes_generic_variant_field_names() {
     let e = ast::Enum {
         name: "Option".to_string(),
         variants: vec![
-            ast::EnumVariant { name: "Some".to_string(), fields: vec!["a".to_string()] },
+            ast::EnumVariant { name: "Some".to_string(), fields: vec!["T".to_string()] },
             ast::EnumVariant { name: "None".to_string(), fields: vec![] },
         ],
     };
     let mut bindings = std::collections::BTreeMap::new();
-    bindings.insert("a".to_string(), PlumType::TInt);
+    bindings.insert("T".to_string(), PlumType::TInt);
     let specialized = specialize_enum(&e, &Substitution(bindings), "Option$Int");
     assert_eq!(specialized.name, "Option$Int");
     assert_eq!(specialized.variants[0].fields, vec!["Int".to_string()]);