]> git.madduck.net Git - etc/vim.git/blob - tests/data/simple_cases/function_trailing_comma.py

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

Add latest_prerelease Docker Hub tag for following the latest alpha release (#3465)
[etc/vim.git] / tests / data / simple_cases / function_trailing_comma.py
1 def f(a,):
2     d = {'key': 'value',}
3     tup = (1,)
4
5 def f2(a,b,):
6     d = {'key': 'value', 'key2': 'value2',}
7     tup = (1,2,)
8
9 def f(a:int=1,):
10     call(arg={'explode': 'this',})
11     call2(arg=[1,2,3],)
12     x = {
13         "a": 1,
14         "b": 2,
15     }["a"]
16     if a == {"a": 1,"b": 2,"c": 3,"d": 4,"e": 5,"f": 6,"g": 7,"h": 8,}["a"]:
17         pass
18
19 def xxxxxxxxxxxxxxxxxxxxxxxxxxxx() -> Set[
20     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
21 ]:
22     json = {"k": {"k2": {"k3": [1,]}}}
23
24
25
26 # The type annotation shouldn't get a trailing comma since that would change its type.
27 # Relevant bug report: https://github.com/psf/black/issues/2381.
28 def some_function_with_a_really_long_name() -> (
29     returning_a_deeply_nested_import_of_a_type_i_suppose
30 ):
31     pass
32
33
34 def some_method_with_a_really_long_name(very_long_parameter_so_yeah: str, another_long_parameter: int) -> (
35     another_case_of_returning_a_deeply_nested_import_of_a_type_i_suppose_cause_why_not
36 ):
37     pass
38
39
40 def func() -> (
41     also_super_long_type_annotation_that_may_cause_an_AST_related_crash_in_black(this_shouldn_t_get_a_trailing_comma_too)
42 ):
43     pass
44
45
46 def func() -> ((also_super_long_type_annotation_that_may_cause_an_AST_related_crash_in_black(
47         this_shouldn_t_get_a_trailing_comma_too
48     ))
49 ):
50     pass
51
52
53 # Make sure inner one-element tuple won't explode
54 some_module.some_function(
55     argument1, (one_element_tuple,), argument4, argument5, argument6
56 )
57
58 # Inner trailing comma causes outer to explode
59 some_module.some_function(
60     argument1, (one, two,), argument4, argument5, argument6
61 )
62
63 # output
64
65 def f(
66     a,
67 ):
68     d = {
69         "key": "value",
70     }
71     tup = (1,)
72
73
74 def f2(
75     a,
76     b,
77 ):
78     d = {
79         "key": "value",
80         "key2": "value2",
81     }
82     tup = (
83         1,
84         2,
85     )
86
87
88 def f(
89     a: int = 1,
90 ):
91     call(
92         arg={
93             "explode": "this",
94         }
95     )
96     call2(
97         arg=[1, 2, 3],
98     )
99     x = {
100         "a": 1,
101         "b": 2,
102     }["a"]
103     if (
104         a
105         == {
106             "a": 1,
107             "b": 2,
108             "c": 3,
109             "d": 4,
110             "e": 5,
111             "f": 6,
112             "g": 7,
113             "h": 8,
114         }["a"]
115     ):
116         pass
117
118
119 def xxxxxxxxxxxxxxxxxxxxxxxxxxxx() -> Set[
120     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
121 ]:
122     json = {
123         "k": {
124             "k2": {
125                 "k3": [
126                     1,
127                 ]
128             }
129         }
130     }
131
132
133 # The type annotation shouldn't get a trailing comma since that would change its type.
134 # Relevant bug report: https://github.com/psf/black/issues/2381.
135 def some_function_with_a_really_long_name() -> (
136     returning_a_deeply_nested_import_of_a_type_i_suppose
137 ):
138     pass
139
140
141 def some_method_with_a_really_long_name(
142     very_long_parameter_so_yeah: str, another_long_parameter: int
143 ) -> (
144     another_case_of_returning_a_deeply_nested_import_of_a_type_i_suppose_cause_why_not
145 ):
146     pass
147
148
149 def func() -> (
150     also_super_long_type_annotation_that_may_cause_an_AST_related_crash_in_black(
151         this_shouldn_t_get_a_trailing_comma_too
152     )
153 ):
154     pass
155
156
157 def func() -> (
158     (
159         also_super_long_type_annotation_that_may_cause_an_AST_related_crash_in_black(
160             this_shouldn_t_get_a_trailing_comma_too
161         )
162     )
163 ):
164     pass
165
166
167 # Make sure inner one-element tuple won't explode
168 some_module.some_function(
169     argument1, (one_element_tuple,), argument4, argument5, argument6
170 )
171
172 # Inner trailing comma causes outer to explode
173 some_module.some_function(
174     argument1,
175     (
176         one,
177         two,
178     ),
179     argument4,
180     argument5,
181     argument6,
182 )