--- xonsh-0.14.4/xonsh/parsers/v310.orig.py	2024-01-18 17:58:44.463700213 +0200
+++ xonsh-0.14.4/xonsh/parsers/v310.py	2024-01-18 19:03:33.985074856 +0200
@@ -76,26 +76,24 @@
         """
 
         loc = self.get_line_cols(p, 1)
-        match list(p):
-            case [_, _, pattern, _, suite]:
-                p[0] = ast.match_case(pattern=pattern, body=suite, **loc)
-            case [_, _, pattern, _, guard, _, suite]:
-                p[0] = ast.match_case(pattern=pattern, body=suite, guard=guard, **loc)
-            case _:
-                raise AssertionError()
+        if list(p) == [_, _, pattern, _, suite]:
+            p[0] = ast.match_case(pattern=pattern, body=suite, **loc)
+        elif list(p) == [_, _, pattern, _, guard, _, suite]:
+            p[0] = ast.match_case(pattern=pattern, body=suite, guard=guard, **loc)
+        else:
+            raise AssertionError()
 
     def p_case_block_list_nonempty(self, p):
         """
         case_block_list_nonempty : case_block
                                  | case_block case_block_list_nonempty
         """
-        match list(p):
-            case [_, case_block]:
-                p[0] = [case_block]
-            case [_, case_block, case_block_list_nonempty]:
-                p[0] = [case_block] + case_block_list_nonempty
-            case _:
-                raise AssertionError()
+        if list(p) == [_, case_block]:
+            p[0] = [case_block]
+        elif list(p) == [_, case_block, case_block_list_nonempty]:
+            p[0] = [case_block] + case_block_list_nonempty
+        else:
+            raise AssertionError()
 
     # subject expression
     def p_subject_expr_single_value(self, p):
@@ -103,33 +101,31 @@
         subject_expr : test_or_star_expr comma_opt
         """
 
-        match list(p):
-            case [_, test_or_star_expr, None]:
-                # single value
-                p[0] = test_or_star_expr
-            case [_, test_or_star_expr, ","]:
-                # tuple with one element
-                p[0] = ast.Tuple(
-                    elts=[test_or_star_expr], ctx=ast.Load(), **self.get_line_cols(p, 1)
-                )
-            case _:
-                raise AssertionError()
+        if list(p) == [_, test_or_star_expr, None]:
+            # single value
+            p[0] = test_or_star_expr
+        elif list(p) == [_, test_or_star_expr, ","]:
+            # tuple with one element
+            p[0] = ast.Tuple(
+                elts=[test_or_star_expr], ctx=ast.Load(), **self.get_line_cols(p, 1)
+            )
+        else:
+            raise AssertionError()
 
     def p_subject_expr_multiple_values(self, p):
         """
         subject_expr : test_or_star_expr comma_test_or_star_expr_list comma_opt
         """
 
-        match list(p):
-            case [_, test_or_star_expr, comma_test_or_star_expr_list, "," | None]:
-                # tuple with more than one element
-                p[0] = ast.Tuple(
-                    elts=[test_or_star_expr] + comma_test_or_star_expr_list,
-                    ctx=ast.Load(),
-                    **self.get_line_cols(p, 1),
-                )
-            case _:
-                raise AssertionError()
+        if list(p) == [_, test_or_star_expr, comma_test_or_star_expr_list, "," | None]:
+            # tuple with more than one element
+            p[0] = ast.Tuple(
+                elts=[test_or_star_expr] + comma_test_or_star_expr_list,
+                ctx=ast.Load(),
+                **self.get_line_cols(p, 1),
+            )
+        else:
+            raise AssertionError()
 
     # patterns
     def p_closed_pattern(self, p):
@@ -167,22 +163,20 @@
 
         _, or_pattern_list = p
 
-        match or_pattern_list:
-            case [single_value]:
-                p[0] = single_value
-            case multiple_values:
-                p[0] = ast.MatchOr(patterns=multiple_values, **self.get_line_cols(p, 1))
+        if or_pattern_list == [single_value]:
+            p[0] = single_value
+        elif or_pattern_list == multiple_values:
+            p[0] = ast.MatchOr(patterns=multiple_values, **self.get_line_cols(p, 1))
 
     def p_or_pattern_list(self, p):
         """
         or_pattern_list : closed_pattern
                         | closed_pattern PIPE or_pattern_list
         """
-        match list(p):
-            case [_, closed_pattern]:
-                p[0] = [closed_pattern]
-            case [_, closed_pattern, "|", or_pattern_list]:
-                p[0] = [closed_pattern] + or_pattern_list
+        if list(p) == [_, closed_pattern]:
+            p[0] = [closed_pattern]
+        elif list(p) == [_, closed_pattern, "|", or_pattern_list]:
+            p[0] = [closed_pattern] + or_pattern_list
 
     # group pattern
     def p_group_pattern(self, p):
@@ -198,11 +192,10 @@
         literal_pattern : literal_expr
         """
 
-        match p[1]:
-            case None | True | False:
-                p[0] = ast.MatchSingleton(value=p[1], **self.get_line_cols(p, 1))
-            case _:
-                p[0] = ast.MatchValue(value=p[1], **self.get_line_cols(p, 1))
+        if p[1] == None | True | False:
+            p[0] = ast.MatchSingleton(value=p[1], **self.get_line_cols(p, 1))
+        else:
+            p[0] = ast.MatchValue(value=p[1], **self.get_line_cols(p, 1))
 
     def p_literal_expr_number_or_string_literal_list(self, p):
         """
@@ -212,11 +205,10 @@
 
         p[0] = p[1]
 
-        match p[1]:
-            case ast.JoinedStr():
-                raise AssertionError("patterns may not match formatted string literals")
-                # TODO: raise SyntaxError instead
-                # (doing so currently somehow causes an IndexError in tools.py:get_logical_line)
+        if p[1] == ast.JoinedStr():
+            raise AssertionError("patterns may not match formatted string literals")
+            # TODO: raise SyntaxError instead
+            # (doing so currently somehow causes an IndexError in tools.py:get_logical_line)
 
         # TODO: f"hi" "hi" does not parse in xonsh
 
@@ -227,15 +219,14 @@
                      | false_tok
         """
 
-        match p[1].value:
-            case "None":
-                value = None
-            case "True":
-                value = True
-            case "False":
-                value = False
-            case _:
-                raise AssertionError()
+        if p[1].value == "None":
+            value = None
+        elif "True":
+            value = True
+        elif "False":
+            value = False
+        else:
+            raise AssertionError()
 
         p[0] = value
 
@@ -253,19 +244,18 @@
         build_complex = False
         loc = self.get_line_cols(p, 1)
 
-        match list(p):
-            case [_, x]:
-                p[0] = x
-            case [_, "-", x]:
-                p[0] = ast.UnaryOp(op=ast.USub(), operand=x, **loc)
-            case [_, left, ("+" | "-") as op_char, right]:
-                build_complex = True
-                negate_left_side = False
-            case [_, "-", left, ("+" | "-") as op_char, right]:
-                build_complex = True
-                negate_left_side = True
-            case _:
-                raise AssertionError()
+        if list(p) == [_, x]:
+            p[0] = x
+        elif list(p) == [_, "-", x]:
+            p[0] = ast.UnaryOp(op=ast.USub(), operand=x, **loc)
+        elif list(p) == [_, left, ("+",  op_char) | ("-", op_char), right]:
+            build_complex = True
+            negate_left_side = False
+        elif list(p) == [_, "-", left, ("+",  op_char) | ("-", op_char), right]:
+            build_complex = True
+            negate_left_side = True
+        else:
+            raise AssertionError()
 
         if build_complex:
             # TODO raise syntax error instead (see reason in p_literal_expr_number_or_string_literal_list)
@@ -322,17 +312,16 @@
                          | LPAREN RPAREN
         """
 
-        match list(p):
-            case [_, _, ast.MatchSequence() as seq, _]:
-                p[0] = seq
-            case [_, _, single_item, _]:
-                p[0] = ast.MatchSequence(
-                    patterns=[single_item], **self.get_line_cols(p, 1)
-                )
-            case [_, _, _]:
-                p[0] = ast.MatchSequence(patterns=[], **self.get_line_cols(p, 1))
-            case _:
-                raise AssertionError()
+        if list(p) == [_, _, (ast.MatchSequence(), seq), _]:
+            p[0] = seq
+        elif list(p) == [_, _, single_item, _]:
+            p[0] = ast.MatchSequence(
+                patterns=[single_item], **self.get_line_cols(p, 1)
+            )
+        elif list(p) == [_, _, _]:
+            p[0] = ast.MatchSequence(patterns=[], **self.get_line_cols(p, 1))
+        else:
+            raise AssertionError()
 
     def p_maybe_sequence_pattern(self, p):
         """
@@ -340,30 +329,24 @@
                                | maybe_star_pattern COMMA maybe_sequence_pattern
         """
 
-        match list(p):
-            case [_, maybe_star_pattern, ","]:
-                p[0] = ast.MatchSequence(
-                    patterns=[maybe_star_pattern], **self.get_line_cols(p, 1)
-                )
-            case [_, maybe_star_pattern, None]:
-                p[0] = maybe_star_pattern
-            case [
-                _,
-                maybe_star_pattern,
-                ",",
-                ast.MatchSequence(patterns=list(maybe_sequence_pattern)),
-            ]:
-                p[0] = ast.MatchSequence(
-                    patterns=[maybe_star_pattern] + maybe_sequence_pattern,
-                    **self.get_line_cols(p, 1),
-                )
-            case [_, maybe_star_pattern, ",", maybe_sequence_pattern]:
-                p[0] = ast.MatchSequence(
-                    patterns=[maybe_star_pattern, maybe_sequence_pattern],
-                    **self.get_line_cols(p, 1),
-                )
-            case _:
-                raise AssertionError()
+        if list(p) == [_, maybe_star_pattern, ","]:
+            p[0] = ast.MatchSequence(
+                patterns=[maybe_star_pattern], **self.get_line_cols(p, 1)
+            )
+        elif list(p) == [_, maybe_star_pattern, None]:
+            p[0] = maybe_star_pattern
+        elif list(p) == [_, maybe_star_pattern, ",", ast.MatchSequence(patterns=list(maybe_sequence_pattern)),]:
+            p[0] = ast.MatchSequence(
+                patterns=[maybe_star_pattern] + maybe_sequence_pattern,
+                **self.get_line_cols(p, 1),
+            )
+        elif list(p) == [_, maybe_star_pattern, ",", maybe_sequence_pattern]:
+            p[0] = ast.MatchSequence(
+                patterns=[maybe_star_pattern, maybe_sequence_pattern],
+                **self.get_line_cols(p, 1),
+            )
+        else:
+            raise AssertionError()
 
     def p_open_sequence_pattern(self, p):
         """
@@ -429,19 +412,18 @@
                                             | name_str EQUALS pattern COMMA class_pattern_keyword_part
         """
 
-        match list(p):
-            case [_]:
-                p[0] = ([], [])
-            case [_, pattern]:
-                p[0] = ([pattern], [])
-            case [_, pattern, ",", (names, patterns)]:
-                p[0] = ([pattern] + names, patterns)
-            case [_, name, "=", pattern]:
-                p[0] = ([], [(name, pattern)])
-            case [_, name, "=", pattern, ",", class_pattern_keyword_part]:
-                p[0] = ([], [(name, pattern)] + class_pattern_keyword_part)
-            case _:
-                raise AssertionError()
+        if list(p) == [_]:
+            p[0] = ([], [])
+        elif list(p) == [_, pattern]:
+            p[0] = ([pattern], [])
+        elif list(p) == [_, pattern, ",", (names, patterns)]:
+            p[0] = ([pattern] + names, patterns)
+        elif list(p) == [_, name, "=", pattern]:
+            p[0] = ([], [(name, pattern)])
+        elif list(p) == [_, name, "=", pattern, ",", class_pattern_keyword_part]:
+            p[0] = ([], [(name, pattern)] + class_pattern_keyword_part)
+        else:
+            raise AssertionError()
 
     # returns ( [pattern], [ (name, pattern) ]  )
     def p_class_pattern_positional_part_skip(self, p):
@@ -457,13 +439,12 @@
                                       | pattern COMMA class_pattern_positional_part
         """
 
-        match list(p):
-            case [_, pattern]:
-                p[0] = ([pattern], [])
-            case [_, pattern, ",", (names, patterns)]:
-                p[0] = ([pattern] + names, patterns)
-            case _:
-                raise AssertionError()
+        if list(p) == [_, pattern]:
+            p[0] = ([pattern], [])
+        elif list(p) == [_, pattern, ",", (names, patterns)]:
+            p[0] = ([pattern] + names, patterns)
+        else:
+            raise AssertionError()
 
     # returns [ (name, pattern) ]
     def p_class_pattern_keyword_part(self, p):
@@ -474,15 +455,14 @@
                                    | name_str EQUALS pattern COMMA class_pattern_keyword_part
         """
 
-        match list(p):
-            case [_] | [_, ","]:
-                p[0] = []
-            case [_, name, "=", pattern]:
-                p[0] = [(name, pattern)]
-            case [_, name, "=", pattern, ",", class_pattern_keyword_part]:
-                p[0] = [(name, pattern)] + class_pattern_keyword_part
-            case _:
-                raise AssertionError()
+        if list(p) == [_] | [_, ","]:
+            p[0] = []
+        elif list(p) == [_, name, "=", pattern]:
+            p[0] = [(name, pattern)]
+        elif list(p) == [_, name, "=", pattern, ",", class_pattern_keyword_part]:
+            p[0] = [(name, pattern)] + class_pattern_keyword_part
+        else:
+            raise AssertionError()
 
     # Mapping pattern
 
@@ -505,43 +485,40 @@
                                    | key_value_pattern COMMA mapping_pattern_args_item_part
                                    | double_star_pattern
         """
-        match list(p):
-            case [_]:
-                p[0] = [], [], None
-            case [_, (key, value)]:
-                p[0] = [key], [value], None
-            case [_, (key, value), ",", (keys, values, rest)]:
-                p[0] = [key] + keys, [value] + values, rest
-            case [_, str(double_star_pattern)]:
-                p[0] = [], [], double_star_pattern
-            case _:
-                raise AssertionError()
+        if list(p) == [_]:
+            p[0] = [], [], None
+        elif list(p) == [_, (key, value)]:
+            p[0] = [key], [value], None
+        elif list(p) == [_, (key, value), ",", (keys, values, rest)]:
+            p[0] = [key] + keys, [value] + values, rest
+        elif list(p) == [_, str(double_star_pattern)]:
+            p[0] = [], [], double_star_pattern
+        else:
+            raise AssertionError()
 
     def p_mapping_pattern_args_item_part_skip(self, p):
         """
         mapping_pattern_args_item_part :
                                        | double_star_pattern
         """
-        match list(p):
-            case [_]:
-                p[0] = [], [], None
-            case [_, rest]:
-                p[0] = [], [], rest
-            case _:
-                raise AssertionError()
+        if list(p) == [_]:
+            p[0] = [], [], None
+        elif list(p) == [_, rest]:
+            p[0] = [], [], rest
+        else:
+            raise AssertionError()
 
     def p_mapping_pattern_args_item_part(self, p):
         """
         mapping_pattern_args_item_part : key_value_pattern
                                        | key_value_pattern COMMA mapping_pattern_args_item_part
         """
-        match list(p):
-            case [_, (key, value)]:
-                p[0] = [key], [value], None
-            case [_, (key, value), ",", (keys, values, rest)]:
-                p[0] = [key] + keys, [value] + values, rest
-            case _:
-                raise AssertionError()
+        if list(p) == [_, (key, value)]:
+            p[0] = [key], [value], None
+        elif list(p) == [_, (key, value), ",", (keys, values, rest)]:
+            p[0] = [key] + keys, [value] + values, rest
+        else:
+            raise AssertionError()
 
     def p_double_star_pattern(self, p):
         """