internal: Replace Vec with Box in hir Expr

5 files changed, 34 insertions, 37 deletions

diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 31362067612..48aa1b3464b 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -130,11 +130,7 @@ impl ExprCollector<'_> {
                 self.body.params.push(param_pat);
             }
 
-            for param in param_list.params() {
-                let pat = match param.pat() {
-                    None => continue,
-                    Some(pat) => pat,
-                };
+            for pat in param_list.params().filter_map(|param| param.pat()) {
                 let param_pat = self.collect_pat(pat);
                 self.body.params.push(param_pat);
             }
@@ -160,7 +156,7 @@ impl ExprCollector<'_> {
         self.make_expr(expr, Err(SyntheticSyntax))
     }
     fn unit(&mut self) -> ExprId {
-        self.alloc_expr_desugared(Expr::Tuple { exprs: Vec::new() })
+        self.alloc_expr_desugared(Expr::Tuple { exprs: Box::default() })
     }
     fn missing_expr(&mut self) -> ExprId {
         self.alloc_expr_desugared(Expr::Missing)
@@ -235,7 +231,8 @@ impl ExprCollector<'_> {
                                     expr: else_branch.unwrap_or_else(|| self.unit()),
                                     guard: None,
                                 },
-                            ];
+                            ]
+                            .into();
                             return Some(
                                 self.alloc_expr(Expr::Match { expr: match_expr, arms }, syntax_ptr),
                             );
@@ -300,7 +297,8 @@ impl ExprCollector<'_> {
                             let arms = vec![
                                 MatchArm { pat, expr: body, guard: None },
                                 MatchArm { pat: placeholder_pat, expr: break_, guard: None },
-                            ];
+                            ]
+                            .into();
                             let match_expr =
                                 self.alloc_expr_desugared(Expr::Match { expr: match_expr, arms });
                             return Some(
@@ -324,7 +322,7 @@ impl ExprCollector<'_> {
                 let args = if let Some(arg_list) = e.arg_list() {
                     arg_list.args().filter_map(|e| self.maybe_collect_expr(e)).collect()
                 } else {
-                    Vec::new()
+                    Box::default()
                 };
                 self.alloc_expr(Expr::Call { callee, args }, syntax_ptr)
             }
@@ -333,7 +331,7 @@ impl ExprCollector<'_> {
                 let args = if let Some(arg_list) = e.arg_list() {
                     arg_list.args().filter_map(|e| self.maybe_collect_expr(e)).collect()
                 } else {
-                    Vec::new()
+                    Box::default()
                 };
                 let method_name = e.name_ref().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
                 let generic_args = e
@@ -367,7 +365,7 @@ impl ExprCollector<'_> {
                         })
                         .collect()
                 } else {
-                    Vec::new()
+                    Box::default()
                 };
                 self.alloc_expr(Expr::Match { expr, arms }, syntax_ptr)
             }
@@ -429,7 +427,7 @@ impl ExprCollector<'_> {
                     let spread = nfl.spread().map(|s| self.collect_expr(s));
                     Expr::RecordLit { path, fields, spread }
                 } else {
-                    Expr::RecordLit { path, fields: Vec::new(), spread: None }
+                    Expr::RecordLit { path, fields: Box::default(), spread: None }
                 };
 
                 self.alloc_expr(record_lit, syntax_ptr)
@@ -496,7 +494,10 @@ impl ExprCollector<'_> {
                     .and_then(|r| r.ty())
                     .map(|it| Interned::new(TypeRef::from_ast(&self.ctx(), it)));
                 let body = self.collect_expr_opt(e.body());
-                self.alloc_expr(Expr::Lambda { args, arg_types, ret_type, body }, syntax_ptr)
+                self.alloc_expr(
+                    Expr::Lambda { args: args.into(), arg_types: arg_types.into(), ret_type, body },
+                    syntax_ptr,
+                )
             }
             ast::Expr::BinExpr(e) => {
                 let lhs = self.collect_expr_opt(e.lhs());
@@ -718,7 +719,7 @@ impl ExprCollector<'_> {
             self.statements_in_scope.pop();
         }
         let tail = tail;
-        let statements = std::mem::replace(&mut self.statements_in_scope, prev_statements);
+        let statements = std::mem::replace(&mut self.statements_in_scope, prev_statements).into();
         let syntax_node_ptr = AstPtr::new(&block.into());
         let expr_id = self.alloc_expr(
             Expr::Block { id: block_id, statements, tail, label: None },
diff --git a/crates/hir_def/src/body/scope.rs b/crates/hir_def/src/body/scope.rs
index 147d6412357..2658eece8e8 100644
--- a/crates/hir_def/src/body/scope.rs
+++ b/crates/hir_def/src/body/scope.rs
@@ -204,7 +204,7 @@ fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut ExprScopes, scope
         }
         Expr::Match { expr, arms } => {
             compute_expr_scopes(*expr, body, scopes, scope);
-            for arm in arms {
+            for arm in arms.iter() {
                 let mut scope = scopes.new_scope(scope);
                 scopes.add_bindings(body, scope, arm.pat);
                 match arm.guard {
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index 17af48b7bf6..587a5ce46d4 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -61,7 +61,7 @@ pub enum Expr {
     },
     Block {
         id: BlockId,
-        statements: Vec<Statement>,
+        statements: Box<[Statement]>,
         tail: Option<ExprId>,
         label: Option<LabelId>,
     },
@@ -82,17 +82,17 @@ pub enum Expr {
     },
     Call {
         callee: ExprId,
-        args: Vec<ExprId>,
+        args: Box<[ExprId]>,
     },
     MethodCall {
         receiver: ExprId,
         method_name: Name,
-        args: Vec<ExprId>,
+        args: Box<[ExprId]>,
         generic_args: Option<Box<GenericArgs>>,
     },
     Match {
         expr: ExprId,
-        arms: Vec<MatchArm>,
+        arms: Box<[MatchArm]>,
     },
     Continue {
         label: Option<Name>,
@@ -109,7 +109,7 @@ pub enum Expr {
     },
     RecordLit {
         path: Option<Box<Path>>,
-        fields: Vec<RecordLitField>,
+        fields: Box<[RecordLitField]>,
         spread: Option<ExprId>,
     },
     Field {
@@ -162,13 +162,13 @@ pub enum Expr {
         index: ExprId,
     },
     Lambda {
-        args: Vec<PatId>,
-        arg_types: Vec<Option<Interned<TypeRef>>>,
+        args: Box<[PatId]>,
+        arg_types: Box<[Option<Interned<TypeRef>>]>,
         ret_type: Option<Interned<TypeRef>>,
         body: ExprId,
     },
     Tuple {
-        exprs: Vec<ExprId>,
+        exprs: Box<[ExprId]>,
     },
     Unsafe {
         body: ExprId,
@@ -233,7 +233,7 @@ impl Expr {
                 }
             }
             Expr::Block { statements, tail, .. } => {
-                for stmt in statements {
+                for stmt in statements.iter() {
                     match stmt {
                         Statement::Let { initializer, .. } => {
                             if let Some(expr) = initializer {
@@ -262,19 +262,19 @@ impl Expr {
             }
             Expr::Call { callee, args } => {
                 f(*callee);
-                for arg in args {
+                for arg in args.iter() {
                     f(*arg);
                 }
             }
             Expr::MethodCall { receiver, args, .. } => {
                 f(*receiver);
-                for arg in args {
+                for arg in args.iter() {
                     f(*arg);
                 }
             }
             Expr::Match { expr, arms } => {
                 f(*expr);
-                for arm in arms {
+                for arm in arms.iter() {
                     f(arm.expr);
                 }
             }
@@ -285,7 +285,7 @@ impl Expr {
                 }
             }
             Expr::RecordLit { fields, spread, .. } => {
-                for field in fields {
+                for field in fields.iter() {
                     f(field.expr);
                 }
                 if let Some(expr) = spread {
@@ -321,7 +321,7 @@ impl Expr {
                 f(*expr);
             }
             Expr::Tuple { exprs } => {
-                for expr in exprs {
+                for expr in exprs.iter() {
                     f(*expr);
                 }
             }
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index abcb84401b4..195c53c17e2 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -202,19 +202,16 @@ impl ExprValidator {
         }
 
         let is_method_call = matches!(expr, Expr::MethodCall { .. });
-        let (sig, args) = match expr {
+        let (sig, mut arg_count) = match expr {
             Expr::Call { callee, args } => {
                 let callee = &self.infer.type_of_expr[*callee];
                 let sig = match callee.callable_sig(db) {
                     Some(sig) => sig,
                     None => return,
                 };
-                (sig, args.clone())
+                (sig, args.len())
             }
             Expr::MethodCall { receiver, args, .. } => {
-                let mut args = args.clone();
-                args.insert(0, *receiver);
-
                 let receiver = &self.infer.type_of_expr[*receiver];
                 if receiver.strip_references().is_unknown() {
                     // if the receiver is of unknown type, it's very likely we
@@ -229,7 +226,7 @@ impl ExprValidator {
                 };
                 let sig = db.callable_item_signature(callee.into()).substitute(&Interner, &subst);
 
-                (sig, args)
+                (sig, args.len() + 1)
             }
             _ => return,
         };
@@ -241,7 +238,6 @@ impl ExprValidator {
         let params = sig.params();
 
         let mut param_count = params.len();
-        let mut arg_count = args.len();
 
         if arg_count != param_count {
             if is_method_call {
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 3aad9d4cc8a..5fb227c0e49 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -375,7 +375,7 @@ impl<'a> InferenceContext<'a> {
                 let matchee_diverges = self.diverges;
                 let mut all_arms_diverge = Diverges::Always;
 
-                for arm in arms {
+                for arm in arms.iter() {
                     self.diverges = Diverges::Maybe;
                     let _pat_ty = self.infer_pat(arm.pat, &input_ty, BindingMode::default());
                     match arm.guard {