Auto merge of #15721 - Veykril:shrink-pat-ptr, r=Veykril

Shrink PatPtr by swapping its AstPtr and Either wrap order

Will have neglible perf results I imagine, but it cleans up some code

Author: bors

crates/hir-def/src/body.rs

@@ -57,7 +57,7 @@ pub struct Body {
 pub type ExprPtr = AstPtr<ast::Expr>;
 pub type ExprSource = InFile<ExprPtr>;
 
-pub type PatPtr = Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>;
+pub type PatPtr = AstPtr<Either<ast::Pat, ast::SelfParam>>;
 pub type PatSource = InFile<PatPtr>;
 
 pub type LabelPtr = AstPtr<ast::Label>;
@@ -356,12 +356,12 @@ impl BodySourceMap {
     }
 
     pub fn node_pat(&self, node: InFile<&ast::Pat>) -> Option<PatId> {
-        let src = node.map(|it| Either::Left(AstPtr::new(it)));
+        let src = node.map(|it| AstPtr::new(it).wrap_left());
         self.pat_map.get(&src).cloned()
     }
 
     pub fn node_self_param(&self, node: InFile<&ast::SelfParam>) -> Option<PatId> {
-        let src = node.map(|it| Either::Right(AstPtr::new(it)));
+        let src = node.map(|it| AstPtr::new(it).wrap_right());
         self.pat_map.get(&src).cloned()
     }
 

crates/hir-def/src/body/lower.rs

@@ -196,16 +196,12 @@ impl ExprCollector<'_> {
             if let Some(self_param) =
                 param_list.self_param().filter(|_| attr_enabled.next().unwrap_or(false))
             {
-                let ptr = AstPtr::new(&self_param);
-                let binding_id: la_arena::Idx<Binding> = self.alloc_binding(
-                    name![self],
-                    BindingAnnotation::new(
-                        self_param.mut_token().is_some() && self_param.amp_token().is_none(),
-                        false,
-                    ),
-                );
-                let param_pat =
-                    self.alloc_pat(Pat::Bind { id: binding_id, subpat: None }, Either::Right(ptr));
+                let is_mutable =
+                    self_param.mut_token().is_some() && self_param.amp_token().is_none();
+                let ptr = AstPtr::new(&Either::Right(self_param));
+                let binding_id: la_arena::Idx<Binding> =
+                    self.alloc_binding(name![self], BindingAnnotation::new(is_mutable, false));
+                let param_pat = self.alloc_pat(Pat::Bind { id: binding_id, subpat: None }, ptr);
                 self.add_definition_to_binding(binding_id, param_pat);
                 self.body.params.push(param_pat);
             }
@@ -1260,8 +1256,8 @@ impl ExprCollector<'_> {
                     (Some(id), Pat::Bind { id, subpat })
                 };
 
-                let ptr = AstPtr::new(&pat);
-                let pat = self.alloc_pat(pattern, Either::Left(ptr));
+                let ptr = AstPtr::new(&Either::Left(pat));
+                let pat = self.alloc_pat(pattern, ptr);
                 if let Some(binding_id) = binding {
                     self.add_definition_to_binding(binding_id, pat);
                 }
@@ -1395,7 +1391,7 @@ impl ExprCollector<'_> {
             ast::Pat::MacroPat(mac) => match mac.macro_call() {
                 Some(call) => {
                     let macro_ptr = AstPtr::new(&call);
-                    let src = self.expander.to_source(Either::Left(AstPtr::new(&pat)));
+                    let src = self.expander.to_source(AstPtr::new(&Either::Left(pat)));
                     let pat =
                         self.collect_macro_call(call, macro_ptr, true, |this, expanded_pat| {
                             this.collect_pat_opt(expanded_pat, binding_list)
@@ -1430,8 +1426,8 @@ impl ExprCollector<'_> {
                 Pat::Range { start, end }
             }
         };
-        let ptr = AstPtr::new(&pat);
-        self.alloc_pat(pattern, Either::Left(ptr))
+        let ptr = AstPtr::new(&Either::Left(pat));
+        self.alloc_pat(pattern, ptr)
     }
 
     fn collect_pat_opt(&mut self, pat: Option<ast::Pat>, binding_list: &mut BindingList) -> PatId {

crates/hir-def/src/body/scope.rs

@@ -475,10 +475,7 @@ fn foo() {
             .pat_syntax(*body.bindings[resolved.binding()].definitions.first().unwrap())
             .unwrap();
 
-        let local_name = pat_src.value.either(
-            |it| it.syntax_node_ptr().to_node(file.syntax()),
-            |it| it.syntax_node_ptr().to_node(file.syntax()),
-        );
+        let local_name = pat_src.value.syntax_node_ptr().to_node(file.syntax());
         assert_eq!(local_name.text_range(), expected_name.syntax().text_range());
     }
 

crates/hir-ty/src/diagnostics/decl_check.rs

@@ -336,48 +336,44 @@ impl<'a> DeclValidator<'a> {
 
         for (id, replacement) in pats_replacements {
             if let Ok(source_ptr) = source_map.pat_syntax(id) {
-                if let Some(expr) = source_ptr.value.as_ref().left() {
+                if let Some(ptr) = source_ptr.value.clone().cast::<ast::IdentPat>() {
                     let root = source_ptr.file_syntax(self.db.upcast());
-                    if let ast::Pat::IdentPat(ident_pat) = expr.to_node(&root) {
-                        let parent = match ident_pat.syntax().parent() {
-                            Some(parent) => parent,
-                            None => continue,
-                        };
-                        let name_ast = match ident_pat.name() {
-                            Some(name_ast) => name_ast,
-                            None => continue,
-                        };
+                    let ident_pat = ptr.to_node(&root);
+                    let parent = match ident_pat.syntax().parent() {
+                        Some(parent) => parent,
+                        None => continue,
+                    };
+                    let name_ast = match ident_pat.name() {
+                        Some(name_ast) => name_ast,
+                        None => continue,
+                    };
+
+                    let is_param = ast::Param::can_cast(parent.kind());
+
+                    // We have to check that it's either `let var = ...` or `var @ Variant(_)` statement,
+                    // because e.g. match arms are patterns as well.
+                    // In other words, we check that it's a named variable binding.
+                    let is_binding = ast::LetStmt::can_cast(parent.kind())
+                        || (ast::MatchArm::can_cast(parent.kind())
+                            && ident_pat.at_token().is_some());
+                    if !(is_param || is_binding) {
+                        // This pattern is not an actual variable declaration, e.g. `Some(val) => {..}` match arm.
+                        continue;
+                    }
 
-                        let is_param = ast::Param::can_cast(parent.kind());
-
-                        // We have to check that it's either `let var = ...` or `var @ Variant(_)` statement,
-                        // because e.g. match arms are patterns as well.
-                        // In other words, we check that it's a named variable binding.
-                        let is_binding = ast::LetStmt::can_cast(parent.kind())
-                            || (ast::MatchArm::can_cast(parent.kind())
-                                && ident_pat.at_token().is_some());
-                        if !(is_param || is_binding) {
-                            // This pattern is not an actual variable declaration, e.g. `Some(val) => {..}` match arm.
-                            continue;
-                        }
+                    let ident_type =
+                        if is_param { IdentType::Parameter } else { IdentType::Variable };
 
-                        let ident_type =
-                            if is_param { IdentType::Parameter } else { IdentType::Variable };
-
-                        let diagnostic = IncorrectCase {
-                            file: source_ptr.file_id,
-                            ident_type,
-                            ident: AstPtr::new(&name_ast),
-                            expected_case: replacement.expected_case,
-                            ident_text: replacement
-                                .current_name
-                                .display(self.db.upcast())
-                                .to_string(),
-                            suggested_text: replacement.suggested_text,
-                        };
+                    let diagnostic = IncorrectCase {
+                        file: source_ptr.file_id,
+                        ident_type,
+                        ident: AstPtr::new(&name_ast),
+                        expected_case: replacement.expected_case,
+                        ident_text: replacement.current_name.display(self.db.upcast()).to_string(),
+                        suggested_text: replacement.suggested_text,
+                    };
 
-                        self.sink.push(diagnostic);
-                    }
+                    self.sink.push(diagnostic);
                 }
             }
         }

crates/hir-ty/src/mir/eval.rs

@@ -375,10 +375,7 @@ impl MirEvalError {
                         Err(_) => continue,
                     },
                     MirSpan::PatId(p) => match source_map.pat_syntax(*p) {
-                        Ok(s) => s.map(|it| match it {
-                            Either::Left(e) => e.into(),
-                            Either::Right(e) => e.into(),
-                        }),
+                        Ok(s) => s.map(|it| it.syntax_node_ptr()),
                         Err(_) => continue,
                     },
                     MirSpan::Unknown => continue,

crates/hir-ty/src/tests.rs

@@ -269,12 +269,7 @@ fn pat_node(
     Some(match body_source_map.pat_syntax(pat) {
         Ok(sp) => {
             let root = db.parse_or_expand(sp.file_id);
-            sp.map(|ptr| {
-                ptr.either(
-                    |it| it.to_node(&root).syntax().clone(),
-                    |it| it.to_node(&root).syntax().clone(),
-                )
-            })
+            sp.map(|ptr| ptr.to_node(&root).syntax().clone())
         }
         Err(SyntheticSyntax) => return None,
     })
@@ -303,12 +298,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
             let syntax_ptr = match body_source_map.pat_syntax(pat) {
                 Ok(sp) => {
                     let root = db.parse_or_expand(sp.file_id);
-                    sp.map(|ptr| {
-                        ptr.either(
-                            |it| it.to_node(&root).syntax().clone(),
-                            |it| it.to_node(&root).syntax().clone(),
-                        )
-                    })
+                    sp.map(|ptr| ptr.to_node(&root).syntax().clone())
                 }
                 Err(SyntheticSyntax) => continue,
             };

crates/hir/src/diagnostics.rs

@@ -174,20 +174,19 @@ pub struct MalformedDerive {
 
 #[derive(Debug)]
 pub struct NoSuchField {
-    pub field: InFile<Either<AstPtr<ast::RecordExprField>, AstPtr<ast::RecordPatField>>>,
+    pub field: InFile<AstPtr<Either<ast::RecordExprField, ast::RecordPatField>>>,
     pub private: bool,
 }
 
 #[derive(Debug)]
 pub struct PrivateAssocItem {
-    pub expr_or_pat:
-        InFile<Either<AstPtr<ast::Expr>, Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>>>,
+    pub expr_or_pat: InFile<AstPtr<Either<ast::Expr, Either<ast::Pat, ast::SelfParam>>>>,
     pub item: AssocItem,
 }
 
 #[derive(Debug)]
 pub struct MismatchedTupleStructPatArgCount {
-    pub expr_or_pat: InFile<Either<AstPtr<ast::Expr>, AstPtr<ast::Pat>>>,
+    pub expr_or_pat: InFile<AstPtr<Either<ast::Expr, ast::Pat>>>,
     pub expected: usize,
     pub found: usize,
 }
@@ -228,7 +227,7 @@ pub struct MissingUnsafe {
 #[derive(Debug)]
 pub struct MissingFields {
     pub file: HirFileId,
-    pub field_list_parent: Either<AstPtr<ast::RecordExpr>, AstPtr<ast::RecordPat>>,
+    pub field_list_parent: AstPtr<Either<ast::RecordExpr, ast::RecordPat>>,
     pub field_list_parent_path: Option<AstPtr<ast::Path>>,
     pub missed_fields: Vec<Name>,
 }
@@ -255,7 +254,7 @@ pub struct MissingMatchArms {
 
 #[derive(Debug)]
 pub struct TypeMismatch {
-    pub expr_or_pat: Either<InFile<AstPtr<ast::Expr>>, InFile<AstPtr<ast::Pat>>>,
+    pub expr_or_pat: InFile<AstPtr<Either<ast::Expr, ast::Pat>>>,
     pub expected: Type,
     pub actual: Type,
 }