diff options
author | bors[bot] <26634292+bors[bot]@users.noreply.github.com> | 2019-09-02 20:20:24 +0100 |
---|---|---|
committer | GitHub <[email protected]> | 2019-09-02 20:20:24 +0100 |
commit | 7faec1c30046769d4ae490e15cf5405bcfbdeef8 (patch) | |
tree | 6d268b721027a5350928a6c5a0ec227b5fde8ebc /crates/ra_hir/src/expr.rs | |
parent | a8397deab914240aca8f015fb3736689919c0a5b (diff) | |
parent | e94587e3153b52684fd3f6b82c8e7efc09ff5c8d (diff) |
Merge #1752
1752: Always wrap blocks into block expressions r=flodiebold a=matklad
This way, things like function bodies are expressions, and we don't have to single them out
Co-authored-by: Aleksey Kladov <[email protected]>
Diffstat (limited to 'crates/ra_hir/src/expr.rs')
-rw-r--r-- | crates/ra_hir/src/expr.rs | 52 |
1 files changed, 26 insertions, 26 deletions
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs index c7530849b..5c95bed40 100644 --- a/crates/ra_hir/src/expr.rs +++ b/crates/ra_hir/src/expr.rs | |||
@@ -9,7 +9,7 @@ use ra_syntax::{ | |||
9 | self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, NameOwner, | 9 | self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, NameOwner, |
10 | TypeAscriptionOwner, | 10 | TypeAscriptionOwner, |
11 | }, | 11 | }, |
12 | AstNode, AstPtr, SyntaxNodePtr, | 12 | AstNode, AstPtr, |
13 | }; | 13 | }; |
14 | use test_utils::tested_by; | 14 | use test_utils::tested_by; |
15 | 15 | ||
@@ -56,13 +56,14 @@ pub struct Body { | |||
56 | /// file, so that we don't recompute types whenever some whitespace is typed. | 56 | /// file, so that we don't recompute types whenever some whitespace is typed. |
57 | #[derive(Default, Debug, Eq, PartialEq)] | 57 | #[derive(Default, Debug, Eq, PartialEq)] |
58 | pub struct BodySourceMap { | 58 | pub struct BodySourceMap { |
59 | expr_map: FxHashMap<SyntaxNodePtr, ExprId>, | 59 | expr_map: FxHashMap<ExprPtr, ExprId>, |
60 | expr_map_back: ArenaMap<ExprId, SyntaxNodePtr>, | 60 | expr_map_back: ArenaMap<ExprId, ExprPtr>, |
61 | pat_map: FxHashMap<PatPtr, PatId>, | 61 | pat_map: FxHashMap<PatPtr, PatId>, |
62 | pat_map_back: ArenaMap<PatId, PatPtr>, | 62 | pat_map_back: ArenaMap<PatId, PatPtr>, |
63 | field_map: FxHashMap<(ExprId, usize), AstPtr<ast::RecordField>>, | 63 | field_map: FxHashMap<(ExprId, usize), AstPtr<ast::RecordField>>, |
64 | } | 64 | } |
65 | 65 | ||
66 | type ExprPtr = Either<AstPtr<ast::Expr>, AstPtr<ast::RecordField>>; | ||
66 | type PatPtr = Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>; | 67 | type PatPtr = Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>; |
67 | 68 | ||
68 | impl Body { | 69 | impl Body { |
@@ -128,16 +129,12 @@ impl Index<PatId> for Body { | |||
128 | } | 129 | } |
129 | 130 | ||
130 | impl BodySourceMap { | 131 | impl BodySourceMap { |
131 | pub(crate) fn expr_syntax(&self, expr: ExprId) -> Option<SyntaxNodePtr> { | 132 | pub(crate) fn expr_syntax(&self, expr: ExprId) -> Option<ExprPtr> { |
132 | self.expr_map_back.get(expr).cloned() | 133 | self.expr_map_back.get(expr).cloned() |
133 | } | 134 | } |
134 | 135 | ||
135 | pub(crate) fn syntax_expr(&self, ptr: SyntaxNodePtr) -> Option<ExprId> { | ||
136 | self.expr_map.get(&ptr).cloned() | ||
137 | } | ||
138 | |||
139 | pub(crate) fn node_expr(&self, node: &ast::Expr) -> Option<ExprId> { | 136 | pub(crate) fn node_expr(&self, node: &ast::Expr) -> Option<ExprId> { |
140 | self.expr_map.get(&SyntaxNodePtr::new(node.syntax())).cloned() | 137 | self.expr_map.get(&Either::A(AstPtr::new(node))).cloned() |
141 | } | 138 | } |
142 | 139 | ||
143 | pub(crate) fn pat_syntax(&self, pat: PatId) -> Option<PatPtr> { | 140 | pub(crate) fn pat_syntax(&self, pat: PatId) -> Option<PatPtr> { |
@@ -575,11 +572,12 @@ where | |||
575 | current_file_id: file_id, | 572 | current_file_id: file_id, |
576 | } | 573 | } |
577 | } | 574 | } |
578 | fn alloc_expr(&mut self, expr: Expr, syntax_ptr: SyntaxNodePtr) -> ExprId { | 575 | fn alloc_expr(&mut self, expr: Expr, ptr: AstPtr<ast::Expr>) -> ExprId { |
576 | let ptr = Either::A(ptr); | ||
579 | let id = self.exprs.alloc(expr); | 577 | let id = self.exprs.alloc(expr); |
580 | if self.current_file_id == self.original_file_id { | 578 | if self.current_file_id == self.original_file_id { |
581 | self.source_map.expr_map.insert(syntax_ptr, id); | 579 | self.source_map.expr_map.insert(ptr, id); |
582 | self.source_map.expr_map_back.insert(id, syntax_ptr); | 580 | self.source_map.expr_map_back.insert(id, ptr); |
583 | } | 581 | } |
584 | id | 582 | id |
585 | } | 583 | } |
@@ -601,7 +599,7 @@ where | |||
601 | } | 599 | } |
602 | 600 | ||
603 | fn collect_expr(&mut self, expr: ast::Expr) -> ExprId { | 601 | fn collect_expr(&mut self, expr: ast::Expr) -> ExprId { |
604 | let syntax_ptr = SyntaxNodePtr::new(expr.syntax()); | 602 | let syntax_ptr = AstPtr::new(&expr); |
605 | match expr { | 603 | match expr { |
606 | ast::Expr::IfExpr(e) => { | 604 | ast::Expr::IfExpr(e) => { |
607 | let then_branch = self.collect_block_opt(e.then_branch()); | 605 | let then_branch = self.collect_block_opt(e.then_branch()); |
@@ -640,10 +638,10 @@ where | |||
640 | self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr) | 638 | self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr) |
641 | } | 639 | } |
642 | ast::Expr::TryBlockExpr(e) => { | 640 | ast::Expr::TryBlockExpr(e) => { |
643 | let body = self.collect_block_opt(e.block()); | 641 | let body = self.collect_block_opt(e.body()); |
644 | self.alloc_expr(Expr::TryBlock { body }, syntax_ptr) | 642 | self.alloc_expr(Expr::TryBlock { body }, syntax_ptr) |
645 | } | 643 | } |
646 | ast::Expr::BlockExpr(e) => self.collect_block_opt(e.block()), | 644 | ast::Expr::BlockExpr(e) => self.collect_block(e), |
647 | ast::Expr::LoopExpr(e) => { | 645 | ast::Expr::LoopExpr(e) => { |
648 | let body = self.collect_block_opt(e.loop_body()); | 646 | let body = self.collect_block_opt(e.loop_body()); |
649 | self.alloc_expr(Expr::Loop { body }, syntax_ptr) | 647 | self.alloc_expr(Expr::Loop { body }, syntax_ptr) |
@@ -739,7 +737,7 @@ where | |||
739 | ast::Expr::ParenExpr(e) => { | 737 | ast::Expr::ParenExpr(e) => { |
740 | let inner = self.collect_expr_opt(e.expr()); | 738 | let inner = self.collect_expr_opt(e.expr()); |
741 | // make the paren expr point to the inner expression as well | 739 | // make the paren expr point to the inner expression as well |
742 | self.source_map.expr_map.insert(syntax_ptr, inner); | 740 | self.source_map.expr_map.insert(Either::A(syntax_ptr), inner); |
743 | inner | 741 | inner |
744 | } | 742 | } |
745 | ast::Expr::ReturnExpr(e) => { | 743 | ast::Expr::ReturnExpr(e) => { |
@@ -763,12 +761,9 @@ where | |||
763 | } else if let Some(nr) = field.name_ref() { | 761 | } else if let Some(nr) = field.name_ref() { |
764 | // field shorthand | 762 | // field shorthand |
765 | let id = self.exprs.alloc(Expr::Path(Path::from_name_ref(&nr))); | 763 | let id = self.exprs.alloc(Expr::Path(Path::from_name_ref(&nr))); |
766 | self.source_map | 764 | let ptr = Either::B(AstPtr::new(&field)); |
767 | .expr_map | 765 | self.source_map.expr_map.insert(ptr, id); |
768 | .insert(SyntaxNodePtr::new(nr.syntax()), id); | 766 | self.source_map.expr_map_back.insert(id, ptr); |
769 | self.source_map | ||
770 | .expr_map_back | ||
771 | .insert(id, SyntaxNodePtr::new(nr.syntax())); | ||
772 | id | 767 | id |
773 | } else { | 768 | } else { |
774 | self.exprs.alloc(Expr::Missing) | 769 | self.exprs.alloc(Expr::Missing) |
@@ -942,7 +937,12 @@ where | |||
942 | } | 937 | } |
943 | } | 938 | } |
944 | 939 | ||
945 | fn collect_block(&mut self, block: ast::Block) -> ExprId { | 940 | fn collect_block(&mut self, expr: ast::BlockExpr) -> ExprId { |
941 | let syntax_node_ptr = AstPtr::new(&expr.clone().into()); | ||
942 | let block = match expr.block() { | ||
943 | Some(block) => block, | ||
944 | None => return self.alloc_expr(Expr::Missing, syntax_node_ptr), | ||
945 | }; | ||
946 | let statements = block | 946 | let statements = block |
947 | .statements() | 947 | .statements() |
948 | .map(|s| match s { | 948 | .map(|s| match s { |
@@ -956,11 +956,11 @@ where | |||
956 | }) | 956 | }) |
957 | .collect(); | 957 | .collect(); |
958 | let tail = block.expr().map(|e| self.collect_expr(e)); | 958 | let tail = block.expr().map(|e| self.collect_expr(e)); |
959 | self.alloc_expr(Expr::Block { statements, tail }, SyntaxNodePtr::new(block.syntax())) | 959 | self.alloc_expr(Expr::Block { statements, tail }, syntax_node_ptr) |
960 | } | 960 | } |
961 | 961 | ||
962 | fn collect_block_opt(&mut self, block: Option<ast::Block>) -> ExprId { | 962 | fn collect_block_opt(&mut self, expr: Option<ast::BlockExpr>) -> ExprId { |
963 | if let Some(block) = block { | 963 | if let Some(block) = expr { |
964 | self.collect_block(block) | 964 | self.collect_block(block) |
965 | } else { | 965 | } else { |
966 | self.exprs.alloc(Expr::Missing) | 966 | self.exprs.alloc(Expr::Missing) |