Revert "Use block_def_map in body lowering"
This commit is contained in:
parent
3c1fcfcd1b
commit
7202ce6c96
10 changed files with 96 additions and 161 deletions
|
@ -46,7 +46,7 @@ pub(crate) struct CfgExpander {
|
||||||
|
|
||||||
pub(crate) struct Expander {
|
pub(crate) struct Expander {
|
||||||
cfg_expander: CfgExpander,
|
cfg_expander: CfgExpander,
|
||||||
def_map: Arc<DefMap>,
|
crate_def_map: Arc<DefMap>,
|
||||||
current_file_id: HirFileId,
|
current_file_id: HirFileId,
|
||||||
ast_id_map: Arc<AstIdMap>,
|
ast_id_map: Arc<AstIdMap>,
|
||||||
module: ModuleId,
|
module: ModuleId,
|
||||||
|
@ -91,7 +91,7 @@ impl Expander {
|
||||||
let ast_id_map = db.ast_id_map(current_file_id);
|
let ast_id_map = db.ast_id_map(current_file_id);
|
||||||
Expander {
|
Expander {
|
||||||
cfg_expander,
|
cfg_expander,
|
||||||
def_map: crate_def_map,
|
crate_def_map,
|
||||||
current_file_id,
|
current_file_id,
|
||||||
ast_id_map,
|
ast_id_map,
|
||||||
module,
|
module,
|
||||||
|
@ -102,6 +102,7 @@ impl Expander {
|
||||||
pub(crate) fn enter_expand<T: ast::AstNode>(
|
pub(crate) fn enter_expand<T: ast::AstNode>(
|
||||||
&mut self,
|
&mut self,
|
||||||
db: &dyn DefDatabase,
|
db: &dyn DefDatabase,
|
||||||
|
local_scope: Option<&ItemScope>,
|
||||||
macro_call: ast::MacroCall,
|
macro_call: ast::MacroCall,
|
||||||
) -> ExpandResult<Option<(Mark, T)>> {
|
) -> ExpandResult<Option<(Mark, T)>> {
|
||||||
if self.recursion_limit + 1 > EXPANSION_RECURSION_LIMIT {
|
if self.recursion_limit + 1 > EXPANSION_RECURSION_LIMIT {
|
||||||
|
@ -111,12 +112,18 @@ impl Expander {
|
||||||
|
|
||||||
let macro_call = InFile::new(self.current_file_id, ¯o_call);
|
let macro_call = InFile::new(self.current_file_id, ¯o_call);
|
||||||
|
|
||||||
let resolver =
|
let resolver = |path: ModPath| -> Option<MacroDefId> {
|
||||||
|path: ModPath| -> Option<MacroDefId> { self.resolve_path_as_macro(db, &path) };
|
if let Some(local_scope) = local_scope {
|
||||||
|
if let Some(def) = path.as_ident().and_then(|n| local_scope.get_legacy_macro(n)) {
|
||||||
|
return Some(def);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
self.resolve_path_as_macro(db, &path)
|
||||||
|
};
|
||||||
|
|
||||||
let mut err = None;
|
let mut err = None;
|
||||||
let call_id =
|
let call_id =
|
||||||
macro_call.as_call_id_with_errors(db, self.def_map.krate(), resolver, &mut |e| {
|
macro_call.as_call_id_with_errors(db, self.crate_def_map.krate(), resolver, &mut |e| {
|
||||||
err.get_or_insert(e);
|
err.get_or_insert(e);
|
||||||
});
|
});
|
||||||
let call_id = match call_id {
|
let call_id = match call_id {
|
||||||
|
@ -197,7 +204,7 @@ impl Expander {
|
||||||
}
|
}
|
||||||
|
|
||||||
fn resolve_path_as_macro(&self, db: &dyn DefDatabase, path: &ModPath) -> Option<MacroDefId> {
|
fn resolve_path_as_macro(&self, db: &dyn DefDatabase, path: &ModPath) -> Option<MacroDefId> {
|
||||||
self.def_map
|
self.crate_def_map
|
||||||
.resolve_path(db, self.module.local_id, path, BuiltinShadowMode::Other)
|
.resolve_path(db, self.module.local_id, path, BuiltinShadowMode::Other)
|
||||||
.0
|
.0
|
||||||
.take_macros()
|
.take_macros()
|
||||||
|
|
|
@ -1,7 +1,7 @@
|
||||||
//! Transforms `ast::Expr` into an equivalent `hir_def::expr::Expr`
|
//! Transforms `ast::Expr` into an equivalent `hir_def::expr::Expr`
|
||||||
//! representation.
|
//! representation.
|
||||||
|
|
||||||
use std::{any::type_name, mem, sync::Arc};
|
use std::{any::type_name, sync::Arc};
|
||||||
|
|
||||||
use either::Either;
|
use either::Either;
|
||||||
use hir_expand::{
|
use hir_expand::{
|
||||||
|
@ -36,8 +36,8 @@ use crate::{
|
||||||
item_tree::{ItemTree, ItemTreeId, ItemTreeNode},
|
item_tree::{ItemTree, ItemTreeId, ItemTreeNode},
|
||||||
path::{GenericArgs, Path},
|
path::{GenericArgs, Path},
|
||||||
type_ref::{Mutability, Rawness, TypeRef},
|
type_ref::{Mutability, Rawness, TypeRef},
|
||||||
AdtId, BlockLoc, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern,
|
AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId,
|
||||||
ModuleDefId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
|
StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
|
||||||
};
|
};
|
||||||
|
|
||||||
use super::{diagnostics::BodyDiagnostic, ExprSource, PatSource};
|
use super::{diagnostics::BodyDiagnostic, ExprSource, PatSource};
|
||||||
|
@ -152,8 +152,8 @@ impl ExprCollector<'_> {
|
||||||
fn alloc_expr_desugared(&mut self, expr: Expr) -> ExprId {
|
fn alloc_expr_desugared(&mut self, expr: Expr) -> ExprId {
|
||||||
self.make_expr(expr, Err(SyntheticSyntax))
|
self.make_expr(expr, Err(SyntheticSyntax))
|
||||||
}
|
}
|
||||||
fn unit(&mut self) -> ExprId {
|
fn empty_block(&mut self) -> ExprId {
|
||||||
self.alloc_expr_desugared(Expr::Tuple { exprs: Vec::new() })
|
self.alloc_expr_desugared(Expr::Block { statements: Vec::new(), tail: None, label: None })
|
||||||
}
|
}
|
||||||
fn missing_expr(&mut self) -> ExprId {
|
fn missing_expr(&mut self) -> ExprId {
|
||||||
self.alloc_expr_desugared(Expr::Missing)
|
self.alloc_expr_desugared(Expr::Missing)
|
||||||
|
@ -222,7 +222,7 @@ impl ExprCollector<'_> {
|
||||||
MatchArm { pat, expr: then_branch, guard: None },
|
MatchArm { pat, expr: then_branch, guard: None },
|
||||||
MatchArm {
|
MatchArm {
|
||||||
pat: placeholder_pat,
|
pat: placeholder_pat,
|
||||||
expr: else_branch.unwrap_or_else(|| self.unit()),
|
expr: else_branch.unwrap_or_else(|| self.empty_block()),
|
||||||
guard: None,
|
guard: None,
|
||||||
},
|
},
|
||||||
];
|
];
|
||||||
|
@ -561,7 +561,7 @@ impl ExprCollector<'_> {
|
||||||
let outer_file = self.expander.current_file_id;
|
let outer_file = self.expander.current_file_id;
|
||||||
|
|
||||||
let macro_call = self.expander.to_source(AstPtr::new(&e));
|
let macro_call = self.expander.to_source(AstPtr::new(&e));
|
||||||
let res = self.expander.enter_expand(self.db, e);
|
let res = self.expander.enter_expand(self.db, Some(&self.body.item_scope), e);
|
||||||
|
|
||||||
match &res.err {
|
match &res.err {
|
||||||
Some(ExpandError::UnresolvedProcMacro) => {
|
Some(ExpandError::UnresolvedProcMacro) => {
|
||||||
|
@ -697,27 +697,12 @@ impl ExprCollector<'_> {
|
||||||
}
|
}
|
||||||
|
|
||||||
fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId {
|
fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId {
|
||||||
let ast_id = self.expander.ast_id(&block);
|
let syntax_node_ptr = AstPtr::new(&block.clone().into());
|
||||||
let block_loc = BlockLoc { ast_id, module: self.expander.module };
|
|
||||||
let block_id = self.db.intern_block(block_loc);
|
|
||||||
let def_map = self.db.block_def_map(block_id);
|
|
||||||
let root = def_map.module_id(def_map.root());
|
|
||||||
let prev_def_map = mem::replace(&mut self.expander.def_map, def_map);
|
|
||||||
let prev_module = mem::replace(&mut self.expander.module, root);
|
|
||||||
|
|
||||||
self.collect_stmts_items(block.statements());
|
self.collect_stmts_items(block.statements());
|
||||||
let statements =
|
let statements =
|
||||||
block.statements().filter_map(|s| self.collect_stmt(s)).flatten().collect();
|
block.statements().filter_map(|s| self.collect_stmt(s)).flatten().collect();
|
||||||
let tail = block.tail_expr().map(|e| self.collect_expr(e));
|
let tail = block.tail_expr().map(|e| self.collect_expr(e));
|
||||||
let syntax_node_ptr = AstPtr::new(&block.clone().into());
|
self.alloc_expr(Expr::Block { statements, tail, label: None }, syntax_node_ptr)
|
||||||
let expr_id = self.alloc_expr(
|
|
||||||
Expr::Block { id: block_id, statements, tail, label: None },
|
|
||||||
syntax_node_ptr,
|
|
||||||
);
|
|
||||||
|
|
||||||
self.expander.def_map = prev_def_map;
|
|
||||||
self.expander.module = prev_module;
|
|
||||||
expr_id
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fn collect_stmts_items(&mut self, stmts: ast::AstChildren<ast::Stmt>) {
|
fn collect_stmts_items(&mut self, stmts: ast::AstChildren<ast::Stmt>) {
|
||||||
|
@ -847,7 +832,7 @@ impl ExprCollector<'_> {
|
||||||
if annotation == BindingAnnotation::Unannotated && subpat.is_none() {
|
if annotation == BindingAnnotation::Unannotated && subpat.is_none() {
|
||||||
// This could also be a single-segment path pattern. To
|
// This could also be a single-segment path pattern. To
|
||||||
// decide that, we need to try resolving the name.
|
// decide that, we need to try resolving the name.
|
||||||
let (resolved, _) = self.expander.def_map.resolve_path(
|
let (resolved, _) = self.expander.crate_def_map.resolve_path(
|
||||||
self.db,
|
self.db,
|
||||||
self.expander.module.local_id,
|
self.expander.module.local_id,
|
||||||
&name.clone().into(),
|
&name.clone().into(),
|
||||||
|
|
|
@ -1,10 +1,7 @@
|
||||||
mod block;
|
use base_db::{fixture::WithFixture, SourceDatabase};
|
||||||
|
|
||||||
use base_db::{fixture::WithFixture, FilePosition, SourceDatabase};
|
|
||||||
use expect_test::Expect;
|
|
||||||
use test_utils::mark;
|
use test_utils::mark;
|
||||||
|
|
||||||
use crate::{test_db::TestDB, BlockId, ModuleDefId};
|
use crate::{test_db::TestDB, ModuleDefId};
|
||||||
|
|
||||||
use super::*;
|
use super::*;
|
||||||
|
|
||||||
|
@ -34,115 +31,6 @@ fn check_diagnostics(ra_fixture: &str) {
|
||||||
db.check_diagnostics();
|
db.check_diagnostics();
|
||||||
}
|
}
|
||||||
|
|
||||||
fn block_def_map_at(ra_fixture: &str) -> Arc<DefMap> {
|
|
||||||
let (db, position) = crate::test_db::TestDB::with_position(ra_fixture);
|
|
||||||
|
|
||||||
let krate = db.crate_graph().iter().next().unwrap();
|
|
||||||
let def_map = db.crate_def_map(krate);
|
|
||||||
|
|
||||||
let mut block =
|
|
||||||
block_at_pos(&db, &def_map, position).expect("couldn't find enclosing function or block");
|
|
||||||
loop {
|
|
||||||
let def_map = db.block_def_map(block);
|
|
||||||
let new_block = block_at_pos(&db, &def_map, position);
|
|
||||||
match new_block {
|
|
||||||
Some(new_block) => {
|
|
||||||
assert_ne!(block, new_block);
|
|
||||||
block = new_block;
|
|
||||||
}
|
|
||||||
None => {
|
|
||||||
return def_map;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn block_at_pos(db: &dyn DefDatabase, def_map: &DefMap, position: FilePosition) -> Option<BlockId> {
|
|
||||||
let mut size = None;
|
|
||||||
let mut fn_def = None;
|
|
||||||
for (_, module) in def_map.modules() {
|
|
||||||
let file_id = module.definition_source(db).file_id;
|
|
||||||
if file_id != position.file_id.into() {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
let root = db.parse_or_expand(file_id).unwrap();
|
|
||||||
let ast_map = db.ast_id_map(file_id);
|
|
||||||
let item_tree = db.item_tree(file_id);
|
|
||||||
for decl in module.scope.declarations() {
|
|
||||||
if let ModuleDefId::FunctionId(it) = decl {
|
|
||||||
let ast = ast_map.get(item_tree[it.lookup(db).id.value].ast_id).to_node(&root);
|
|
||||||
let range = ast.syntax().text_range();
|
|
||||||
|
|
||||||
// Find the smallest (innermost) function containing the cursor.
|
|
||||||
if !range.contains(position.offset) {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
let new_size = match size {
|
|
||||||
None => range.len(),
|
|
||||||
Some(size) => {
|
|
||||||
if range.len() < size {
|
|
||||||
range.len()
|
|
||||||
} else {
|
|
||||||
size
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
if size != Some(new_size) {
|
|
||||||
size = Some(new_size);
|
|
||||||
fn_def = Some(it);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
let (body, source_map) = db.body_with_source_map(fn_def?.into());
|
|
||||||
|
|
||||||
// Now find the smallest encompassing block expression in the function body.
|
|
||||||
let mut size = None;
|
|
||||||
let mut block_id = None;
|
|
||||||
for (expr_id, expr) in body.exprs.iter() {
|
|
||||||
if let Expr::Block { id, .. } = expr {
|
|
||||||
if let Ok(ast) = source_map.expr_syntax(expr_id) {
|
|
||||||
if ast.file_id != position.file_id.into() {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
let root = db.parse_or_expand(ast.file_id).unwrap();
|
|
||||||
let ast = ast.value.to_node(&root);
|
|
||||||
let range = ast.syntax().text_range();
|
|
||||||
|
|
||||||
if !range.contains(position.offset) {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
let new_size = match size {
|
|
||||||
None => range.len(),
|
|
||||||
Some(size) => {
|
|
||||||
if range.len() < size {
|
|
||||||
range.len()
|
|
||||||
} else {
|
|
||||||
size
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
if size != Some(new_size) {
|
|
||||||
size = Some(new_size);
|
|
||||||
block_id = Some(*id);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Some(block_id.expect("can't find block containing cursor"))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn check_at(ra_fixture: &str, expect: Expect) {
|
|
||||||
let def_map = block_def_map_at(ra_fixture);
|
|
||||||
let actual = def_map.dump();
|
|
||||||
expect.assert_eq(&actual);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn your_stack_belongs_to_me() {
|
fn your_stack_belongs_to_me() {
|
||||||
mark::check!(your_stack_belongs_to_me);
|
mark::check!(your_stack_belongs_to_me);
|
||||||
|
|
|
@ -262,7 +262,7 @@ fn collect_items(
|
||||||
let root = db.parse_or_expand(file_id).unwrap();
|
let root = db.parse_or_expand(file_id).unwrap();
|
||||||
let call = ast_id_map.get(call.ast_id).to_node(&root);
|
let call = ast_id_map.get(call.ast_id).to_node(&root);
|
||||||
|
|
||||||
if let Some((mark, mac)) = expander.enter_expand(db, call).value {
|
if let Some((mark, mac)) = expander.enter_expand(db, None, call).value {
|
||||||
let src: InFile<ast::MacroItems> = expander.to_source(mac);
|
let src: InFile<ast::MacroItems> = expander.to_source(mac);
|
||||||
let item_tree = db.item_tree(src.file_id);
|
let item_tree = db.item_tree(src.file_id);
|
||||||
let iter =
|
let iter =
|
||||||
|
|
|
@ -20,7 +20,6 @@ use crate::{
|
||||||
builtin_type::{BuiltinFloat, BuiltinInt},
|
builtin_type::{BuiltinFloat, BuiltinInt},
|
||||||
path::{GenericArgs, Path},
|
path::{GenericArgs, Path},
|
||||||
type_ref::{Mutability, Rawness, TypeRef},
|
type_ref::{Mutability, Rawness, TypeRef},
|
||||||
BlockId,
|
|
||||||
};
|
};
|
||||||
|
|
||||||
pub type ExprId = Idx<Expr>;
|
pub type ExprId = Idx<Expr>;
|
||||||
|
@ -57,7 +56,6 @@ pub enum Expr {
|
||||||
else_branch: Option<ExprId>,
|
else_branch: Option<ExprId>,
|
||||||
},
|
},
|
||||||
Block {
|
Block {
|
||||||
id: BlockId,
|
|
||||||
statements: Vec<Statement>,
|
statements: Vec<Statement>,
|
||||||
tail: Option<ExprId>,
|
tail: Option<ExprId>,
|
||||||
label: Option<LabelId>,
|
label: Option<LabelId>,
|
||||||
|
|
|
@ -24,7 +24,7 @@ use la_arena::{Arena, Idx, RawIdx};
|
||||||
use profile::Count;
|
use profile::Count;
|
||||||
use rustc_hash::FxHashMap;
|
use rustc_hash::FxHashMap;
|
||||||
use smallvec::SmallVec;
|
use smallvec::SmallVec;
|
||||||
use syntax::{ast, match_ast, SyntaxKind};
|
use syntax::{ast, match_ast};
|
||||||
use test_utils::mark;
|
use test_utils::mark;
|
||||||
|
|
||||||
use crate::{
|
use crate::{
|
||||||
|
@ -80,10 +80,6 @@ impl ItemTree {
|
||||||
pub(crate) fn item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
|
pub(crate) fn item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
|
||||||
let _p = profile::span("item_tree_query").detail(|| format!("{:?}", file_id));
|
let _p = profile::span("item_tree_query").detail(|| format!("{:?}", file_id));
|
||||||
let syntax = if let Some(node) = db.parse_or_expand(file_id) {
|
let syntax = if let Some(node) = db.parse_or_expand(file_id) {
|
||||||
if node.kind() == SyntaxKind::ERROR {
|
|
||||||
// FIXME: not 100% sure why these crop up, but return an empty tree to avoid a panic
|
|
||||||
return Default::default();
|
|
||||||
}
|
|
||||||
node
|
node
|
||||||
} else {
|
} else {
|
||||||
return Default::default();
|
return Default::default();
|
||||||
|
|
|
@ -201,10 +201,8 @@ impl DefMap {
|
||||||
let block: BlockLoc = db.lookup_intern_block(block_id);
|
let block: BlockLoc = db.lookup_intern_block(block_id);
|
||||||
let parent = block.module.def_map(db);
|
let parent = block.module.def_map(db);
|
||||||
|
|
||||||
let item_tree = db.item_tree(block.ast_id.file_id);
|
// FIXME: It would be good to just return the parent map when the block has no items, but
|
||||||
if item_tree.inner_items_of_block(block.ast_id.value).is_empty() {
|
// we rely on `def_map.block` in a few places, which is `Some` for the inner `DefMap`.
|
||||||
return parent.clone();
|
|
||||||
}
|
|
||||||
|
|
||||||
let block_info =
|
let block_info =
|
||||||
BlockInfo { block: block_id, parent, parent_module: block.module.local_id };
|
BlockInfo { block: block_id, parent, parent_module: block.module.local_id };
|
||||||
|
|
|
@ -4,14 +4,16 @@ mod macros;
|
||||||
mod mod_resolution;
|
mod mod_resolution;
|
||||||
mod diagnostics;
|
mod diagnostics;
|
||||||
mod primitives;
|
mod primitives;
|
||||||
|
mod block;
|
||||||
|
|
||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
|
|
||||||
use base_db::{fixture::WithFixture, SourceDatabase};
|
use base_db::{fixture::WithFixture, FilePosition, SourceDatabase};
|
||||||
use expect_test::{expect, Expect};
|
use expect_test::{expect, Expect};
|
||||||
|
use syntax::AstNode;
|
||||||
use test_utils::mark;
|
use test_utils::mark;
|
||||||
|
|
||||||
use crate::{db::DefDatabase, nameres::*, test_db::TestDB};
|
use crate::{db::DefDatabase, nameres::*, test_db::TestDB, Lookup};
|
||||||
|
|
||||||
fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
|
fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
|
||||||
let db = TestDB::with_files(ra_fixture);
|
let db = TestDB::with_files(ra_fixture);
|
||||||
|
@ -19,12 +21,74 @@ fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
|
||||||
db.crate_def_map(krate)
|
db.crate_def_map(krate)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn compute_block_def_map(ra_fixture: &str) -> Arc<DefMap> {
|
||||||
|
let (db, position) = TestDB::with_position(ra_fixture);
|
||||||
|
|
||||||
|
// FIXME: perhaps we should make this use body lowering tests instead?
|
||||||
|
|
||||||
|
let module = db.module_for_file(position.file_id);
|
||||||
|
let mut def_map = db.crate_def_map(module.krate);
|
||||||
|
while let Some(new_def_map) = descend_def_map_at_position(&db, position, def_map.clone()) {
|
||||||
|
def_map = new_def_map;
|
||||||
|
}
|
||||||
|
|
||||||
|
// FIXME: select the right module, not the root
|
||||||
|
|
||||||
|
def_map
|
||||||
|
}
|
||||||
|
|
||||||
|
fn descend_def_map_at_position(
|
||||||
|
db: &dyn DefDatabase,
|
||||||
|
position: FilePosition,
|
||||||
|
def_map: Arc<DefMap>,
|
||||||
|
) -> Option<Arc<DefMap>> {
|
||||||
|
for (local_id, module_data) in def_map.modules() {
|
||||||
|
let mod_def = module_data.origin.definition_source(db);
|
||||||
|
let ast_map = db.ast_id_map(mod_def.file_id);
|
||||||
|
let item_tree = db.item_tree(mod_def.file_id);
|
||||||
|
let root = db.parse_or_expand(mod_def.file_id).unwrap();
|
||||||
|
for item in module_data.scope.declarations() {
|
||||||
|
match item {
|
||||||
|
ModuleDefId::FunctionId(it) => {
|
||||||
|
// Technically blocks can be inside any type (due to arrays and const generics),
|
||||||
|
// and also in const/static initializers. For tests we only really care about
|
||||||
|
// functions though.
|
||||||
|
|
||||||
|
let ast = ast_map.get(item_tree[it.lookup(db).id.value].ast_id).to_node(&root);
|
||||||
|
|
||||||
|
if ast.syntax().text_range().contains(position.offset) {
|
||||||
|
// Cursor inside function, descend into its body's DefMap.
|
||||||
|
// Note that we don't handle block *expressions* inside function bodies.
|
||||||
|
let ast_map = db.ast_id_map(position.file_id.into());
|
||||||
|
let ast_id = ast_map.ast_id(&ast.body().unwrap());
|
||||||
|
let block = BlockLoc {
|
||||||
|
ast_id: InFile::new(position.file_id.into(), ast_id),
|
||||||
|
module: def_map.module_id(local_id),
|
||||||
|
};
|
||||||
|
let block_id = db.intern_block(block);
|
||||||
|
return Some(db.block_def_map(block_id));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => continue,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
None
|
||||||
|
}
|
||||||
|
|
||||||
fn check(ra_fixture: &str, expect: Expect) {
|
fn check(ra_fixture: &str, expect: Expect) {
|
||||||
let def_map = compute_crate_def_map(ra_fixture);
|
let def_map = compute_crate_def_map(ra_fixture);
|
||||||
let actual = def_map.dump();
|
let actual = def_map.dump();
|
||||||
expect.assert_eq(&actual);
|
expect.assert_eq(&actual);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn check_at(ra_fixture: &str, expect: Expect) {
|
||||||
|
let def_map = compute_block_def_map(ra_fixture);
|
||||||
|
let actual = def_map.dump();
|
||||||
|
expect.assert_eq(&actual);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn crate_def_map_smoke_test() {
|
fn crate_def_map_smoke_test() {
|
||||||
check(
|
check(
|
||||||
|
|
|
@ -1,5 +1,4 @@
|
||||||
use super::*;
|
use super::*;
|
||||||
use expect_test::expect;
|
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn inner_item_smoke() {
|
fn inner_item_smoke() {
|
|
@ -137,7 +137,7 @@ impl<'a> InferenceContext<'a> {
|
||||||
|
|
||||||
self.coerce_merge_branch(&then_ty, &else_ty)
|
self.coerce_merge_branch(&then_ty, &else_ty)
|
||||||
}
|
}
|
||||||
Expr::Block { statements, tail, label, id: _ } => match label {
|
Expr::Block { statements, tail, label } => match label {
|
||||||
Some(_) => {
|
Some(_) => {
|
||||||
let break_ty = self.table.new_type_var();
|
let break_ty = self.table.new_type_var();
|
||||||
self.breakables.push(BreakableContext {
|
self.breakables.push(BreakableContext {
|
||||||
|
|
Loading…
Reference in a new issue