ty 0.0.0a6__tar.gz → 0.0.0a7__tar.gz

{ty-0.0.0a6 → ty-0.0.0a7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ty
-Version: 0.0.0a6
+Version: 0.0.0a7
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -37,7 +37,12 @@ Project-URL: Discord, https://discord.gg/astral-sh
 
 An extremely fast Python type checker and language server, written in Rust.
 
-**This project is still in development and is not ready for production use.**
+> [!WARNING]
+> ty is pre-release software and not ready for production use. Expect to encounter bugs, missing
+> features, and fatal errors.
+
+ty is in active development, and we're working hard to make it stable
+and feature-complete.
 
 ## Getting involved
 

{ty-0.0.0a6 → ty-0.0.0a7}/README.md

@@ -2,7 +2,12 @@
 
 An extremely fast Python type checker and language server, written in Rust.
 
-**This project is still in development and is not ready for production use.**
+> [!WARNING]
+> ty is pre-release software and not ready for production use. Expect to encounter bugs, missing
+> features, and fatal errors.
+
+ty is in active development, and we're working hard to make it stable
+and feature-complete.
 
 ## Getting involved
 

{ty-0.0.0a6 → ty-0.0.0a7}/dist-workspace.toml

@@ -1,7 +1,7 @@
 [workspace]
 members = ["cargo:./ruff"]
 packages = ["ty"]
-version = "0.0.0-alpha.6"
+version = "0.0.0-alpha.7"
 
 # Config for 'dist'
 [dist]

{ty-0.0.0a6 → ty-0.0.0a7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ty"
-version = "0.0.0a6"
+version = "0.0.0a7"
 requires-python = ">=3.8"
 dependencies = []
 description = "An extremely fast Python type checker, written in Rust."
@@ -83,7 +83,7 @@ required-imports = ["from __future__ import annotations"]
 
 
 [tool.uv.sources]
-rooster-blue = { git = "https://github.com/zanieb/rooster", rev = "e070bc9" }
+rooster-blue = { git = "https://github.com/zanieb/rooster", rev = "f6e61d2" }
 
 [tool.maturin]
 bindings = "bin"
@@ -104,7 +104,8 @@ version-files = [
     { path = "dist-workspace.toml", field = "workspace.version", format = "cargo" },
 ]
 submodules = ["ruff"]
-required-labels = [{ submodule = "ruff", labels = ["ty"] }]
+require-labels = [{ submodule = "ruff", labels = ["ty"] }]
+ignore-labels = ["internal"]
 version-format = "cargo"
 default-bump-type = "pre"
 trim-title-prefixes = ["[ty]"]

{ty-0.0.0a6 → ty-0.0.0a7}/ruff/crates/ruff_db/src/diagnostic/mod.rs

@@ -232,6 +232,15 @@ impl Diagnostic {
     pub fn primary_tags(&self) -> Option<&[DiagnosticTag]> {
         self.primary_annotation().map(|ann| ann.tags.as_slice())
     }
+
+    /// Returns a key that can be used to sort two diagnostics into the canonical order
+    /// in which they should appear when rendered.
+    pub fn rendering_sort_key<'a>(&'a self, db: &'a dyn Db) -> impl Ord + 'a {
+        RenderingSortKey {
+            db,
+            diagnostic: self,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -243,6 +252,64 @@ struct DiagnosticInner {
     subs: Vec<SubDiagnostic>,
 }
 
+struct RenderingSortKey<'a> {
+    db: &'a dyn Db,
+    diagnostic: &'a Diagnostic,
+}
+
+impl Ord for RenderingSortKey<'_> {
+    // We sort diagnostics in a way that keeps them in source order
+    // and grouped by file. After that, we fall back to severity
+    // (with fatal messages sorting before info messages) and then
+    // finally the diagnostic ID.
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        if let (Some(span1), Some(span2)) = (
+            self.diagnostic.primary_span(),
+            other.diagnostic.primary_span(),
+        ) {
+            let order = span1
+                .file()
+                .path(self.db)
+                .as_str()
+                .cmp(span2.file().path(self.db).as_str());
+            if order.is_ne() {
+                return order;
+            }
+
+            if let (Some(range1), Some(range2)) = (span1.range(), span2.range()) {
+                let order = range1.start().cmp(&range2.start());
+                if order.is_ne() {
+                    return order;
+                }
+            }
+        }
+        // Reverse so that, e.g., Fatal sorts before Info.
+        let order = self
+            .diagnostic
+            .severity()
+            .cmp(&other.diagnostic.severity())
+            .reverse();
+        if order.is_ne() {
+            return order;
+        }
+        self.diagnostic.id().cmp(&other.diagnostic.id())
+    }
+}
+
+impl PartialOrd for RenderingSortKey<'_> {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl PartialEq for RenderingSortKey<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        self.cmp(other).is_eq()
+    }
+}
+
+impl Eq for RenderingSortKey<'_> {}
+
 /// A collection of information subservient to a diagnostic.
 ///
 /// A sub-diagnostic is always rendered after the parent diagnostic it is

{ty-0.0.0a6 → ty-0.0.0a7}/ruff/crates/ruff_python_parser/resources/inline/err/args_unparenthesized_generator.py

@@ -1,2 +1,3 @@
 sum(x for x in range(10), 5)
 total(1, 2, x for x in range(5), 6)
+sum(x for x in range(10),)

ty-0.0.0a7/ruff/crates/ruff_python_parser/resources/inline/ok/args_unparenthesized_generator.py

@@ -0,0 +1,3 @@
+zip((x for x in range(10)), (y for y in range(10)))
+sum(x for x in range(10))
+sum((x for x in range(10)),)

{ty-0.0.0a6 → ty-0.0.0a7}/ruff/crates/ruff_python_parser/src/parser/expression.rs

@@ -661,117 +661,120 @@ impl<'src> Parser<'src> {
         let mut seen_keyword_argument = false; // foo = 1
         let mut seen_keyword_unpacking = false; // **foo
 
-        self.parse_comma_separated_list(RecoveryContextKind::Arguments, |parser| {
-            let argument_start = parser.node_start();
-            if parser.eat(TokenKind::DoubleStar) {
-                let value = parser.parse_conditional_expression_or_higher();
-
-                keywords.push(ast::Keyword {
-                    arg: None,
-                    value: value.expr,
-                    range: parser.node_range(argument_start),
-                });
-
-                seen_keyword_unpacking = true;
-            } else {
-                let start = parser.node_start();
-                let mut parsed_expr = parser
-                    .parse_named_expression_or_higher(ExpressionContext::starred_conditional());
-
-                match parser.current_token_kind() {
-                    TokenKind::Async | TokenKind::For => {
-                        if parsed_expr.is_unparenthesized_starred_expr() {
-                            parser.add_error(
-                                ParseErrorType::IterableUnpackingInComprehension,
-                                &parsed_expr,
-                            );
-                        }
-
-                        parsed_expr = Expr::Generator(parser.parse_generator_expression(
-                            parsed_expr.expr,
-                            start,
-                            Parenthesized::No,
-                        ))
-                        .into();
-                    }
-                    _ => {
-                        if seen_keyword_unpacking && parsed_expr.is_unparenthesized_starred_expr() {
-                            parser.add_error(
-                                ParseErrorType::InvalidArgumentUnpackingOrder,
-                                &parsed_expr,
-                            );
-                        }
-                    }
-                }
-
-                let arg_range = parser.node_range(start);
-                if parser.eat(TokenKind::Equal) {
-                    seen_keyword_argument = true;
-                    let arg = if let ParsedExpr {
-                        expr: Expr::Name(ident_expr),
-                        is_parenthesized,
-                    } = parsed_expr
-                    {
-                        // test_ok parenthesized_kwarg_py37
-                        // # parse_options: {"target-version": "3.7"}
-                        // f((a)=1)
-
-                        // test_err parenthesized_kwarg_py38
-                        // # parse_options: {"target-version": "3.8"}
-                        // f((a)=1)
-                        // f((a) = 1)
-                        // f( ( a ) = 1)
-
-                        if is_parenthesized {
-                            parser.add_unsupported_syntax_error(
-                                UnsupportedSyntaxErrorKind::ParenthesizedKeywordArgumentName,
-                                arg_range,
-                            );
-                        }
-
-                        ast::Identifier {
-                            id: ident_expr.id,
-                            range: ident_expr.range,
-                        }
-                    } else {
-                        // TODO(dhruvmanila): Parser shouldn't drop the `parsed_expr` if it's
-                        // not a name expression. We could add the expression into `args` but
-                        // that means the error is a missing comma instead.
-                        parser.add_error(
-                            ParseErrorType::OtherError("Expected a parameter name".to_string()),
-                            &parsed_expr,
-                        );
-                        ast::Identifier {
-                            id: Name::empty(),
-                            range: parsed_expr.range(),
-                        }
-                    };
-
+        let has_trailing_comma =
+            self.parse_comma_separated_list(RecoveryContextKind::Arguments, |parser| {
+                let argument_start = parser.node_start();
+                if parser.eat(TokenKind::DoubleStar) {
                     let value = parser.parse_conditional_expression_or_higher();
 
                     keywords.push(ast::Keyword {
-                        arg: Some(arg),
+                        arg: None,
                         value: value.expr,
                         range: parser.node_range(argument_start),
                     });
+
+                    seen_keyword_unpacking = true;
                 } else {
-                    if !parsed_expr.is_unparenthesized_starred_expr() {
-                        if seen_keyword_unpacking {
-                            parser.add_error(
-                                ParseErrorType::PositionalAfterKeywordUnpacking,
-                                &parsed_expr,
-                            );
-                        } else if seen_keyword_argument {
+                    let start = parser.node_start();
+                    let mut parsed_expr = parser
+                        .parse_named_expression_or_higher(ExpressionContext::starred_conditional());
+
+                    match parser.current_token_kind() {
+                        TokenKind::Async | TokenKind::For => {
+                            if parsed_expr.is_unparenthesized_starred_expr() {
+                                parser.add_error(
+                                    ParseErrorType::IterableUnpackingInComprehension,
+                                    &parsed_expr,
+                                );
+                            }
+
+                            parsed_expr = Expr::Generator(parser.parse_generator_expression(
+                                parsed_expr.expr,
+                                start,
+                                Parenthesized::No,
+                            ))
+                            .into();
+                        }
+                        _ => {
+                            if seen_keyword_unpacking
+                                && parsed_expr.is_unparenthesized_starred_expr()
+                            {
+                                parser.add_error(
+                                    ParseErrorType::InvalidArgumentUnpackingOrder,
+                                    &parsed_expr,
+                                );
+                            }
+                        }
+                    }
+
+                    let arg_range = parser.node_range(start);
+                    if parser.eat(TokenKind::Equal) {
+                        seen_keyword_argument = true;
+                        let arg = if let ParsedExpr {
+                            expr: Expr::Name(ident_expr),
+                            is_parenthesized,
+                        } = parsed_expr
+                        {
+                            // test_ok parenthesized_kwarg_py37
+                            // # parse_options: {"target-version": "3.7"}
+                            // f((a)=1)
+
+                            // test_err parenthesized_kwarg_py38
+                            // # parse_options: {"target-version": "3.8"}
+                            // f((a)=1)
+                            // f((a) = 1)
+                            // f( ( a ) = 1)
+
+                            if is_parenthesized {
+                                parser.add_unsupported_syntax_error(
+                                    UnsupportedSyntaxErrorKind::ParenthesizedKeywordArgumentName,
+                                    arg_range,
+                                );
+                            }
+
+                            ast::Identifier {
+                                id: ident_expr.id,
+                                range: ident_expr.range,
+                            }
+                        } else {
+                            // TODO(dhruvmanila): Parser shouldn't drop the `parsed_expr` if it's
+                            // not a name expression. We could add the expression into `args` but
+                            // that means the error is a missing comma instead.
                             parser.add_error(
-                                ParseErrorType::PositionalAfterKeywordArgument,
+                                ParseErrorType::OtherError("Expected a parameter name".to_string()),
                                 &parsed_expr,
                             );
+                            ast::Identifier {
+                                id: Name::empty(),
+                                range: parsed_expr.range(),
+                            }
+                        };
+
+                        let value = parser.parse_conditional_expression_or_higher();
+
+                        keywords.push(ast::Keyword {
+                            arg: Some(arg),
+                            value: value.expr,
+                            range: parser.node_range(argument_start),
+                        });
+                    } else {
+                        if !parsed_expr.is_unparenthesized_starred_expr() {
+                            if seen_keyword_unpacking {
+                                parser.add_error(
+                                    ParseErrorType::PositionalAfterKeywordUnpacking,
+                                    &parsed_expr,
+                                );
+                            } else if seen_keyword_argument {
+                                parser.add_error(
+                                    ParseErrorType::PositionalAfterKeywordArgument,
+                                    &parsed_expr,
+                                );
+                            }
                         }
+                        args.push(parsed_expr.expr);
                     }
-                    args.push(parsed_expr.expr);
                 }
-            }
-        });
+            });
 
         self.expect(TokenKind::Rpar);
 
@@ -781,7 +784,7 @@ impl<'src> Parser<'src> {
             keywords: keywords.into_boxed_slice(),
         };
 
-        self.validate_arguments(&arguments);
+        self.validate_arguments(&arguments, has_trailing_comma);
 
         arguments
     }
@@ -2521,9 +2524,9 @@ impl<'src> Parser<'src> {
 
     /// Performs the following validations on the function call arguments:
     /// 1. There aren't any duplicate keyword argument
-    /// 2. If there are more than one argument (positional or keyword), all generator expressions
-    ///    present should be parenthesized.
-    fn validate_arguments(&mut self, arguments: &ast::Arguments) {
+    /// 2. If there are more than one argument (positional or keyword) or a single argument with a
+    ///    trailing comma, all generator expressions present should be parenthesized.
+    fn validate_arguments(&mut self, arguments: &ast::Arguments, has_trailing_comma: bool) {
         let mut all_arg_names =
             FxHashSet::with_capacity_and_hasher(arguments.keywords.len(), FxBuildHasher);
 
@@ -2541,7 +2544,7 @@ impl<'src> Parser<'src> {
             }
         }
 
-        if arguments.len() > 1 {
+        if has_trailing_comma || arguments.len() > 1 {
             for arg in &*arguments.args {
                 if let Some(ast::ExprGenerator {
                     range,
@@ -2550,11 +2553,14 @@ impl<'src> Parser<'src> {
                 }) = arg.as_generator_expr()
                 {
                     // test_ok args_unparenthesized_generator
+                    // zip((x for x in range(10)), (y for y in range(10)))
                     // sum(x for x in range(10))
+                    // sum((x for x in range(10)),)
 
                     // test_err args_unparenthesized_generator
                     // sum(x for x in range(10), 5)
                     // total(1, 2, x for x in range(5), 6)
+                    // sum(x for x in range(10),)
                     self.add_error(ParseErrorType::UnparenthesizedGeneratorExpression, range);
                 }
             }

{ty-0.0.0a6 → ty-0.0.0a7}/ruff/crates/ruff_python_parser/src/parser/mod.rs

@@ -539,17 +539,19 @@ impl<'src> Parser<'src> {
     }
 
     /// Parses a comma separated list of elements where each element is parsed
-    /// sing the given `parse_element` function.
+    /// using the given `parse_element` function.
     ///
     /// The difference between this function and `parse_comma_separated_list_into_vec`
     /// is that this function does not return the parsed elements. Instead, it is the
     /// caller's responsibility to handle the parsed elements. This is the reason
     /// that the `parse_element` parameter is bound to [`FnMut`] instead of [`Fn`].
+    ///
+    /// Returns `true` if there is a trailing comma present.
     fn parse_comma_separated_list(
         &mut self,
         recovery_context_kind: RecoveryContextKind,
         mut parse_element: impl FnMut(&mut Parser<'src>),
-    ) {
+    ) -> bool {
         let mut progress = ParserProgress::default();
 
         let saved_context = self.recovery_context;
@@ -659,6 +661,8 @@ impl<'src> Parser<'src> {
         }
 
         self.recovery_context = saved_context;
+
+        trailing_comma_range.is_some()
     }
 
     #[cold]

{ty-0.0.0a6 → ty-0.0.0a7}/ruff/crates/ruff_python_parser/tests/snapshots/invalid_syntax@args_unparenthesized_generator.py.snap

@@ -1,14 +1,13 @@
 ---
 source: crates/ruff_python_parser/tests/fixtures.rs
 input_file: crates/ruff_python_parser/resources/inline/err/args_unparenthesized_generator.py
-snapshot_kind: text
 ---
 ## AST
 
 ```
 Module(
     ModModule {
-        range: 0..65,
+        range: 0..92,
         body: [
             Expr(
                 StmtExpr {
@@ -194,6 +193,82 @@ Module(
                     ),
                 },
             ),
+            Expr(
+                StmtExpr {
+                    range: 65..91,
+                    value: Call(
+                        ExprCall {
+                            range: 65..91,
+                            func: Name(
+                                ExprName {
+                                    range: 65..68,
+                                    id: Name("sum"),
+                                    ctx: Load,
+                                },
+                            ),
+                            arguments: Arguments {
+                                range: 68..91,
+                                args: [
+                                    Generator(
+                                        ExprGenerator {
+                                            range: 69..89,
+                                            elt: Name(
+                                                ExprName {
+                                                    range: 69..70,
+                                                    id: Name("x"),
+                                                    ctx: Load,
+                                                },
+                                            ),
+                                            generators: [
+                                                Comprehension {
+                                                    range: 71..89,
+                                                    target: Name(
+                                                        ExprName {
+                                                            range: 75..76,
+                                                            id: Name("x"),
+                                                            ctx: Store,
+                                                        },
+                                                    ),
+                                                    iter: Call(
+                                                        ExprCall {
+                                                            range: 80..89,
+                                                            func: Name(
+                                                                ExprName {
+                                                                    range: 80..85,
+                                                                    id: Name("range"),
+                                                                    ctx: Load,
+                                                                },
+                                                            ),
+                                                            arguments: Arguments {
+                                                                range: 85..89,
+                                                                args: [
+                                                                    NumberLiteral(
+                                                                        ExprNumberLiteral {
+                                                                            range: 86..88,
+                                                                            value: Int(
+                                                                                10,
+                                                                            ),
+                                                                        },
+                                                                    ),
+                                                                ],
+                                                                keywords: [],
+                                                            },
+                                                        },
+                                                    ),
+                                                    ifs: [],
+                                                    is_async: false,
+                                                },
+                                            ],
+                                            parenthesized: false,
+                                        },
+                                    ),
+                                ],
+                                keywords: [],
+                            },
+                        },
+                    ),
+                },
+            ),
         ],
     },
 )
@@ -204,6 +279,7 @@ Module(
 1 | sum(x for x in range(10), 5)
   |     ^^^^^^^^^^^^^^^^^^^^ Syntax Error: Unparenthesized generator expression cannot be used here
 2 | total(1, 2, x for x in range(5), 6)
+3 | sum(x for x in range(10),)
   |
 
 
@@ -211,4 +287,13 @@ Module(
 1 | sum(x for x in range(10), 5)
 2 | total(1, 2, x for x in range(5), 6)
   |             ^^^^^^^^^^^^^^^^^^^ Syntax Error: Unparenthesized generator expression cannot be used here
+3 | sum(x for x in range(10),)
+  |
+
+
+  |
+1 | sum(x for x in range(10), 5)
+2 | total(1, 2, x for x in range(5), 6)
+3 | sum(x for x in range(10),)
+  |     ^^^^^^^^^^^^^^^^^^^^ Syntax Error: Unparenthesized generator expression cannot be used here
   |