275 commits

Author	SHA1	Message	Date
konsti	787e2fd49d	Format import statements (#5493) ... ## Summary Format import statements in all their variants. Specifically, this implemented formatting `StmtImport`, `StmtImportFrom` and `Alias`. ## Test Plan I added some custom snapshots, even though this has been covered well by black's tests.	2023-07-04 07:07:20 +00:00
konsti	a647f31600	Don't add a magic trailing comma for a single entry (#5463) ... ## Summary If a comma separated list has only one entry, black will respect the magic trailing comma, but it will not add a new one. The following code will remain as is: ```python b1 = [ aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa ] b2 = [ aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa, ] b3 = [ aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa, aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa ] ``` ## Test Plan This was first discovered in 7eeadc82c2/django/contrib/admin/checks.py (L674-L681), which i've minimized into a call test. I've added tests for the three cases (one entry + no comma, one entry + comma, more than one entry) to the list tests. The diffs from the black tests get smaller.	2023-07-03 21:48:44 +02:00
Louis Dispa	dc072537e5	Fix python_formatter generate.py with rust path (#5475) ... ## Summary This PR fix an issue with the `generate.py` file of the python formatter. Since https://github.com/astral-sh/ruff/pull/5369 the [node.rs file](f51dc20497/crates/ruff_python_ast/src/node.rs) used to generate the types now has `ast::` in the enum. ```rust pub enum AnyNode { ModModule(ModModule), ModInteractive(ModInteractive), ModExpression(ModExpression), ModFunctionType(ModFunctionType), ... ``` And now: ```rust pub enum AnyNode { ModModule(ast::ModModule), ModInteractive(ast::ModInteractive), ModExpression(ast::ModExpression), ModFunctionType(ast::ModFunctionType), ... ``` The python script was not parsing rust paths. This PR adds the possibility to have it. ## Test Plan This was tested locally. ### Script output Before ``` ['ast::ModModule),', 'ast::ModInteractive),', 'ast::ModExpression),', 'ast::ModFunctionType),', 'ast::StmtFunctionDef),', 'ast::StmtAsyncFunctionDef),', 'ast::StmtClassDef),', 'ast::StmtReturn),', 'ast::StmtDelete),', 'ast::StmtAssign),', 'ast::StmtAugAssign),', 'ast::StmtAnnAssign),', 'ast::StmtFor),', 'ast::StmtAsyncFor),', 'ast::StmtWhile),', 'ast::StmtIf),', 'ast::StmtWith),', 'ast::StmtAsyncWith),', 'ast::StmtMatch),', 'ast::StmtRaise),', 'ast::StmtTry),', 'ast::StmtTryStar),', 'ast::StmtAssert),', 'ast::StmtImport),', 'ast::StmtImportFrom),', 'ast::StmtGlobal),', 'ast::StmtNonlocal),', 'ast::StmtExpr),', 'ast::StmtPass),', 'ast::StmtBreak),', 'ast::StmtContinue),', 'ast::ExprBoolOp),', 'ast::ExprNamedExpr),', 'ast::ExprBinOp),', 'ast::ExprUnaryOp),', 'ast::ExprLambda),', 'ast::ExprIfExp),', 'ast::ExprDict),', 'ast::ExprSet),', 'ast::ExprListComp),', 'ast::ExprSetComp),', 'ast::ExprDictComp),', 'ast::ExprGeneratorExp),', 'ast::ExprAwait),', 'ast::ExprYield),', 'ast::ExprYieldFrom),', 'ast::ExprCompare),', 'ast::ExprCall),', 'ast::ExprFormattedValue),', 'ast::ExprJoinedStr),', 'ast::ExprConstant),', 'ast::ExprAttribute),', 'ast::ExprSubscript),', 'ast::ExprStarred),', 'ast::ExprName),', 'ast::ExprList),', 'ast::ExprTuple),', 'ast::ExprSlice),', 'ast::ExceptHandlerExceptHandler),', 'ast::PatternMatchValue),', 'ast::PatternMatchSingleton),', 'ast::PatternMatchSequence),', 'ast::PatternMatchMapping),', 'ast::PatternMatchClass),', 'ast::PatternMatchStar),', 'ast::PatternMatchAs),', 'ast::PatternMatchOr),', 'ast::TypeIgnoreTypeIgnore),', 'Comprehension),', 'Arguments),', 'Arg),', 'ArgWithDefault),', 'Keyword),', 'Alias),', 'WithItem),', 'MatchCase),', 'Decorator),'] error: unexpected closing delimiter: `)` --> <stdin>:3:55 | 2 | use ruff_formatter::{write, Buffer, FormatResult}; | - this opening brace... - ...matches this closing brace 3 | use rustpython_parser::ast::ast::ModModule),; | ^ unexpected closing delimiter Traceback (most recent call last): File "/Users/ldispa/Documents/perso/ruff/crates/ruff_python_formatter/generate.py", line 100, in <module> node_path.write_text(rustfmt(code)) ^^^^^^^^^^^^^ File "/Users/ldispa/Documents/perso/ruff/crates/ruff_python_formatter/generate.py", line 12, in rustfmt return check_output(["rustfmt", "--emit=stdout"], input=code, text=True) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/opt/homebrew/Cellar/python@3.11/3.11.4_1/Frameworks/Python.framework/Versions/3.11/lib/python3.11/subprocess.py", line 466, in check_output return run(*popenargs, stdout=PIPE, timeout=timeout, check=True, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/opt/homebrew/Cellar/python@3.11/3.11.4_1/Frameworks/Python.framework/Versions/3.11/lib/python3.11/subprocess.py", line 571, in run raise CalledProcessError(retcode, process.args, subprocess.CalledProcessError: Command '['rustfmt', '--emit=stdout']' returned non-zero exit status 1. ``` After: ``` ['ModModule', 'ModInteractive', 'ModExpression', 'ModFunctionType', 'StmtFunctionDef', 'StmtAsyncFunctionDef', 'StmtClassDef', 'StmtReturn', 'StmtDelete', 'StmtAssign', 'StmtAugAssign', 'StmtAnnAssign', 'StmtFor', 'StmtAsyncFor', 'StmtWhile', 'StmtIf', 'StmtWith', 'StmtAsyncWith', 'StmtMatch', 'StmtRaise', 'StmtTry', 'StmtTryStar', 'StmtAssert', 'StmtImport', 'StmtImportFrom', 'StmtGlobal', 'StmtNonlocal', 'StmtExpr', 'StmtPass', 'StmtBreak', 'StmtContinue', 'ExprBoolOp', 'ExprNamedExpr', 'ExprBinOp', 'ExprUnaryOp', 'ExprLambda', 'ExprIfExp', 'ExprDict', 'ExprSet', 'ExprListComp', 'ExprSetComp', 'ExprDictComp', 'ExprGeneratorExp', 'ExprAwait', 'ExprYield', 'ExprYieldFrom', 'ExprCompare', 'ExprCall', 'ExprFormattedValue', 'ExprJoinedStr', 'ExprConstant', 'ExprAttribute', 'ExprSubscript', 'ExprStarred', 'ExprName', 'ExprList', 'ExprTuple', 'ExprSlice', 'ExceptHandlerExceptHandler', 'PatternMatchValue', 'PatternMatchSingleton', 'PatternMatchSequence', 'PatternMatchMapping', 'PatternMatchClass', 'PatternMatchStar', 'PatternMatchAs', 'PatternMatchOr', 'TypeIgnoreTypeIgnore', 'Comprehension', 'Arguments', 'Arg', 'ArgWithDefault', 'Keyword', 'Alias', 'WithItem', 'MatchCase', 'Decorator'] ```	2023-07-03 16:07:57 +02:00
konsti	7ac9e0252e	Document Checking formatter stability and panics (#5415) ... This adds the documentation, but ideally we should add the CI first	2023-07-03 11:22:19 +02:00
konsti	ca6ff72404	Change generator formatting dummy to include NOT_YET_IMPLEMENTED (#5464) ... ## Summary Change generator formatting dummy to include `NOT_YET_IMPLEMENTED`. This makes it easier to correctly identify them as dummies ## Test Plan This is a dummy change	2023-07-03 09:11:14 +02:00
Anders Kaseorg	df13e69c3c	Format let-else with rustfmt nightly (#5461) ... Support for `let…else` formatting was just merged to nightly (rust-lang/rust#113225). Rerun `cargo fmt` with Rust nightly 2023-07-02 to pick this up. Followup to #939. Signed-off-by: Anders Kaseorg <andersk@mit.edu>	2023-07-03 02:13:35 +00:00
Micha Reiser	f9129e435a	Normalize '\r' in string literals to '\n' ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR normalizes line endings inside of strings to `\n` as required by the printer. <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan I added a new test using `\r\n` and ran the ecosystem check. There are no remaining end of line panics. https://gist.github.com/MichaReiser/8f36b1391ca7b48475b3a4f592d74ff4 <!-- How was it tested? -->	2023-06-30 10:13:23 +02:00
Micha Reiser	9c2a75284b	Preserve parentheses around left side of binary expression ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR fixes an issue where the binary expression formatting removed parentheses around the left hand side of an expression. <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan I added a new regression test and re-ran the ecosystem check. It brings down the `check-formatter-stability` output from a 3.4MB file down to 900KB. <!-- How was it tested? -->	2023-06-30 09:52:14 +02:00
Micha Reiser	ae25638b0b	Update Black tests (#5438)	2023-06-30 06:32:50 +00:00
Micha Reiser	955e9ef821	Fix invalid syntax for binary expression in unary op (#5370)	2023-06-29 08:09:26 +02:00
Micha Reiser	38189ed913	Fix invalid printer IR error (#5422)	2023-06-29 08:09:13 +02:00
David Szotten	ca5e10b5ea	format StmtTryStar (#5418)	2023-06-29 08:07:33 +02:00
David Szotten	c7adb9117f	format StmtAsyncWith (#5376) ... Co-authored-by: Micha Reiser <micha@reiser.io>	2023-06-28 10:21:44 +00:00
David Szotten	1979103ec0	Format StmtTry (#5222) ... Co-authored-by: Micha Reiser <micha@reiser.io>	2023-06-28 10:02:15 +00:00
konstin	7f6cb9dfb5	Format call expressions (without call chaining) (#5341) ... ## Summary This formats call expressions with magic trailing comma and parentheses behaviour but without call chaining ## Test Plan Lots of new test fixtures, including some that don't work yet	2023-06-27 09:29:40 +00:00
David Szotten	50a7769d69	magic trailing comma for ExprList (#5365)	2023-06-26 21:59:01 +02:00
Charlie Marsh	fa1b85b3da	Remove prelude from ruff_python_ast (#5369) ... ## Summary Per @MichaReiser, this is causing more confusion than it is helpful.	2023-06-26 11:43:49 -04:00
David Szotten	d00559e42a	format StmtWith (#5350)	2023-06-26 15:09:06 +01:00
Micha Reiser	49cabca3e7	Format implicit string continuation (#5328)	2023-06-26 12:41:47 +00:00
Micha Reiser	313711aaf9	Prefer the configured quote style ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR extends the string formatting to respect the configured quote style. <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan Extended the string test with new cases and set it up to run twice: Once with the `quote_style: Doube`, and once with `quote_style: Single` single and double quotes. <!-- How was it tested? -->	2023-06-26 14:24:25 +02:00
Micha Reiser	f18a1f70de	Add tests for skip magic trailing comma ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR adds tests that verify that the magic trailing comma is not respected if disabled in the formatter options. Our test setup now allows to create a `<fixture-name>.options.json` file that contains an array of configurations that should be tested. <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan It's all about tests :) <!-- How was it tested? -->	2023-06-26 14:15:55 +02:00
Micha Reiser	dd0d1afb66	Create PyFormatOptions ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR adds a new `PyFormatOptions` struct that stores the python formatter options. The new options aren't used yet, with the exception of magical trailing commas and the options passed to the printer. I'll follow up with more PRs that use the new options (e.g. `QuoteStyle`). <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan `cargo test` I'll follow up with a new PR that adds support for overriding the options in our fixture tests.	2023-06-26 14:02:17 +02:00
konstin	a52cd47c7f	Fix attribute chain own line comments (#5340) ... ## Motation Previously, ```python x = ( a1 .a2 # a . # b # c a3 ) ``` got formatted as ```python x = a1.a2 # a . # b # c a3 ``` which is invalid syntax. This fixes that. ## Summary This implements a basic form of attribute chaining (<https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#call-chains>) by checking if any inner attribute access contains an own line comment, and if this is the case, adds parentheses around the outermost attribute access while disabling parentheses for all inner attribute expressions. We want to replace this with an implementation that uses recursion or a stack while formatting instead of in `needs_parentheses` and also includes calls rather sooner than later, but i'm fixing this now because i'm uncomfortable with having known invalid syntax generation in the formatter. ## Test Plan I added new fixtures.	2023-06-26 09:13:07 +00:00
Micha Reiser	8879927b9a	Use insta::glob instead of fixture macro (#5364)	2023-06-26 08:46:18 +00:00
Micha Reiser	d3d69a031e	Add JoinCommaSeparatedBuilder (#5342)	2023-06-23 22:03:05 +01:00
konstin	4b65446de6	Refactor magic trailing comma (#5339) ... ## Summary This is small refactoring to reuse the code that detects the magic trailing comma across functions. I make this change now to avoid copying code in a later PR. @MichaReiser is planning on making a larger refactoring later that integrates with the join nodes builder ## Test Plan No functional changes. The magic trailing comma behaviour is checked by the fixtures.	2023-06-23 18:53:55 +02:00
Micha Reiser	2dfa6ff58d	Fix unstable set comprehension formatting (#5327)	2023-06-23 11:50:24 +02:00
konstin	930f03de98	Don't mistake a following if for an elif (#5296) ... In the following code, the comment used to get wrongly associated with the `if False` since it looked like an elif. This fixes it by checking the indentation and adding a regression test ```python if True: pass else: # Comment if False: pass pass ``` Originally found in 1570b94a02/gradio/external.py (L478)	2023-06-23 10:07:28 +02:00
Micha Reiser	c52aa8f065	Basic string formatting ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR implements formatting for non-f-string Strings that do not use implicit concatenation. Docstring formatting is out of the scope of this PR. <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan I added a few tests for simple string literals. ## Performance Ouch. This is hitting performance somewhat hard. This is probably because we now iterate each string a couple of times: 1. To detect if it is an implicit string continuation 2. To detect if the string contains any new lines 3. To detect the preferred quote 4. To normalize the string Edit: I integrated the detection of newlines into the preferred quote detection so that we only iterate the string three time. We can probably do better by merging the implicit string continuation with the quote detection and new line detection by iterating till the end of the string part and returning the offset. We then use our simple tokenizer to skip over any comments or whitespace until we find the first non trivia token. From there we keep continue doing this in a loop until we reach the end o the string. I'll leave this improvement for later.	2023-06-23 09:46:05 +02:00
Micha Reiser	3e12bdff45	Format Compare Op ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR adds basic formatting for compare operations. The implementation currently breaks diffeently when nesting binary like expressions. I haven't yet figured out what Black's logic is in that case but I think that this by itself is already an improvement worth merging. <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan I added a few new tests <!-- How was it tested? -->	2023-06-23 09:35:29 +02:00
konstin	d407165aa7	Fix formatter panic with comment after parenthesized dict value (#5293) ... ## Summary This snippet used to panic because it expected to see a comma or something similar after the `2` but met the closing parentheses that is not part of the range and panicked ```python a = { 1: (2), # comment 3: True, } ``` Originally found in 636a717ef0/testing/marionette/client/marionette_driver/geckoinstance.py (L109) This snippet is also the test plan.	2023-06-22 16:52:48 +02:00
Micha Reiser	f7e1cf4b51	Format class definitions (#5289)	2023-06-22 09:09:43 +00:00
konstin	7d4f8e59da	Improve FormatExprCall dummy (#5290) ... This solves an instability when formatting cpython. It also introduces another one, but i think it's still a worthwhile change for now. There's no proper testing since this is just a dummy.	2023-06-22 10:59:30 +02:00
Micha Reiser	ccf34aae8c	Format Attribute Expression (#5259)	2023-06-21 21:33:53 +00:00
David Szotten	1eccbbb60e	Format StmtFor (#5163) ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary format StmtFor still trying to learn how to help out with the formatter. trying something slightly more advanced than [break](#5158) mostly copied form StmtWhile ## Test Plan snapshots	2023-06-21 23:00:31 +02:00
konstin	9419d3f9c8	Special ExprTuple formatting option for for-loops (#5175) ... ## Motivation While black keeps parentheses nearly everywhere, the notable exception is in the body of for loops: ```python for (a, b) in x: pass ``` becomes ```python for a, b in x: pass ``` This currently blocks #5163, which this PR should unblock. ## Solution This changes the `ExprTuple` formatting option to include one additional option that removes the parentheses when not using magic trailing comma and not breaking. It is supposed to be used through ```rust #[derive(Debug)] struct ExprTupleWithoutParentheses<'a>(&'a Expr); impl Format<PyFormatContext<'_>> for ExprTupleWithoutParentheses<'_> { fn fmt(&self, f: &mut Formatter<PyFormatContext<'_>>) -> FormatResult<()> { match self.0 { Expr::Tuple(expr_tuple) => expr_tuple .format() .with_options(TupleParentheses::StripInsideForLoop) .fmt(f), other => other.format().with_options(Parenthesize::IfBreaks).fmt(f), } } } ``` ## Testing The for loop formatting isn't merged due to missing this (and i didn't want to create more git weirdness across two people), but I've confirmed that when applying this to while loops instead of for loops, then ```rust write!( f, [ text("while"), space(), ExprTupleWithoutParentheses(test.as_ref()), text(":"), trailing_comments(trailing_condition_comments), block_indent(&body.format()) ] )?; ``` makes ```python while (a, b): pass while ( ajssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssa, b, ): pass while (a,b,): pass ``` formatted as ```python while a, b: pass while ( ajssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssa, b, ): pass while ( a, b, ): pass ```	2023-06-21 21:17:47 +02:00
konstin	d7c7484618	Format function argument separator comments (#5211) ... ## Summary This is a complete rewrite of the handling of `/` and `*` comment handling in function signatures. The key problem is that slash and star don't have a note. We now parse out the positions of slash and star and their respective preceding and following note. I've left code comments for each possible case of function signature structure and comment placement ## Test Plan I extended the function statement fixtures with cases that i found. If you have more weird edge cases your input would be appreciated.	2023-06-21 17:56:47 +00:00
konstin	bc63cc9b3c	Fix remaining CPython formatter errors except for function argument separator comments (#5210) ... ## Summary This fixes two problems discovered when trying to format the cpython repo with `cargo run --bin ruff_dev -- check-formatter-stability projects/cpython`: The first is to ignore try/except trailing comments for now since they lead to unstable formatting on the dummy. The second is to avoid dropping trailing if comments through placement: This changes the placement to keep a comment trailing an if-elif or if-elif-else to keep the comment a trailing comment on the entire if. Previously the last comment would have been lost. ```python if "first if":     pass elif "first elif":     pass ``` The last remaining problem in cpython so far is function signature argument separator comment placement which is its own PR on top of this. ## Test Plan I added test fixtures of minimized examples with links back to the original cpython location	2023-06-21 19:45:53 +02:00
Micha Reiser	e47aa468d5	Format Identifier (#5255)	2023-06-21 17:35:37 +02:00
konstin	6155fd647d	Format Slice Expressions (#5047) ... This formats slice expressions and subscript expressions. Spaces around the colons follows the same rules as black (https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#slices): ```python e00 = "e"[:] e01 = "e"[:1] e02 = "e"[: a()] e10 = "e"[1:] e11 = "e"[1:1] e12 = "e"[1 : a()] e20 = "e"[a() :] e21 = "e"[a() : 1] e22 = "e"[a() : a()] e200 = "e"[a() : :] e201 = "e"[a() :: 1] e202 = "e"[a() :: a()] e210 = "e"[a() : 1 :] ``` Comment placement is different due to our very different infrastructure. If we have explicit bounds (e.g. `x[1:2]`) all comments get assigned as leading or trailing to the bound expression. If a bound is missing `[:]`, comments get marked as dangling and placed in the same section as they were originally in: ```python x = "x"[ # a # b : # c # d ] ``` to ```python x = "x"[ # a # b : # c # d ] ``` Except for the potential trailing end-of-line comments, all comments get formatted on their own line. This can be improved by keeping end-of-line comments after the opening bracket or after a colon as such but the changes were already complex enough. I added tests for comment placement and spaces.	2023-06-21 15:09:39 +00:00
konstin	44156f6962	Improve debuggability of place_comment (#5209) ... ## Summary I found it hard to figure out which function decides placement for a specific comment. An explicit loop makes this easier to debug ## Test Plan There should be no functional changes, no changes to the formatting of the fixtures.	2023-06-21 09:52:13 +00:00
Micha Reiser	653dbb6d17	Format BoolOp (#4986)	2023-06-21 09:27:57 +00:00
konstin	db301c14bd	Consistently name comment own line/end-of-line line_position() (#5215) ... ## Summary Previously, `DecoratedComment` used `text_position()` and `SourceComment` used `position()`. This PR unifies this to `line_position` everywhere. ## Test Plan This is a rename refactoring.	2023-06-21 11:04:56 +02:00
Micha Reiser	1336ca601b	Format UnaryExpr ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR adds basic formatting for unary expressions. <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan I added a new `unary.py` with custom test cases	2023-06-21 10:09:47 +02:00
Micha Reiser	3973836420	Correctly handle left/right breaking of binary expression ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary Black supports for layouts when it comes to breaking binary expressions: ```rust #[derive(Copy, Clone, Debug, Eq, PartialEq)] enum BinaryLayout { /// Put each operand on their own line if either side expands Default, /// Try to expand the left to make it fit. Add parentheses if the left or right don't fit. /// ///```python /// [ /// a, /// b /// ] & c ///``` ExpandLeft, /// Try to expand the right to make it fix. Add parentheses if the left or right don't fit. /// /// ```python /// a & [ /// b, /// c /// ] /// ``` ExpandRight, /// Both the left and right side can be expanded. Try in the following order: /// * expand the right side /// * expand the left side /// * expand both sides /// /// to make the expression fit /// /// ```python /// [ /// a, /// b /// ] & [ /// c, /// d /// ] /// ``` ExpandRightThenLeft, } ``` Our current implementation only handles `ExpandRight` and `Default` correctly. This PR adds support for `ExpandRightThenLeft` and `ExpandLeft`. ## Test Plan I added tests that play through all 4 binary expression layouts.	2023-06-21 09:40:05 +02:00
Micha Reiser	e520a3a721	Fix ArgWithDefault comments handling (#5204)	2023-06-20 20:48:07 +00:00
Micha Reiser	b369288833	Accept any Into<AnyNodeRef> as Comments arguments (#5205)	2023-06-20 16:49:21 +00:00
Charlie Marsh	6331598511	Upgrade RustPython to access ranged names (#5194) ... ## Summary In https://github.com/astral-sh/RustPython-Parser/pull/8, we modified RustPython to include ranges for any identifiers that aren't `Expr::Name` (which already has an identifier). For example, the `e` in `except ValueError as e` was previously un-ranged. To extract its range, we had to do some lexing of our own. This change should improve performance and let us remove a bunch of code. ## Test Plan `cargo test`	2023-06-20 15:43:38 +00:00
David Szotten	773e79b481	basic formatting for ExprDict (#5167)	2023-06-20 09:25:08 +00:00
Charlie Marsh	36e01ad6eb	Upgrade RustPython (#5192) ... ## Summary This PR upgrade RustPython to pull in the changes to `Arguments` (zip defaults with their identifiers) and all the renames to `CmpOp` and friends.	2023-06-19 21:09:53 +00:00