cl-ast: Cleanup

- Function bind is now one Pattern
- TyRef now allows &Ty (i.e. &[i32], &(char, bool)
- Range patterns (they cannot bind, only check whether a value is in range
- ArrayRep repeat has been reverted to usize, for now, until early consteval is implemented.

compiler/cl-ast/src/ast_impl/convert.rs

@@ -140,6 +140,14 @@ impl TryFrom<Expr> for Pattern {
                 };
                 Pattern::TupleStruct(path, args)
             }
+            ExprKind::Binary(Binary { kind: BinaryKind::RangeExc, parts }) => {
+                let (head, tail) = (Pattern::try_from(parts.0)?, Pattern::try_from(parts.1)?);
+                Pattern::RangeExc(head.into(), tail.into())
+            }
+            ExprKind::Binary(Binary { kind: BinaryKind::RangeInc, parts }) => {
+                let (head, tail) = (Pattern::try_from(parts.0)?, Pattern::try_from(parts.1)?);
+                Pattern::RangeInc(head.into(), tail.into())
+            }
             ExprKind::Unary(Unary { kind: UnaryKind::RangeExc, tail }) => {
                 Pattern::Rest(Some(Pattern::try_from(*tail)?.into()))
             }

compiler/cl-ast/src/ast_impl/display.rs

@@ -161,11 +161,19 @@ impl Display for Function {
                 Default::default()
             }
         };
+        let bind = match bind {
+            Pattern::Tuple(patterns) => patterns.as_slice(),
+            _ => {
+                write!(f, "Invalid argument binder: {bind}")?;
+                Default::default()
+            }
+        };
 
         debug_assert_eq!(bind.len(), types.len());
         write!(f, "fn {name} ")?;
         {
             let mut f = f.delimit(INLINE_PARENS);
+
             for (idx, (arg, ty)) in bind.iter().zip(types.iter()).enumerate() {
                 if idx != 0 {
                     f.write_str(", ")?;
@@ -453,6 +461,8 @@ impl Display for Pattern {
             Pattern::Rest(Some(name)) => write!(f, "..{name}"),
             Pattern::Rest(None) => "..".fmt(f),
             Pattern::Ref(mutability, pattern) => write!(f, "&{mutability}{pattern}"),
+            Pattern::RangeExc(head, tail) => write!(f, "{head}..{tail}"),
+            Pattern::RangeInc(head, tail) => write!(f, "{head}..={tail}"),
             Pattern::Tuple(patterns) => separate(patterns, ", ")(f.delimit(INLINE_PARENS)),
             Pattern::Array(patterns) => separate(patterns, ", ")(f.delimit(INLINE_SQUARE)),
             Pattern::Struct(path, items) => {

compiler/cl-ast/src/ast_impl/weight_of.rs

@@ -342,6 +342,8 @@ impl WeightOf for Pattern {
             Pattern::Rest(Some(pattern)) => pattern.weight_of(),
             Pattern::Rest(None) => 0,
             Pattern::Ref(mutability, pattern) => mutability.weight_of() + pattern.weight_of(),
+            Pattern::RangeExc(head, tail) => head.weight_of() + tail.weight_of(),
+            Pattern::RangeInc(head, tail) => head.weight_of() + tail.weight_of(),
             Pattern::Tuple(patterns) | Pattern::Array(patterns) => patterns.weight_of(),
             Pattern::Struct(path, items) => {
                 let sitems: usize = items