diff options
Diffstat (limited to 'system/xonsh/v310.patch')
| -rw-r--r-- | system/xonsh/v310.patch | 432 |
1 files changed, 432 insertions, 0 deletions
diff --git a/system/xonsh/v310.patch b/system/xonsh/v310.patch new file mode 100644 index 0000000000..836124714e --- /dev/null +++ b/system/xonsh/v310.patch @@ -0,0 +1,432 @@ +--- 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): + """ |