Shrink additional parser AST collections (#25465)

Author: MichaReiser

crates/ruff_python_parser/src/parser/expression.rs

@@ -1004,6 +1004,8 @@ impl<'src> Parser<'src> {
                 slices.push(parser.parse_slice());
             });
 
+            slices.shrink_to_fit();
+
             slice = Expr::Tuple(ast::ExprTuple {
                 elts: slices,
                 ctx: ExprContext::Load,
@@ -1260,6 +1262,8 @@ impl<'src> Parser<'src> {
             }
         }
 
+        values.shrink_to_fit();
+
         ast::ExprBoolOp {
             values,
             op,
@@ -2476,6 +2480,8 @@ impl<'src> Parser<'src> {
             self.expect(TokenKind::Rpar);
         }
 
+        elts.shrink_to_fit();
+
         ast::ExprTuple {
             elts,
             ctx: ExprContext::Load,
@@ -2505,6 +2511,8 @@ impl<'src> Parser<'src> {
 
         self.expect(TokenKind::Rsqb);
 
+        elts.shrink_to_fit();
+
         ast::ExprList {
             elts,
             ctx: ExprContext::Load,
@@ -2599,6 +2607,8 @@ impl<'src> Parser<'src> {
 
         self.expect(TokenKind::Rbrace);
 
+        items.shrink_to_fit();
+
         ast::ExprDict {
             range: self.node_range(start),
             node_index: AtomicNodeIndex::NONE,
@@ -2623,6 +2633,8 @@ impl<'src> Parser<'src> {
             generators.push(self.parse_comprehension());
         }
 
+        generators.shrink_to_fit();
+
         generators
     }
 
@@ -2667,6 +2679,8 @@ impl<'src> Parser<'src> {
             ifs.push(parsed_expr.expr);
         }
 
+        ifs.shrink_to_fit();
+
         ast::Comprehension {
             range: self.node_range(start),
             node_index: AtomicNodeIndex::NONE,

crates/ruff_python_parser/src/parser/recovery.rs

@@ -80,6 +80,8 @@ pub(super) fn pattern_to_expr(pattern: Pattern) -> Expr {
                 });
                 items.push(ast::DictItem { key: None, value });
             }
+            items.shrink_to_fit();
+
             Expr::Dict(ast::ExprDict {
                 range,
                 node_index,

crates/ruff_python_parser/src/parser/statement.rs

@@ -614,7 +614,7 @@ impl<'src> Parser<'src> {
         // import ,
         // import x, y,
 
-        let names = self
+        let mut names = self
             .parse_comma_separated_list_into_vec(RecoveryContextKind::ImportNames, |p| {
                 p.parse_alias(ImportStyle::Import)
             });
@@ -625,6 +625,8 @@ impl<'src> Parser<'src> {
             self.add_error(ParseErrorType::EmptyImportNames, self.current_token_range());
         }
 
+        names.shrink_to_fit();
+
         ast::StmtImport {
             names,
             is_lazy,
@@ -740,6 +742,8 @@ impl<'src> Parser<'src> {
             self.expect(TokenKind::Rpar);
         }
 
+        names.shrink_to_fit();
+
         ast::StmtImportFrom {
             module,
             names,
@@ -1444,6 +1448,8 @@ impl<'src> Parser<'src> {
             elif_else_clauses.push(self.parse_elif_or_else_clause(ElifOrElse::Else));
         }
 
+        elif_else_clauses.shrink_to_fit();
+
         ast::StmtIf {
             test: Box::new(test.expr),
             body,
@@ -1539,7 +1545,7 @@ impl<'src> Parser<'src> {
         // except* ExceptionGroup:
         //     pass
         let mut mixed_except_ranges = Vec::new();
-        let handlers = self.parse_clauses(Clause::Except, |p| {
+        let mut handlers = self.parse_clauses(Clause::Except, |p| {
             let (handler, kind) = p.parse_except_clause();
             if let ExceptClauseKind::Star(range) = kind {
                 p.add_unsupported_syntax_error(UnsupportedSyntaxErrorKind::ExceptStar, range);
@@ -1551,6 +1557,8 @@ impl<'src> Parser<'src> {
             }
             handler
         });
+        handlers.shrink_to_fit();
+
         // Empty handler has `is_star` false.
         let is_star = is_star.unwrap_or_default();
         for handler_err_range in mixed_except_ranges {
@@ -2170,7 +2178,9 @@ impl<'src> Parser<'src> {
     fn parse_with_statement(&mut self, start: TextSize) -> ast::StmtWith {
         self.bump(TokenKind::With);
 
-        let items = self.parse_with_items();
+        let mut items = self.parse_with_items();
+        items.shrink_to_fit();
+
         self.expect(TokenKind::Colon);
 
         let body = self.parse_body(Clause::With);
@@ -2985,6 +2995,8 @@ impl<'src> Parser<'src> {
             self.expect(TokenKind::Newline);
         }
 
+        decorators.shrink_to_fit();
+
         match self.current_token_kind() {
             TokenKind::Def => Stmt::FunctionDef(self.parse_function_definition(decorators, start)),
             TokenKind::Class => Stmt::ClassDef(self.parse_class_definition(decorators, start)),
@@ -3528,6 +3540,10 @@ impl<'src> Parser<'src> {
             self.expect(TokenKind::Rpar);
         }
 
+        parameters.args.shrink_to_fit();
+        parameters.kwonlyargs.shrink_to_fit();
+        parameters.posonlyargs.shrink_to_fit();
+
         parameters.range = self.node_range(start);
 
         parameters