Less box

Summary: Avoid some, given it is not standard.

Reviewed By: yangdanny97

Differential Revision: D75456358

fbshipit-source-id: 20f1132403d5de7a622ec70460508e6cf096f03c

Author: ndmitchell

pyrefly/lib/alt/expr.rs

@@ -1428,8 +1428,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Expr::BooleanLiteral(x) => Lit::from_boolean_literal(x).to_type(),
             Expr::NoneLiteral(_) => Type::None,
             Expr::EllipsisLiteral(_) => Type::Ellipsis,
-            Expr::Starred(ExprStarred { value: box x, .. }) => {
-                let ty = self.expr_untype(x, TypeFormContext::TypeArgument, errors);
+            Expr::Starred(ExprStarred { value, .. }) => {
+                let ty = self.expr_untype(value, TypeFormContext::TypeArgument, errors);
                 Type::Unpack(Box::new(ty))
             }
             Expr::Slice(x) => {
@@ -1485,7 +1485,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 ..
             }) => {
                 let lower_literal = match lower_expr {
-                    Some(box expr) => {
+                    Some(expr) => {
                         let lower_type = self.expr_infer(expr, errors);
                         match &lower_type {
                             Type::Literal(lit) => lit.as_index_i64(),
@@ -1495,7 +1495,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     None => Some(0),
                 };
                 let upper_literal = match upper_expr {
-                    Some(box expr) => {
+                    Some(expr) => {
                         let upper_type = self.expr_infer(expr, errors);
                         match &upper_type {
                             Type::Literal(lit) => lit.as_index_i64(),

pyrefly/lib/alt/narrow.rs

@@ -200,11 +200,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     }
                     Type::Tuple(Tuple::Unpacked(box (
                         prefix,
-                        Type::Tuple(Tuple::Unbounded(box middle)),
+                        Type::Tuple(Tuple::Unbounded(middle)),
                         suffix,
                     ))) if prefix.len() + suffix.len() < len => {
                         let middle_elements =
-                            vec![middle.clone(); len - prefix.len() - suffix.len()];
+                            vec![(**middle).clone(); len - prefix.len() - suffix.len()];
                         Type::tuple(
                             prefix
                                 .iter()
@@ -214,8 +214,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                                 .collect(),
                         )
                     }
-                    Type::Tuple(Tuple::Unbounded(box elements)) => {
-                        Type::tuple(vec![elements.clone(); len])
+                    Type::Tuple(Tuple::Unbounded(elements)) => {
+                        Type::tuple(vec![(**elements).clone(); len])
                     }
                     Type::ClassType(class)
                         if let Some(elements) = self.named_tuple_element_types(class)
@@ -402,7 +402,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         None,
                         None,
                     );
-                    if let Type::TypeIs(box t) = ret {
+                    if let Type::TypeIs(t) = ret {
                         return self.intersect(ty, &t);
                     }
                 }
@@ -423,7 +423,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         None,
                         None,
                     );
-                    if let Type::TypeIs(box t) = ret {
+                    if let Type::TypeIs(t) = ret {
                         return self.subtract(ty, &t);
                     }
                 }

pyrefly/lib/alt/operators.rs

@@ -149,9 +149,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     r_suffix.clone(),
                 ))))
             }
-            (Tuple::Unbounded(box l), Tuple::Unpacked(box (r_prefix, r_middle, r_suffix))) => {
+            (Tuple::Unbounded(l), Tuple::Unpacked(box (r_prefix, r_middle, r_suffix))) => {
                 let mut middle = r_prefix.clone();
-                middle.push(l.clone());
+                middle.push((**l).clone());
                 middle.push(
                     self.unwrap_iterable(r_middle)
                         .unwrap_or(Type::any_implicit()),
@@ -162,9 +162,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     r_suffix.clone(),
                 ))))
             }
-            (Tuple::Unpacked(box (l_prefix, l_middle, l_suffix)), Tuple::Unbounded(box r)) => {
+            (Tuple::Unpacked(box (l_prefix, l_middle, l_suffix)), Tuple::Unbounded(r)) => {
                 let mut middle = l_suffix.clone();
-                middle.push(r.clone());
+                middle.push((**r).clone());
                 middle.push(
                     self.unwrap_iterable(l_middle)
                         .unwrap_or(Type::any_implicit()),

pyrefly/lib/binding/function.rs

@@ -194,7 +194,7 @@ impl<'a> BindingsBuilder<'a> {
                 class_key,
             );
         }
-        if let Some(box kwargs) = &x.kwarg {
+        if let Some(kwargs) = &x.kwarg {
             self.bind_function_param(
                 AnnotationTarget::KwargsParam(kwargs.name.id.clone()),
                 AnyParameterRef::Variadic(kwargs),
@@ -251,9 +251,8 @@ impl<'a> BindingsBuilder<'a> {
             }
         }
 
-        let return_ann_with_range = mem::take(&mut x.returns).map(|box e| {
-            self.to_return_annotation_with_range(e, func_name, class_key, &mut legacy)
-        });
+        let return_ann_with_range = mem::take(&mut x.returns)
+            .map(|e| self.to_return_annotation_with_range(*e, func_name, class_key, &mut legacy));
 
         let legacy_tparam_builder = legacy.unwrap();
         legacy_tparam_builder.add_name_definitions(self);