change Identifier to Pattern in MatchPattern

Author: gerau

src/ast.rs

@@ -1400,16 +1400,22 @@ impl AbstractSyntaxTree for Match {
             Expression::analyze(from.scrutinee(), &scrutinee_ty, scope).map(Arc::new)?;
 
         scope.push_scope();
-        if let Some((id_l, ty_l)) = from.left().pattern().as_typed_variable() {
+        if let Some((pat_l, ty_l)) = from.left().pattern().as_typed_pattern() {
             let ty_l = scope.resolve(ty_l).with_span(from)?;
-            scope.insert_variable(id_l.clone(), ty_l);
+            let typed_variables = pat_l.is_of_type(&ty_l).with_span(from)?;
+            for (identifier, ty) in typed_variables {
+                scope.insert_variable(identifier, ty);
+            }
         }
         let ast_l = Expression::analyze(from.left().expression(), ty, scope).map(Arc::new)?;
         scope.pop_scope();
         scope.push_scope();
-        if let Some((id_r, ty_r)) = from.right().pattern().as_typed_variable() {
+        if let Some((pat_r, ty_r)) = from.right().pattern().as_typed_pattern() {
             let ty_r = scope.resolve(ty_r).with_span(from)?;
-            scope.insert_variable(id_r.clone(), ty_r);
+            let typed_variables = pat_r.is_of_type(&ty_r).with_span(from)?;
+            for (identifier, ty) in typed_variables {
+                scope.insert_variable(identifier, ty);
+            }
         }
         let ast_r = Expression::analyze(from.right().expression(), ty, scope).map(Arc::new)?;
         scope.pop_scope();

src/compile/mod.rs

@@ -656,9 +656,9 @@ impl Match {
         scope.insert(
             self.left()
                 .pattern()
-                .as_variable()
+                .as_pattern()
                 .cloned()
-                .map_or(Pattern::Ignore, Pattern::Identifier),
+                .unwrap_or(Pattern::Ignore),
         );
         let left = self.left().expression().compile(scope)?;
         scope.pop_scope();
@@ -667,9 +667,9 @@ impl Match {
         scope.insert(
             self.right()
                 .pattern()
-                .as_variable()
+                .as_pattern()
                 .cloned()
-                .map_or(Pattern::Ignore, Pattern::Identifier),
+                .unwrap_or(Pattern::Ignore),
         );
         let right = self.right().expression().compile(scope)?;
         scope.pop_scope();

src/parse.rs

@@ -429,23 +429,23 @@ impl MatchArm {
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum MatchPattern {
-    /// Bind inner value of left value to variable name.
-    Left(Identifier, AliasedType),
-    /// Bind inner value of right value to variable name.
-    Right(Identifier, AliasedType),
+    /// Bind inner value of left value to a pattern.
+    Left(Pattern, AliasedType),
+    /// Bind inner value of right value to a pattern.
+    Right(Pattern, AliasedType),
     /// Match none value (no binding).
     None,
-    /// Bind inner value of some value to variable name.
-    Some(Identifier, AliasedType),
+    /// Bind inner value of some value to a pattern.
+    Some(Pattern, AliasedType),
     /// Match false value (no binding).
     False,
     /// Match true value (no binding).
     True,
 }
 
 impl MatchPattern {
-    /// Access the identifier of a pattern that binds a variable.
-    pub fn as_variable(&self) -> Option<&Identifier> {
+    /// Access the pattern of a match pattern that binds a variables.
+    pub fn as_pattern(&self) -> Option<&Pattern> {
         match self {
             MatchPattern::Left(i, _) | MatchPattern::Right(i, _) | MatchPattern::Some(i, _) => {
                 Some(i)
@@ -454,8 +454,8 @@ impl MatchPattern {
         }
     }
 
-    /// Access the identifier and the type of a pattern that binds a variable.
-    pub fn as_typed_variable(&self) -> Option<(&Identifier, &AliasedType)> {
+    /// Access the pattern and the type of a match pattern that binds a variables.
+    pub fn as_typed_pattern(&self) -> Option<(&Pattern, &AliasedType)> {
         match self {
             MatchPattern::Left(i, ty) | MatchPattern::Right(i, ty) | MatchPattern::Some(i, ty) => {
                 Some((i, ty))
@@ -1623,17 +1623,17 @@ impl ChumskyParse for MatchPattern {
     where
         I: ValueInput<'tokens, Token = Token<'src>, Span = Span>,
     {
-        let wrapper = |name: &'static str, ctor: fn(Identifier, AliasedType) -> Self| {
+        let wrapper = |name: &'static str, ctor: fn(Pattern, AliasedType) -> Self| {
             select! { Token::Ident(i) if i == name => i }
                 .ignore_then(delimited_with_recovery(
-                    Identifier::parser()
+                    Pattern::parser()
                         .then_ignore(just(Token::Colon))
                         .then(AliasedType::parser()),
                     Token::LParen,
                     Token::RParen,
                     |_| {
                         (
-                            Identifier::from_str_unchecked(""),
+                            Pattern::Ignore,
                             AliasedType::alias(AliasName::from_str_unchecked("error")),
                         )
                     },
@@ -2130,16 +2130,16 @@ impl crate::ArbitraryRec for Match {
         let scrutinee = Expression::arbitrary_rec(u, budget).map(Arc::new)?;
         let (pat_l, pat_r) = match u.int_in_range(0..=2)? {
             0 => {
-                let id_l = Identifier::arbitrary(u)?;
+                let id_l = Pattern::arbitrary(u)?;
                 let ty_l = AliasedType::arbitrary(u)?;
                 let pat_l = MatchPattern::Left(id_l, ty_l);
-                let id_r = Identifier::arbitrary(u)?;
+                let id_r = Pattern::arbitrary(u)?;
                 let ty_r = AliasedType::arbitrary(u)?;
                 let pat_r = MatchPattern::Right(id_r, ty_r);
                 (pat_l, pat_r)
             }
             1 => {
-                let id_r = Identifier::arbitrary(u)?;
+                let id_r = Pattern::arbitrary(u)?;
                 let ty_r = AliasedType::arbitrary(u)?;
                 let pat_r = MatchPattern::Some(id_r, ty_r);
                 (MatchPattern::None, pat_r)