diff options
author | Seivan Heidari <[email protected]> | 2019-11-14 22:20:27 +0000 |
---|---|---|
committer | Seivan Heidari <[email protected]> | 2019-11-14 22:20:27 +0000 |
commit | c622413bc72ea56d5f62a16788d897cb61eca948 (patch) | |
tree | 9de3dbe8b5c935ed168efac4e70770e54fbe0714 /crates/ra_hir_def/src/body | |
parent | 0525778a3ad590492b51cc11085d815f9bb8f92b (diff) | |
parent | bbb022d3999b3038549ec6c309efb065231c896a (diff) |
Merge branch 'master' of https://github.com/rust-analyzer/rust-analyzer into feature/themes
Diffstat (limited to 'crates/ra_hir_def/src/body')
-rw-r--r-- | crates/ra_hir_def/src/body/lower.rs | 90 | ||||
-rw-r--r-- | crates/ra_hir_def/src/body/scope.rs | 165 |
2 files changed, 192 insertions, 63 deletions
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs index 2aa863c9e..a5bb60e85 100644 --- a/crates/ra_hir_def/src/body/lower.rs +++ b/crates/ra_hir_def/src/body/lower.rs | |||
@@ -2,9 +2,7 @@ | |||
2 | 2 | ||
3 | use hir_expand::{ | 3 | use hir_expand::{ |
4 | either::Either, | 4 | either::Either, |
5 | hygiene::Hygiene, | ||
6 | name::{self, AsName, Name}, | 5 | name::{self, AsName, Name}, |
7 | AstId, HirFileId, MacroCallLoc, MacroFileKind, Source, | ||
8 | }; | 6 | }; |
9 | use ra_arena::Arena; | 7 | use ra_arena::Arena; |
10 | use ra_syntax::{ | 8 | use ra_syntax::{ |
@@ -16,7 +14,7 @@ use ra_syntax::{ | |||
16 | }; | 14 | }; |
17 | 15 | ||
18 | use crate::{ | 16 | use crate::{ |
19 | body::{Body, BodySourceMap, MacroResolver, PatPtr}, | 17 | body::{Body, BodySourceMap, Expander, PatPtr}, |
20 | builtin_type::{BuiltinFloat, BuiltinInt}, | 18 | builtin_type::{BuiltinFloat, BuiltinInt}, |
21 | db::DefDatabase2, | 19 | db::DefDatabase2, |
22 | expr::{ | 20 | expr::{ |
@@ -30,16 +28,13 @@ use crate::{ | |||
30 | 28 | ||
31 | pub(super) fn lower( | 29 | pub(super) fn lower( |
32 | db: &impl DefDatabase2, | 30 | db: &impl DefDatabase2, |
33 | resolver: MacroResolver, | 31 | expander: Expander, |
34 | file_id: HirFileId, | ||
35 | params: Option<ast::ParamList>, | 32 | params: Option<ast::ParamList>, |
36 | body: Option<ast::Expr>, | 33 | body: Option<ast::Expr>, |
37 | ) -> (Body, BodySourceMap) { | 34 | ) -> (Body, BodySourceMap) { |
38 | ExprCollector { | 35 | ExprCollector { |
39 | resolver, | 36 | expander, |
40 | db, | 37 | db, |
41 | original_file_id: file_id, | ||
42 | current_file_id: file_id, | ||
43 | source_map: BodySourceMap::default(), | 38 | source_map: BodySourceMap::default(), |
44 | body: Body { | 39 | body: Body { |
45 | exprs: Arena::default(), | 40 | exprs: Arena::default(), |
@@ -53,9 +48,7 @@ pub(super) fn lower( | |||
53 | 48 | ||
54 | struct ExprCollector<DB> { | 49 | struct ExprCollector<DB> { |
55 | db: DB, | 50 | db: DB, |
56 | resolver: MacroResolver, | 51 | expander: Expander, |
57 | original_file_id: HirFileId, | ||
58 | current_file_id: HirFileId, | ||
59 | 52 | ||
60 | body: Body, | 53 | body: Body, |
61 | source_map: BodySourceMap, | 54 | source_map: BodySourceMap, |
@@ -101,12 +94,9 @@ where | |||
101 | fn alloc_expr(&mut self, expr: Expr, ptr: AstPtr<ast::Expr>) -> ExprId { | 94 | fn alloc_expr(&mut self, expr: Expr, ptr: AstPtr<ast::Expr>) -> ExprId { |
102 | let ptr = Either::A(ptr); | 95 | let ptr = Either::A(ptr); |
103 | let id = self.body.exprs.alloc(expr); | 96 | let id = self.body.exprs.alloc(expr); |
104 | if self.current_file_id == self.original_file_id { | 97 | let src = self.expander.to_source(ptr); |
105 | self.source_map.expr_map.insert(ptr, id); | 98 | self.source_map.expr_map.insert(src, id); |
106 | } | 99 | self.source_map.expr_map_back.insert(id, src); |
107 | self.source_map | ||
108 | .expr_map_back | ||
109 | .insert(id, Source { file_id: self.current_file_id, ast: ptr }); | ||
110 | id | 100 | id |
111 | } | 101 | } |
112 | // desugared exprs don't have ptr, that's wrong and should be fixed | 102 | // desugared exprs don't have ptr, that's wrong and should be fixed |
@@ -117,20 +107,16 @@ where | |||
117 | fn alloc_expr_field_shorthand(&mut self, expr: Expr, ptr: AstPtr<ast::RecordField>) -> ExprId { | 107 | fn alloc_expr_field_shorthand(&mut self, expr: Expr, ptr: AstPtr<ast::RecordField>) -> ExprId { |
118 | let ptr = Either::B(ptr); | 108 | let ptr = Either::B(ptr); |
119 | let id = self.body.exprs.alloc(expr); | 109 | let id = self.body.exprs.alloc(expr); |
120 | if self.current_file_id == self.original_file_id { | 110 | let src = self.expander.to_source(ptr); |
121 | self.source_map.expr_map.insert(ptr, id); | 111 | self.source_map.expr_map.insert(src, id); |
122 | } | 112 | self.source_map.expr_map_back.insert(id, src); |
123 | self.source_map | ||
124 | .expr_map_back | ||
125 | .insert(id, Source { file_id: self.current_file_id, ast: ptr }); | ||
126 | id | 113 | id |
127 | } | 114 | } |
128 | fn alloc_pat(&mut self, pat: Pat, ptr: PatPtr) -> PatId { | 115 | fn alloc_pat(&mut self, pat: Pat, ptr: PatPtr) -> PatId { |
129 | let id = self.body.pats.alloc(pat); | 116 | let id = self.body.pats.alloc(pat); |
130 | if self.current_file_id == self.original_file_id { | 117 | let src = self.expander.to_source(ptr); |
131 | self.source_map.pat_map.insert(ptr, id); | 118 | self.source_map.pat_map.insert(src, id); |
132 | } | 119 | self.source_map.pat_map_back.insert(id, src); |
133 | self.source_map.pat_map_back.insert(id, Source { file_id: self.current_file_id, ast: ptr }); | ||
134 | id | 120 | id |
135 | } | 121 | } |
136 | 122 | ||
@@ -272,7 +258,7 @@ where | |||
272 | ast::Expr::PathExpr(e) => { | 258 | ast::Expr::PathExpr(e) => { |
273 | let path = e | 259 | let path = e |
274 | .path() | 260 | .path() |
275 | .and_then(|path| self.parse_path(path)) | 261 | .and_then(|path| self.expander.parse_path(path)) |
276 | .map(Expr::Path) | 262 | .map(Expr::Path) |
277 | .unwrap_or(Expr::Missing); | 263 | .unwrap_or(Expr::Missing); |
278 | self.alloc_expr(path, syntax_ptr) | 264 | self.alloc_expr(path, syntax_ptr) |
@@ -288,7 +274,8 @@ where | |||
288 | ast::Expr::ParenExpr(e) => { | 274 | ast::Expr::ParenExpr(e) => { |
289 | let inner = self.collect_expr_opt(e.expr()); | 275 | let inner = self.collect_expr_opt(e.expr()); |
290 | // make the paren expr point to the inner expression as well | 276 | // make the paren expr point to the inner expression as well |
291 | self.source_map.expr_map.insert(Either::A(syntax_ptr), inner); | 277 | let src = self.expander.to_source(Either::A(syntax_ptr)); |
278 | self.source_map.expr_map.insert(src, inner); | ||
292 | inner | 279 | inner |
293 | } | 280 | } |
294 | ast::Expr::ReturnExpr(e) => { | 281 | ast::Expr::ReturnExpr(e) => { |
@@ -296,7 +283,7 @@ where | |||
296 | self.alloc_expr(Expr::Return { expr }, syntax_ptr) | 283 | self.alloc_expr(Expr::Return { expr }, syntax_ptr) |
297 | } | 284 | } |
298 | ast::Expr::RecordLit(e) => { | 285 | ast::Expr::RecordLit(e) => { |
299 | let path = e.path().and_then(|path| self.parse_path(path)); | 286 | let path = e.path().and_then(|path| self.expander.parse_path(path)); |
300 | let mut field_ptrs = Vec::new(); | 287 | let mut field_ptrs = Vec::new(); |
301 | let record_lit = if let Some(nfl) = e.record_field_list() { | 288 | let record_lit = if let Some(nfl) = e.record_field_list() { |
302 | let fields = nfl | 289 | let fields = nfl |
@@ -443,32 +430,14 @@ where | |||
443 | // FIXME implement HIR for these: | 430 | // FIXME implement HIR for these: |
444 | ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr), | 431 | ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr), |
445 | ast::Expr::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr), | 432 | ast::Expr::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr), |
446 | ast::Expr::MacroCall(e) => { | 433 | ast::Expr::MacroCall(e) => match self.expander.enter_expand(self.db, e) { |
447 | let ast_id = AstId::new( | 434 | Some((mark, expansion)) => { |
448 | self.current_file_id, | 435 | let id = self.collect_expr(expansion); |
449 | self.db.ast_id_map(self.current_file_id).ast_id(&e), | 436 | self.expander.exit(self.db, mark); |
450 | ); | 437 | id |
451 | |||
452 | if let Some(path) = e.path().and_then(|path| self.parse_path(path)) { | ||
453 | if let Some(def) = self.resolver.resolve_path_as_macro(self.db, &path) { | ||
454 | let call_id = self.db.intern_macro(MacroCallLoc { def, ast_id }); | ||
455 | let file_id = call_id.as_file(MacroFileKind::Expr); | ||
456 | if let Some(node) = self.db.parse_or_expand(file_id) { | ||
457 | if let Some(expr) = ast::Expr::cast(node) { | ||
458 | log::debug!("macro expansion {:#?}", expr.syntax()); | ||
459 | let old_file_id = | ||
460 | std::mem::replace(&mut self.current_file_id, file_id); | ||
461 | let id = self.collect_expr(expr); | ||
462 | self.current_file_id = old_file_id; | ||
463 | return id; | ||
464 | } | ||
465 | } | ||
466 | } | ||
467 | } | 438 | } |
468 | // FIXME: Instead of just dropping the error from expansion | 439 | None => self.alloc_expr(Expr::Missing, syntax_ptr), |
469 | // report it | 440 | }, |
470 | self.alloc_expr(Expr::Missing, syntax_ptr) | ||
471 | } | ||
472 | } | 441 | } |
473 | } | 442 | } |
474 | 443 | ||
@@ -519,7 +488,7 @@ where | |||
519 | Pat::Bind { name, mode: annotation, subpat } | 488 | Pat::Bind { name, mode: annotation, subpat } |
520 | } | 489 | } |
521 | ast::Pat::TupleStructPat(p) => { | 490 | ast::Pat::TupleStructPat(p) => { |
522 | let path = p.path().and_then(|path| self.parse_path(path)); | 491 | let path = p.path().and_then(|path| self.expander.parse_path(path)); |
523 | let args = p.args().map(|p| self.collect_pat(p)).collect(); | 492 | let args = p.args().map(|p| self.collect_pat(p)).collect(); |
524 | Pat::TupleStruct { path, args } | 493 | Pat::TupleStruct { path, args } |
525 | } | 494 | } |
@@ -529,7 +498,7 @@ where | |||
529 | Pat::Ref { pat, mutability } | 498 | Pat::Ref { pat, mutability } |
530 | } | 499 | } |
531 | ast::Pat::PathPat(p) => { | 500 | ast::Pat::PathPat(p) => { |
532 | let path = p.path().and_then(|path| self.parse_path(path)); | 501 | let path = p.path().and_then(|path| self.expander.parse_path(path)); |
533 | path.map(Pat::Path).unwrap_or(Pat::Missing) | 502 | path.map(Pat::Path).unwrap_or(Pat::Missing) |
534 | } | 503 | } |
535 | ast::Pat::TuplePat(p) => { | 504 | ast::Pat::TuplePat(p) => { |
@@ -538,7 +507,7 @@ where | |||
538 | } | 507 | } |
539 | ast::Pat::PlaceholderPat(_) => Pat::Wild, | 508 | ast::Pat::PlaceholderPat(_) => Pat::Wild, |
540 | ast::Pat::RecordPat(p) => { | 509 | ast::Pat::RecordPat(p) => { |
541 | let path = p.path().and_then(|path| self.parse_path(path)); | 510 | let path = p.path().and_then(|path| self.expander.parse_path(path)); |
542 | let record_field_pat_list = | 511 | let record_field_pat_list = |
543 | p.record_field_pat_list().expect("every struct should have a field list"); | 512 | p.record_field_pat_list().expect("every struct should have a field list"); |
544 | let mut fields: Vec<_> = record_field_pat_list | 513 | let mut fields: Vec<_> = record_field_pat_list |
@@ -579,11 +548,6 @@ where | |||
579 | self.missing_pat() | 548 | self.missing_pat() |
580 | } | 549 | } |
581 | } | 550 | } |
582 | |||
583 | fn parse_path(&mut self, path: ast::Path) -> Option<Path> { | ||
584 | let hygiene = Hygiene::new(self.db, self.current_file_id); | ||
585 | Path::from_src(path, &hygiene) | ||
586 | } | ||
587 | } | 551 | } |
588 | 552 | ||
589 | impl From<ast::BinOp> for BinaryOp { | 553 | impl From<ast::BinOp> for BinaryOp { |
diff --git a/crates/ra_hir_def/src/body/scope.rs b/crates/ra_hir_def/src/body/scope.rs new file mode 100644 index 000000000..09a39e721 --- /dev/null +++ b/crates/ra_hir_def/src/body/scope.rs | |||
@@ -0,0 +1,165 @@ | |||
1 | //! FIXME: write short doc here | ||
2 | use std::sync::Arc; | ||
3 | |||
4 | use hir_expand::name::Name; | ||
5 | use ra_arena::{impl_arena_id, Arena, RawId}; | ||
6 | use rustc_hash::FxHashMap; | ||
7 | |||
8 | use crate::{ | ||
9 | body::Body, | ||
10 | db::DefDatabase2, | ||
11 | expr::{Expr, ExprId, Pat, PatId, Statement}, | ||
12 | DefWithBodyId, | ||
13 | }; | ||
14 | |||
15 | #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] | ||
16 | pub struct ScopeId(RawId); | ||
17 | impl_arena_id!(ScopeId); | ||
18 | |||
19 | #[derive(Debug, PartialEq, Eq)] | ||
20 | pub struct ExprScopes { | ||
21 | scopes: Arena<ScopeId, ScopeData>, | ||
22 | scope_by_expr: FxHashMap<ExprId, ScopeId>, | ||
23 | } | ||
24 | |||
25 | #[derive(Debug, PartialEq, Eq)] | ||
26 | pub struct ScopeEntry { | ||
27 | name: Name, | ||
28 | pat: PatId, | ||
29 | } | ||
30 | |||
31 | impl ScopeEntry { | ||
32 | pub fn name(&self) -> &Name { | ||
33 | &self.name | ||
34 | } | ||
35 | |||
36 | pub fn pat(&self) -> PatId { | ||
37 | self.pat | ||
38 | } | ||
39 | } | ||
40 | |||
41 | #[derive(Debug, PartialEq, Eq)] | ||
42 | pub struct ScopeData { | ||
43 | parent: Option<ScopeId>, | ||
44 | entries: Vec<ScopeEntry>, | ||
45 | } | ||
46 | |||
47 | impl ExprScopes { | ||
48 | pub(crate) fn expr_scopes_query(db: &impl DefDatabase2, def: DefWithBodyId) -> Arc<ExprScopes> { | ||
49 | let body = db.body(def); | ||
50 | Arc::new(ExprScopes::new(&*body)) | ||
51 | } | ||
52 | |||
53 | fn new(body: &Body) -> ExprScopes { | ||
54 | let mut scopes = | ||
55 | ExprScopes { scopes: Arena::default(), scope_by_expr: FxHashMap::default() }; | ||
56 | let root = scopes.root_scope(); | ||
57 | scopes.add_params_bindings(body, root, body.params()); | ||
58 | compute_expr_scopes(body.body_expr(), body, &mut scopes, root); | ||
59 | scopes | ||
60 | } | ||
61 | |||
62 | pub fn entries(&self, scope: ScopeId) -> &[ScopeEntry] { | ||
63 | &self.scopes[scope].entries | ||
64 | } | ||
65 | |||
66 | pub fn scope_chain(&self, scope: Option<ScopeId>) -> impl Iterator<Item = ScopeId> + '_ { | ||
67 | std::iter::successors(scope, move |&scope| self.scopes[scope].parent) | ||
68 | } | ||
69 | |||
70 | pub fn scope_for(&self, expr: ExprId) -> Option<ScopeId> { | ||
71 | self.scope_by_expr.get(&expr).copied() | ||
72 | } | ||
73 | |||
74 | pub fn scope_by_expr(&self) -> &FxHashMap<ExprId, ScopeId> { | ||
75 | &self.scope_by_expr | ||
76 | } | ||
77 | |||
78 | fn root_scope(&mut self) -> ScopeId { | ||
79 | self.scopes.alloc(ScopeData { parent: None, entries: vec![] }) | ||
80 | } | ||
81 | |||
82 | fn new_scope(&mut self, parent: ScopeId) -> ScopeId { | ||
83 | self.scopes.alloc(ScopeData { parent: Some(parent), entries: vec![] }) | ||
84 | } | ||
85 | |||
86 | fn add_bindings(&mut self, body: &Body, scope: ScopeId, pat: PatId) { | ||
87 | match &body[pat] { | ||
88 | Pat::Bind { name, .. } => { | ||
89 | // bind can have a sub pattern, but it's actually not allowed | ||
90 | // to bind to things in there | ||
91 | let entry = ScopeEntry { name: name.clone(), pat }; | ||
92 | self.scopes[scope].entries.push(entry) | ||
93 | } | ||
94 | p => p.walk_child_pats(|pat| self.add_bindings(body, scope, pat)), | ||
95 | } | ||
96 | } | ||
97 | |||
98 | fn add_params_bindings(&mut self, body: &Body, scope: ScopeId, params: &[PatId]) { | ||
99 | params.iter().for_each(|pat| self.add_bindings(body, scope, *pat)); | ||
100 | } | ||
101 | |||
102 | fn set_scope(&mut self, node: ExprId, scope: ScopeId) { | ||
103 | self.scope_by_expr.insert(node, scope); | ||
104 | } | ||
105 | } | ||
106 | |||
107 | fn compute_block_scopes( | ||
108 | statements: &[Statement], | ||
109 | tail: Option<ExprId>, | ||
110 | body: &Body, | ||
111 | scopes: &mut ExprScopes, | ||
112 | mut scope: ScopeId, | ||
113 | ) { | ||
114 | for stmt in statements { | ||
115 | match stmt { | ||
116 | Statement::Let { pat, initializer, .. } => { | ||
117 | if let Some(expr) = initializer { | ||
118 | scopes.set_scope(*expr, scope); | ||
119 | compute_expr_scopes(*expr, body, scopes, scope); | ||
120 | } | ||
121 | scope = scopes.new_scope(scope); | ||
122 | scopes.add_bindings(body, scope, *pat); | ||
123 | } | ||
124 | Statement::Expr(expr) => { | ||
125 | scopes.set_scope(*expr, scope); | ||
126 | compute_expr_scopes(*expr, body, scopes, scope); | ||
127 | } | ||
128 | } | ||
129 | } | ||
130 | if let Some(expr) = tail { | ||
131 | compute_expr_scopes(expr, body, scopes, scope); | ||
132 | } | ||
133 | } | ||
134 | |||
135 | fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut ExprScopes, scope: ScopeId) { | ||
136 | scopes.set_scope(expr, scope); | ||
137 | match &body[expr] { | ||
138 | Expr::Block { statements, tail } => { | ||
139 | compute_block_scopes(&statements, *tail, body, scopes, scope); | ||
140 | } | ||
141 | Expr::For { iterable, pat, body: body_expr } => { | ||
142 | compute_expr_scopes(*iterable, body, scopes, scope); | ||
143 | let scope = scopes.new_scope(scope); | ||
144 | scopes.add_bindings(body, scope, *pat); | ||
145 | compute_expr_scopes(*body_expr, body, scopes, scope); | ||
146 | } | ||
147 | Expr::Lambda { args, body: body_expr, .. } => { | ||
148 | let scope = scopes.new_scope(scope); | ||
149 | scopes.add_params_bindings(body, scope, &args); | ||
150 | compute_expr_scopes(*body_expr, body, scopes, scope); | ||
151 | } | ||
152 | Expr::Match { expr, arms } => { | ||
153 | compute_expr_scopes(*expr, body, scopes, scope); | ||
154 | for arm in arms { | ||
155 | let scope = scopes.new_scope(scope); | ||
156 | for pat in &arm.pats { | ||
157 | scopes.add_bindings(body, scope, *pat); | ||
158 | } | ||
159 | scopes.set_scope(arm.expr, scope); | ||
160 | compute_expr_scopes(arm.expr, body, scopes, scope); | ||
161 | } | ||
162 | } | ||
163 | e => e.walk_child_exprs(|e| compute_expr_scopes(e, body, scopes, scope)), | ||
164 | }; | ||
165 | } | ||