Make FnScopes use hir::Expr

This was a bit complicated. I've added a wrapper type for now that does the LocalSyntaxPtr <-> ExprId translation; we might want to get rid of that or give it a nicer interface.
author: Florian Diebold <[email protected]> 2019-01-05 21:37:59 +0000
committer: Florian Diebold <[email protected]> 2019-01-05 23:29:36 +0000
commit: 8e3e5ab2c81f238ea4e731f55eac79b74d9d84c3 (patch)
tree: e0388878b4d94ae71fbf82d3e3163c49c8e69c16 /crates/ra_hir
parent: 136aba1cf32646278c4034541ee415f656f8bb5e (diff)
8 files changed, 514 insertions, 282 deletions
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 188b96872..aaf367e08 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -31,7 +31,7 @@ pub trait HirDatabase: SyntaxDatabase
        use fn crate::macros::expand_macro_invocation;
    }
-    fn fn_scopes(def_id: DefId) -> Arc<FnScopes> {
+    fn fn_scopes(def_id: DefId) -> Cancelable<Arc<FnScopes>> {
        type FnScopesQuery;
        use fn query_definitions::fn_scopes;
    }
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 5cdcca082..5cf0f5e3f 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -4,7 +4,7 @@ use rustc_hash::FxHashMap;
 use ra_arena::{Arena, RawId, impl_arena_id};
 use ra_db::{LocalSyntaxPtr, Cancelable};
-use ra_syntax::ast::{self, AstNode, LoopBodyOwner, ArgListOwner};
+use ra_syntax::ast::{self, AstNode, LoopBodyOwner, ArgListOwner, NameOwner};
 use crate::{Path, type_ref::{Mutability, TypeRef}, Name, HirDatabase, DefId, Def, name::AsName};
@@ -21,7 +21,7 @@ pub struct Body {
    /// part of the function signature, the patterns are not (they don't change
    /// the external type of the function).
    ///
-    /// If this `ExprTable` is for the body of a constant, this will just be
+    /// If this `Body` is for the body of a constant, this will just be
    /// empty.
    args: Vec<PatId>,
    /// The `ExprId` of the actual body expression.
@@ -43,6 +43,43 @@ pub struct BodySyntaxMapping {
    pat_syntax_mapping_back: FxHashMap<PatId, LocalSyntaxPtr>,
 }
+impl Body {
+    pub fn expr(&self, expr: ExprId) -> &Expr {
+        &self.exprs[expr]
+    }
+    pub fn pat(&self, pat: PatId) -> &Pat {
+        &self.pats[pat]
+    }
+    pub fn args(&self) -> &[PatId] {
+        &self.args
+    }
+    pub fn body_expr(&self) -> ExprId {
+        self.body_expr
+    }
+}
+impl BodySyntaxMapping {
+    pub fn expr_syntax(&self, expr: ExprId) -> Option<LocalSyntaxPtr> {
+        self.expr_syntax_mapping_back.get(&expr).cloned()
+    }
+    pub fn syntax_expr(&self, ptr: LocalSyntaxPtr) -> Option<ExprId> {
+        self.expr_syntax_mapping.get(&ptr).cloned()
+    }
+    pub fn pat_syntax(&self, pat: PatId) -> Option<LocalSyntaxPtr> {
+        self.pat_syntax_mapping_back.get(&pat).cloned()
+    }
+    pub fn syntax_pat(&self, ptr: LocalSyntaxPtr) -> Option<PatId> {
+        self.pat_syntax_mapping.get(&ptr).cloned()
+    }
+    pub fn body(&self) -> &Arc<Body> {
+        &self.body
+    }
+}
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Expr {
    /// This is produced if syntax tree does not have a required expression piece.
@@ -113,21 +150,26 @@ pub enum Expr {
        expr: ExprId,
        op: Option<UnaryOp>,
    },
+    Lambda {
+        args: Vec<PatId>,
+        arg_types: Vec<Option<TypeRef>>,
+        body: ExprId,
+    },
 }
 pub type UnaryOp = ast::PrefixOp;
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct MatchArm {
-    pats: Vec<PatId>,
+    pub pats: Vec<PatId>,
    // guard: Option<ExprId>, // TODO
-    expr: ExprId,
+    pub expr: ExprId,
 }
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct StructLitField {
-    name: Name,
+    pub name: Name,
-    expr: ExprId,
+    pub expr: ExprId,
 }
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -140,12 +182,118 @@ pub enum Statement {
    Expr(ExprId),
 }
+impl Expr {
+    pub fn walk_child_exprs(&self, mut f: impl FnMut(ExprId)) {
+        match self {
+            Expr::Missing => {}
+            Expr::Path(_) => {}
+            Expr::If {
+                condition,
+                then_branch,
+                else_branch,
+            } => {
+                f(*condition);
+                f(*then_branch);
+                if let Some(else_branch) = else_branch {
+                    f(*else_branch);
+                }
+            }
+            Expr::Block { statements, tail } => {
+                for stmt in statements {
+                    match stmt {
+                        Statement::Let { initializer, .. } => {
+                            if let Some(expr) = initializer {
+                                f(*expr);
+                            }
+                        }
+                        Statement::Expr(e) => f(*e),
+                    }
+                }
+                if let Some(expr) = tail {
+                    f(*expr);
+                }
+            }
+            Expr::Loop { body } => f(*body),
+            Expr::While { condition, body } => {
+                f(*condition);
+                f(*body);
+            }
+            Expr::For { iterable, body, .. } => {
+                f(*iterable);
+                f(*body);
+            }
+            Expr::Call { callee, args } => {
+                f(*callee);
+                for arg in args {
+                    f(*arg);
+                }
+            }
+            Expr::MethodCall { receiver, args, .. } => {
+                f(*receiver);
+                for arg in args {
+                    f(*arg);
+                }
+            }
+            Expr::Match { expr, arms } => {
+                f(*expr);
+                for arm in arms {
+                    f(arm.expr);
+                }
+            }
+            Expr::Continue => {}
+            Expr::Break { expr } | Expr::Return { expr } => {
+                if let Some(expr) = expr {
+                    f(*expr);
+                }
+            }
+            Expr::StructLit { fields, spread, .. } => {
+                for field in fields {
+                    f(field.expr);
+                }
+                if let Some(expr) = spread {
+                    f(*expr);
+                }
+            }
+            Expr::Lambda { body, .. } => {
+                f(*body);
+            }
+            Expr::Field { expr, .. }
+            | Expr::Try { expr }
+            | Expr::Cast { expr, .. }
+            | Expr::Ref { expr, .. }
+            | Expr::UnaryOp { expr, .. } => {
+                f(*expr);
+            }
+        }
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct PatId(RawId);
 impl_arena_id!(PatId);
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub struct Pat;
+pub enum Pat {
+    Missing,
+    Bind {
+        name: Name,
+    },
+    TupleStruct {
+        path: Option<Path>,
+        args: Vec<PatId>,
+    },
+}
+impl Pat {
+    pub fn walk_child_pats(&self, f: impl FnMut(PatId)) {
+        match self {
+            Pat::Missing | Pat::Bind { .. } => {}
+            Pat::TupleStruct { args, .. } => {
+                args.iter().map(|pat| *pat).for_each(f);
+            }
+        }
+    }
+}
 // Queries
@@ -163,6 +311,17 @@ struct ExprCollector {
 }
 impl ExprCollector {
+    fn new() -> Self {
+        ExprCollector {
+            exprs: Arena::default(),
+            pats: Arena::default(),
+            expr_syntax_mapping: FxHashMap::default(),
+            expr_syntax_mapping_back: FxHashMap::default(),
+            pat_syntax_mapping: FxHashMap::default(),
+            pat_syntax_mapping_back: FxHashMap::default(),
+        }
+    }
    fn alloc_expr(&mut self, expr: Expr, syntax_ptr: LocalSyntaxPtr) -> ExprId {
        let id = self.exprs.alloc(expr);
        self.expr_syntax_mapping.insert(syntax_ptr, id);
@@ -177,30 +336,63 @@ impl ExprCollector {
        id
    }
+    fn empty_block(&mut self) -> ExprId {
+        let block = Expr::Block {
+            statements: Vec::new(),
+            tail: None,
+        };
+        self.exprs.alloc(block)
+    }
    fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
        let syntax_ptr = LocalSyntaxPtr::new(expr.syntax());
        match expr {
            ast::Expr::IfExpr(e) => {
-                let condition = if let Some(condition) = e.condition() {
+                if let Some(pat) = e.condition().and_then(|c| c.pat()) {
-                    if condition.pat().is_none() {
+                    // if let -- desugar to match
+                    let pat = self.collect_pat(pat);
+                    let match_expr =
+                        self.collect_expr_opt(e.condition().expect("checked above").expr());
+                    let then_branch = self.collect_block_opt(e.then_branch());
+                    let else_branch = e
+                        .else_branch()
+                        .map(|e| self.collect_block(e))
+                        .unwrap_or_else(|| self.empty_block());
+                    let placeholder_pat = self.pats.alloc(Pat::Missing);
+                    let arms = vec![
+                        MatchArm {
+                            pats: vec![pat],
+                            expr: then_branch,
+                        },
+                        MatchArm {
+                            pats: vec![placeholder_pat],
+                            expr: else_branch,
+                        },
+                    ];
+                    self.alloc_expr(
+                        Expr::Match {
+                            expr: match_expr,
+                            arms,
+                        },
+                        syntax_ptr,
+                    )
+                } else {
+                    let condition = if let Some(condition) = e.condition() {
                        self.collect_expr_opt(condition.expr())
                    } else {
-                        // TODO handle if let
+                        self.exprs.alloc(Expr::Missing)
-                        return self.alloc_expr(Expr::Missing, syntax_ptr);
+                    };
-                    }
+                    let then_branch = self.collect_block_opt(e.then_branch());
-                } else {
+                    let else_branch = e.else_branch().map(|e| self.collect_block(e));
-                    self.exprs.alloc(Expr::Missing)
+                    self.alloc_expr(
-                };
+                        Expr::If {
-                let then_branch = self.collect_block_opt(e.then_branch());
+                            condition,
-                let else_branch = e.else_branch().map(|e| self.collect_block(e));
+                            then_branch,
-                self.alloc_expr(
+                            else_branch,
-                    Expr::If {
+                        },
-                        condition,
+                        syntax_ptr,
-                        then_branch,
+                    )
-                        else_branch,
+                }
-                    },
-                    syntax_ptr,
-                )
            }
            ast::Expr::BlockExpr(e) => self.collect_block_opt(e.block()),
            ast::Expr::LoopExpr(e) => {
@@ -368,18 +560,30 @@ impl ExprCollector {
                let op = e.op();
                self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
            }
+            ast::Expr::LambdaExpr(e) => {
-            // We should never get to these because they're handled in MatchExpr resp. StructLit:
+                let mut args = Vec::new();
-            ast::Expr::MatchArmList(_) | ast::Expr::MatchArm(_) | ast::Expr::MatchGuard(_) => {
+                let mut arg_types = Vec::new();
-                panic!("collect_expr called on {:?}", expr)
+                if let Some(pl) = e.param_list() {
-            }
+                    for param in pl.params() {
-            ast::Expr::NamedFieldList(_) | ast::Expr::NamedField(_) => {
+                        let pat = self.collect_pat_opt(param.pat());
-                panic!("collect_expr called on {:?}", expr)
+                        let type_ref = param.type_ref().map(TypeRef::from_ast);
+                        args.push(pat);
+                        arg_types.push(type_ref);
+                    }
+                }
+                let body = self.collect_expr_opt(e.body());
+                self.alloc_expr(
+                    Expr::Lambda {
+                        args,
+                        arg_types,
+                        body,
+                    },
+                    syntax_ptr,
+                )
            }
            // TODO implement HIR for these:
            ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::Expr::LambdaExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
            ast::Expr::IndexExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
            ast::Expr::TupleExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
            ast::Expr::ArrayExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
@@ -431,16 +635,31 @@ impl ExprCollector {
    fn collect_pat(&mut self, pat: ast::Pat) -> PatId {
        let syntax_ptr = LocalSyntaxPtr::new(pat.syntax());
-        // TODO
+        match pat {
-        self.alloc_pat(Pat, syntax_ptr)
+            ast::Pat::BindPat(bp) => {
+                let name = bp
+                    .name()
+                    .map(|nr| nr.as_name())
+                    .unwrap_or_else(Name::missing);
+                self.alloc_pat(Pat::Bind { name }, syntax_ptr)
+            }
+            ast::Pat::TupleStructPat(p) => {
+                let path = p.path().and_then(Path::from_ast);
+                let args = p.args().map(|p| self.collect_pat(p)).collect();
+                self.alloc_pat(Pat::TupleStruct { path, args }, syntax_ptr)
+            }
+            _ => {
+                // TODO
+                self.alloc_pat(Pat::Missing, syntax_ptr)
+            }
+        }
    }
    fn collect_pat_opt(&mut self, pat: Option<ast::Pat>) -> PatId {
        if let Some(pat) = pat {
            self.collect_pat(pat)
        } else {
-            // TODO
+            self.pats.alloc(Pat::Missing)
-            self.pats.alloc(Pat)
        }
    }
@@ -461,47 +680,61 @@ impl ExprCollector {
    }
 }
+pub(crate) fn collect_fn_body_syntax(node: ast::FnDef) -> BodySyntaxMapping {
+    let mut collector = ExprCollector::new();
+    let args = if let Some(param_list) = node.param_list() {
+        let mut args = Vec::new();
+        if let Some(self_param) = param_list.self_param() {
+            let self_param = LocalSyntaxPtr::new(
+                self_param
+                    .self_kw()
+                    .expect("self param without self keyword")
+                    .syntax(),
+            );
+            let arg = collector.alloc_pat(
+                Pat::Bind {
+                    name: Name::self_param(),
+                },
+                self_param,
+            );
+            args.push(arg);
+        }
+        for param in param_list.params() {
+            let pat = if let Some(pat) = param.pat() {
+                pat
+            } else {
+                continue;
+            };
+            args.push(collector.collect_pat(pat));
+        }
+        args
+    } else {
+        Vec::new()
+    };
+    let body = collector.collect_block_opt(node.body());
+    collector.into_body_syntax_mapping(args, body)
+}
 pub(crate) fn body_syntax_mapping(
    db: &impl HirDatabase,
    def_id: DefId,
 ) -> Cancelable<Arc<BodySyntaxMapping>> {
    let def = def_id.resolve(db)?;
-    let mut collector = ExprCollector {
-        exprs: Arena::default(),
-        pats: Arena::default(),
-        expr_syntax_mapping: FxHashMap::default(),
-        expr_syntax_mapping_back: FxHashMap::default(),
-        pat_syntax_mapping: FxHashMap::default(),
-        pat_syntax_mapping_back: FxHashMap::default(),
-    };
-    let (body, args) = match def {
+    let body_syntax_mapping = match def {
        Def::Function(f) => {
            let node = f.syntax(db);
            let node = node.borrowed();
-            let args = if let Some(param_list) = node.param_list() {
+            collect_fn_body_syntax(node)
-                let mut args = Vec::new();
-                // TODO self param
-                for param in param_list.params() {
-                    let pat = if let Some(pat) = param.pat() {
-                        pat
-                    } else {
-                        continue;
-                    };
-                    args.push(collector.collect_pat(pat));
-                }
-                args
-            } else {
-                Vec::new()
-            };
-            let body = collector.collect_block_opt(node.body());
-            (body, args)
        }
        // TODO: consts, etc.
        _ => panic!("Trying to get body for item type without body"),
    };
-    Ok(Arc::new(collector.into_body_syntax_mapping(args, body)))
+    Ok(Arc::new(body_syntax_mapping))
 }
diff --git a/crates/ra_hir/src/function.rs b/crates/ra_hir/src/function.rs
index 75ef308ae..4dbdf81d8 100644
--- a/crates/ra_hir/src/function.rs
+++ b/crates/ra_hir/src/function.rs
@@ -11,9 +11,9 @@ use ra_syntax::{
    ast::{self, AstNode, DocCommentsOwner, NameOwner},
 };
-use crate::{DefId, DefKind, HirDatabase, ty::InferenceResult, Module, Crate, impl_block::ImplBlock};
+use crate::{DefId, DefKind, HirDatabase, ty::InferenceResult, Module, Crate, impl_block::ImplBlock, expr::{Body, BodySyntaxMapping}};
-pub use self::scope::FnScopes;
+pub use self::scope::{FnScopes, ScopesWithSyntaxMapping};
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Function {
@@ -36,8 +36,21 @@ impl Function {
        ast::FnDef::cast(syntax.borrowed()).unwrap().owned()
    }
-    pub fn scopes(&self, db: &impl HirDatabase) -> Arc<FnScopes> {
+    pub fn body(&self, db: &impl HirDatabase) -> Cancelable<Arc<Body>> {
-        db.fn_scopes(self.def_id)
+        db.body_hir(self.def_id)
+    }
+    pub fn body_syntax_mapping(&self, db: &impl HirDatabase) -> Cancelable<Arc<BodySyntaxMapping>> {
+        db.body_syntax_mapping(self.def_id)
+    }
+    pub fn scopes(&self, db: &impl HirDatabase) -> Cancelable<ScopesWithSyntaxMapping> {
+        let scopes = db.fn_scopes(self.def_id)?;
+        let syntax_mapping = db.body_syntax_mapping(self.def_id)?;
+        Ok(ScopesWithSyntaxMapping {
+            scopes,
+            syntax_mapping,
+        })
    }
    pub fn signature_info(&self, db: &impl HirDatabase) -> Option<FnSignatureInfo> {
diff --git a/crates/ra_hir/src/function/scope.rs b/crates/ra_hir/src/function/scope.rs
index 42bfe4f32..0607a99cb 100644
--- a/crates/ra_hir/src/function/scope.rs
+++ b/crates/ra_hir/src/function/scope.rs
@@ -1,14 +1,16 @@
+use std::sync::Arc;
 use rustc_hash::{FxHashMap, FxHashSet};
 use ra_syntax::{
    AstNode, SyntaxNodeRef, TextUnit, TextRange,
    algo::generate,
-    ast::{self, ArgListOwner, LoopBodyOwner, NameOwner},
+    ast,
 };
 use ra_arena::{Arena, RawId, impl_arena_id};
 use ra_db::LocalSyntaxPtr;
-use crate::{Name, AsName};
+use crate::{Name, AsName, expr::{PatId, ExprId, Pat, Expr, Body, Statement, BodySyntaxMapping}};
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ScopeId(RawId);
@@ -16,15 +18,15 @@ impl_arena_id!(ScopeId);
 #[derive(Debug, PartialEq, Eq)]
 pub struct FnScopes {
-    pub self_param: Option<LocalSyntaxPtr>,
+    body: Arc<Body>,
    scopes: Arena<ScopeId, ScopeData>,
-    scope_for: FxHashMap<LocalSyntaxPtr, ScopeId>,
+    scope_for: FxHashMap<ExprId, ScopeId>,
 }
 #[derive(Debug, PartialEq, Eq)]
 pub struct ScopeEntry {
    name: Name,
-    ptr: LocalSyntaxPtr,
+    pat: PatId,
 }
 #[derive(Debug, PartialEq, Eq)]
@@ -34,28 +36,101 @@ pub struct ScopeData {
 }
 impl FnScopes {
-    pub(crate) fn new(fn_def: ast::FnDef) -> FnScopes {
+    pub(crate) fn new(body: Arc<Body>) -> FnScopes {
        let mut scopes = FnScopes {
-            self_param: fn_def
+            body: body.clone(),
-                .param_list()
-                .and_then(|it| it.self_param())
-                .map(|it| LocalSyntaxPtr::new(it.syntax())),
            scopes: Arena::default(),
            scope_for: FxHashMap::default(),
        };
        let root = scopes.root_scope();
-        scopes.add_params_bindings(root, fn_def.param_list());
+        scopes.add_params_bindings(root, body.args());
-        if let Some(body) = fn_def.body() {
+        compute_expr_scopes(body.body_expr(), &body, &mut scopes, root);
-            compute_block_scopes(body, &mut scopes, root)
-        }
        scopes
    }
    pub fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
        &self.scopes[scope].entries
    }
+    pub fn scope_chain_for<'a>(&'a self, expr: ExprId) -> impl Iterator<Item = ScopeId> + 'a {
+        generate(self.scope_for(expr), move |&scope| {
+            self.scopes[scope].parent
+        })
+    }
+    pub fn resolve_local_name<'a>(
+        &'a self,
+        context_expr: ExprId,
+        name: Name,
+    ) -> Option<&'a ScopeEntry> {
+        let mut shadowed = FxHashSet::default();
+        let ret = self
+            .scope_chain_for(context_expr)
+            .flat_map(|scope| self.entries(scope).iter())
+            .filter(|entry| shadowed.insert(entry.name()))
+            .filter(|entry| entry.name() == &name)
+            .nth(0);
+        ret
+    }
+    fn root_scope(&mut self) -> ScopeId {
+        self.scopes.alloc(ScopeData {
+            parent: None,
+            entries: vec![],
+        })
+    }
+    fn new_scope(&mut self, parent: ScopeId) -> ScopeId {
+        self.scopes.alloc(ScopeData {
+            parent: Some(parent),
+            entries: vec![],
+        })
+    }
+    fn add_bindings(&mut self, body: &Body, scope: ScopeId, pat: PatId) {
+        match body.pat(pat) {
+            Pat::Bind { name } => self.scopes[scope].entries.push(ScopeEntry {
+                name: name.clone(),
+                pat,
+            }),
+            p => p.walk_child_pats(|pat| self.add_bindings(body, scope, pat)),
+        }
+    }
+    fn add_params_bindings(&mut self, scope: ScopeId, params: &[PatId]) {
+        let body = Arc::clone(&self.body);
+        params
+            .into_iter()
+            .for_each(|it| self.add_bindings(&body, scope, *it));
+    }
+    fn set_scope(&mut self, node: ExprId, scope: ScopeId) {
+        self.scope_for.insert(node, scope);
+    }
+    fn scope_for(&self, expr: ExprId) -> Option<ScopeId> {
+        self.scope_for.get(&expr).map(|&scope| scope)
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ScopesWithSyntaxMapping {
+    pub syntax_mapping: Arc<BodySyntaxMapping>,
+    pub scopes: Arc<FnScopes>,
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ScopeEntryWithSyntax {
+    name: Name,
+    ptr: LocalSyntaxPtr,
+}
+impl ScopeEntryWithSyntax {
+    pub fn name(&self) -> &Name {
+        &self.name
+    }
+    pub fn ptr(&self) -> LocalSyntaxPtr {
+        self.ptr
+    }
+}
+impl ScopesWithSyntaxMapping {
    pub fn scope_chain<'a>(&'a self, node: SyntaxNodeRef) -> impl Iterator<Item = ScopeId> + 'a {
        generate(self.scope_for(node), move |&scope| {
-            self.scopes[scope].parent
+            self.scopes.scopes[scope].parent
        })
    }
    pub fn scope_chain_for_offset<'a>(
@@ -63,26 +138,30 @@ impl FnScopes {
        offset: TextUnit,
    ) -> impl Iterator<Item = ScopeId> + 'a {
        let scope = self
+            .scopes
            .scope_for
            .iter()
-            // find containin scope
+            .filter_map(|(id, scope)| Some((self.syntax_mapping.expr_syntax(*id)?, scope)))
+            // find containing scope
            .min_by_key(|(ptr, _scope)| {
                (
                    !(ptr.range().start() <= offset && offset <= ptr.range().end()),
                    ptr.range().len(),
                )
            })
-            .map(|(ptr, scope)| self.adjust(*ptr, *scope, offset));
+            .map(|(ptr, scope)| self.adjust(ptr, *scope, offset));
-        generate(scope, move |&scope| self.scopes[scope].parent)
+        generate(scope, move |&scope| self.scopes.scopes[scope].parent)
    }
    // XXX: during completion, cursor might be outside of any particular
    // expression. Try to figure out the correct scope...
    fn adjust(&self, ptr: LocalSyntaxPtr, original_scope: ScopeId, offset: TextUnit) -> ScopeId {
        let r = ptr.range();
        let child_scopes = self
+            .scopes
            .scope_for
            .iter()
+            .filter_map(|(id, scope)| Some((self.syntax_mapping.expr_syntax(*id)?, scope)))
            .map(|(ptr, scope)| (ptr.range(), scope))
            .filter(|(range, _)| range.start() <= offset && range.is_subrange(&r) && *range != r);
@@ -100,22 +179,27 @@ impl FnScopes {
            .unwrap_or(original_scope)
    }
-    pub fn resolve_local_name<'a>(&'a self, name_ref: ast::NameRef) -> Option<&'a ScopeEntry> {
+    pub fn resolve_local_name(&self, name_ref: ast::NameRef) -> Option<ScopeEntryWithSyntax> {
        let mut shadowed = FxHashSet::default();
        let name = name_ref.as_name();
        let ret = self
            .scope_chain(name_ref.syntax())
-            .flat_map(|scope| self.entries(scope).iter())
+            .flat_map(|scope| self.scopes.entries(scope).iter())
            .filter(|entry| shadowed.insert(entry.name()))
            .filter(|entry| entry.name() == &name)
            .nth(0);
-        ret
+        ret.and_then(|entry| {
+            Some(ScopeEntryWithSyntax {
+                name: entry.name().clone(),
+                ptr: self.syntax_mapping.pat_syntax(entry.pat())?,
+            })
+        })
    }
    pub fn find_all_refs(&self, pat: ast::BindPat) -> Vec<ReferenceDescriptor> {
        let fn_def = pat.syntax().ancestors().find_map(ast::FnDef::cast).unwrap();
        let name_ptr = LocalSyntaxPtr::new(pat.syntax());
-        let refs: Vec<_> = fn_def
+        fn_def
            .syntax()
            .descendants()
            .filter_map(ast::NameRef::cast)
@@ -127,203 +211,95 @@ impl FnScopes {
                name: name_ref.syntax().text().to_string(),
                range: name_ref.syntax().range(),
            })
-            .collect();
+            .collect()
-        refs
    }
-    fn root_scope(&mut self) -> ScopeId {
-        self.scopes.alloc(ScopeData {
-            parent: None,
-            entries: vec![],
-        })
-    }
-    fn new_scope(&mut self, parent: ScopeId) -> ScopeId {
-        self.scopes.alloc(ScopeData {
-            parent: Some(parent),
-            entries: vec![],
-        })
-    }
-    fn add_bindings(&mut self, scope: ScopeId, pat: ast::Pat) {
-        let entries = pat
-            .syntax()
-            .descendants()
-            .filter_map(ast::BindPat::cast)
-            .filter_map(ScopeEntry::new);
-        self.scopes[scope].entries.extend(entries);
-    }
-    fn add_params_bindings(&mut self, scope: ScopeId, params: Option<ast::ParamList>) {
-        params
-            .into_iter()
-            .flat_map(|it| it.params())
-            .filter_map(|it| it.pat())
-            .for_each(|it| self.add_bindings(scope, it));
-    }
-    fn set_scope(&mut self, node: SyntaxNodeRef, scope: ScopeId) {
-        self.scope_for.insert(LocalSyntaxPtr::new(node), scope);
-    }
    fn scope_for(&self, node: SyntaxNodeRef) -> Option<ScopeId> {
        node.ancestors()
            .map(LocalSyntaxPtr::new)
-            .filter_map(|it| self.scope_for.get(&it).map(|&scope| scope))
+            .filter_map(|ptr| self.syntax_mapping.syntax_expr(ptr))
+            .filter_map(|it| self.scopes.scope_for(it))
            .next()
    }
 }
 impl ScopeEntry {
-    fn new(pat: ast::BindPat) -> Option<ScopeEntry> {
-        let name = pat.name()?.as_name();
-        let res = ScopeEntry {
-            name,
-            ptr: LocalSyntaxPtr::new(pat.syntax()),
-        };
-        Some(res)
-    }
    pub fn name(&self) -> &Name {
        &self.name
    }
-    pub fn ptr(&self) -> LocalSyntaxPtr {
+    pub fn pat(&self) -> PatId {
-        self.ptr
+        self.pat
    }
 }
-fn compute_block_scopes(block: ast::Block, scopes: &mut FnScopes, mut scope: ScopeId) {
+fn compute_block_scopes(
-    // A hack for completion :(
+    statements: &[Statement],
-    scopes.set_scope(block.syntax(), scope);
+    tail: Option<ExprId>,
-    for stmt in block.statements() {
+    body: &Body,
+    scopes: &mut FnScopes,
+    mut scope: ScopeId,
+) {
+    for stmt in statements {
        match stmt {
-            ast::Stmt::LetStmt(stmt) => {
+            Statement::Let {
-                if let Some(expr) = stmt.initializer() {
+                pat, initializer, ..
-                    scopes.set_scope(expr.syntax(), scope);
+            } => {
-                    compute_expr_scopes(expr, scopes, scope);
+                if let Some(expr) = initializer {
+                    scopes.set_scope(*expr, scope);
+                    compute_expr_scopes(*expr, body, scopes, scope);
                }
                scope = scopes.new_scope(scope);
-                if let Some(pat) = stmt.pat() {
+                scopes.add_bindings(body, scope, *pat);
-                    scopes.add_bindings(scope, pat);
-                }
            }
-            ast::Stmt::ExprStmt(expr_stmt) => {
+            Statement::Expr(expr) => {
-                if let Some(expr) = expr_stmt.expr() {
+                scopes.set_scope(*expr, scope);
-                    scopes.set_scope(expr.syntax(), scope);
+                compute_expr_scopes(*expr, body, scopes, scope);
-                    compute_expr_scopes(expr, scopes, scope);
-                }
            }
        }
    }
-    if let Some(expr) = block.expr() {
+    if let Some(expr) = tail {
-        scopes.set_scope(expr.syntax(), scope);
+        compute_expr_scopes(expr, body, scopes, scope);
-        compute_expr_scopes(expr, scopes, scope);
    }
 }
-fn compute_expr_scopes(expr: ast::Expr, scopes: &mut FnScopes, scope: ScopeId) {
+fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut FnScopes, scope: ScopeId) {
-    match expr {
+    scopes.set_scope(expr, scope);
-        ast::Expr::IfExpr(e) => {
+    match body.expr(expr) {
-            let cond_scope = e
+        Expr::Block { statements, tail } => {
-                .condition()
+            compute_block_scopes(&statements, *tail, body, scopes, scope);
-                .and_then(|cond| compute_cond_scopes(cond, scopes, scope));
-            if let Some(block) = e.then_branch() {
-                compute_block_scopes(block, scopes, cond_scope.unwrap_or(scope));
-            }
-            if let Some(block) = e.else_branch() {
-                compute_block_scopes(block, scopes, scope);
-            }
-        }
-        ast::Expr::BlockExpr(e) => {
-            if let Some(block) = e.block() {
-                compute_block_scopes(block, scopes, scope);
-            }
-        }
-        ast::Expr::LoopExpr(e) => {
-            if let Some(block) = e.loop_body() {
-                compute_block_scopes(block, scopes, scope);
-            }
-        }
-        ast::Expr::WhileExpr(e) => {
-            let cond_scope = e
-                .condition()
-                .and_then(|cond| compute_cond_scopes(cond, scopes, scope));
-            if let Some(block) = e.loop_body() {
-                compute_block_scopes(block, scopes, cond_scope.unwrap_or(scope));
-            }
        }
-        ast::Expr::ForExpr(e) => {
+        Expr::For {
-            if let Some(expr) = e.iterable() {
+            iterable,
-                compute_expr_scopes(expr, scopes, scope);
+            pat,
-            }
+            body: body_expr,
-            let mut scope = scope;
+        } => {
-            if let Some(pat) = e.pat() {
+            compute_expr_scopes(*iterable, body, scopes, scope);
-                scope = scopes.new_scope(scope);
-                scopes.add_bindings(scope, pat);
-            }
-            if let Some(block) = e.loop_body() {
-                compute_block_scopes(block, scopes, scope);
-            }
-        }
-        ast::Expr::LambdaExpr(e) => {
            let scope = scopes.new_scope(scope);
-            scopes.add_params_bindings(scope, e.param_list());
+            scopes.add_bindings(body, scope, *pat);
-            if let Some(body) = e.body() {
+            compute_expr_scopes(*body_expr, body, scopes, scope);
-                scopes.set_scope(body.syntax(), scope);
-                compute_expr_scopes(body, scopes, scope);
-            }
        }
-        ast::Expr::CallExpr(e) => {
+        Expr::Lambda {
-            compute_call_scopes(e.expr(), e.arg_list(), scopes, scope);
+            args,
-        }
+            body: body_expr,
-        ast::Expr::MethodCallExpr(e) => {
+            ..
-            compute_call_scopes(e.expr(), e.arg_list(), scopes, scope);
+        } => {
+            let scope = scopes.new_scope(scope);
+            scopes.add_params_bindings(scope, &args);
+            compute_expr_scopes(*body_expr, body, scopes, scope);
        }
-        ast::Expr::MatchExpr(e) => {
+        Expr::Match { expr, arms } => {
-            if let Some(expr) = e.expr() {
+            compute_expr_scopes(*expr, body, scopes, scope);
-                compute_expr_scopes(expr, scopes, scope);
+            for arm in arms {
-            }
-            for arm in e.match_arm_list().into_iter().flat_map(|it| it.arms()) {
                let scope = scopes.new_scope(scope);
-                for pat in arm.pats() {
+                for pat in &arm.pats {
-                    scopes.add_bindings(scope, pat);
+                    scopes.add_bindings(body, scope, *pat);
-                }
-                if let Some(expr) = arm.expr() {
-                    compute_expr_scopes(expr, scopes, scope);
                }
+                scopes.set_scope(arm.expr, scope);
+                compute_expr_scopes(arm.expr, body, scopes, scope);
            }
        }
-        _ => expr
+        e => e.walk_child_exprs(|e| compute_expr_scopes(e, body, scopes, scope)),
-            .syntax()
-            .children()
-            .filter_map(ast::Expr::cast)
-            .for_each(|expr| compute_expr_scopes(expr, scopes, scope)),
    };
-    fn compute_call_scopes(
-        receiver: Option<ast::Expr>,
-        arg_list: Option<ast::ArgList>,
-        scopes: &mut FnScopes,
-        scope: ScopeId,
-    ) {
-        arg_list
-            .into_iter()
-            .flat_map(|it| it.args())
-            .chain(receiver)
-            .for_each(|expr| compute_expr_scopes(expr, scopes, scope));
-    }
-    fn compute_cond_scopes(
-        cond: ast::Condition,
-        scopes: &mut FnScopes,
-        scope: ScopeId,
-    ) -> Option<ScopeId> {
-        if let Some(expr) = cond.expr() {
-            compute_expr_scopes(expr, scopes, scope);
-        }
-        if let Some(pat) = cond.pat() {
-            let s = scopes.new_scope(scope);
-            scopes.add_bindings(s, pat);
-            Some(s)
-        } else {
-            None
-        }
-    }
 }
 #[derive(Debug)]
@@ -338,6 +314,8 @@ mod tests {
    use ra_syntax::SourceFileNode;
    use test_utils::{extract_offset, assert_eq_text};
+    use crate::expr;
    use super::*;
    fn do_check(code: &str, expected: &[&str]) {
@@ -353,15 +331,20 @@ mod tests {
        let file = SourceFileNode::parse(&code);
        let marker: ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
        let fn_def: ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
-        let scopes = FnScopes::new(fn_def);
+        let body_hir = expr::collect_fn_body_syntax(fn_def);
+        let scopes = FnScopes::new(Arc::clone(body_hir.body()));
+        let scopes = ScopesWithSyntaxMapping {
+            scopes: Arc::new(scopes),
+            syntax_mapping: Arc::new(body_hir),
+        };
        let actual = scopes
            .scope_chain(marker.syntax())
-            .flat_map(|scope| scopes.entries(scope))
+            .flat_map(|scope| scopes.scopes.entries(scope))
            .map(|it| it.name().to_string())
            .collect::<Vec<_>>()
            .join("\n");
        let expected = expected.join("\n");
-        assert_eq_text!(&actual, &expected);
+        assert_eq_text!(&expected, &actual);
    }
    #[test]
@@ -389,7 +372,7 @@ mod tests {
    }
    #[test]
-    fn test_metod_call_scope() {
+    fn test_method_call_scope() {
        do_check(
            r"
            fn quux() {
@@ -445,10 +428,15 @@ mod tests {
        let fn_def: ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
        let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
-        let scopes = FnScopes::new(fn_def);
+        let body_hir = expr::collect_fn_body_syntax(fn_def);
+        let scopes = FnScopes::new(Arc::clone(body_hir.body()));
+        let scopes = ScopesWithSyntaxMapping {
+            scopes: Arc::new(scopes),
+            syntax_mapping: Arc::new(body_hir),
+        };
        let local_name_entry = scopes.resolve_local_name(name_ref).unwrap();
-        let local_name = local_name_entry.ptr().resolve(&file);
+        let local_name = local_name_entry.ptr();
        let expected_name =
            find_node_at_offset::<ast::Name>(file.syntax(), expected_offset.into()).unwrap();
        assert_eq!(local_name.range(), expected_name.syntax().range());
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index fea9e141b..82dc287de 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -47,7 +47,7 @@ pub use self::{
    ids::{HirFileId, DefId, DefLoc, MacroCallId, MacroCallLoc},
    macros::{MacroDef, MacroInput, MacroExpansion},
    module::{Module, ModuleId, Problem, nameres::{ItemMap, PerNs, Namespace}, ModuleScope, Resolution},
-    function::{Function, FnScopes},
+    function::{Function, FnScopes, ScopesWithSyntaxMapping},
    adt::{Struct, Enum},
    ty::Ty,
    impl_block::{ImplBlock, ImplItem},
diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs
index 017caf442..6f95b168f 100644
--- a/crates/ra_hir/src/name.rs
+++ b/crates/ra_hir/src/name.rs
@@ -31,6 +31,10 @@ impl Name {
        Name::new("[missing name]".into())
    }
+    pub(crate) fn self_param() -> Name {
+        Name::new("self".into())
+    }
    pub(crate) fn tuple_field_name(idx: usize) -> Name {
        Name::new(idx.to_string().into())
    }
@@ -51,7 +55,8 @@ impl Name {
            "u128" => KnownName::U128,
            "f32" => KnownName::F32,
            "f64" => KnownName::F64,
-            "Self" => KnownName::Self_,
+            "Self" => KnownName::SelfType,
+            "self" => KnownName::SelfParam,
            _ => return None,
        };
        Some(name)
@@ -104,5 +109,6 @@ pub(crate) enum KnownName {
    F32,
    F64,
-    Self_,
+    SelfType,
+    SelfParam,
 }
diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs
index a5d99beda..d9ee9d37f 100644
--- a/crates/ra_hir/src/query_definitions.rs
+++ b/crates/ra_hir/src/query_definitions.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
 use ra_db::{SourceRootId, Cancelable,};
 use crate::{
-    SourceFileItems, SourceItemId, DefKind, Function, DefId, Name, AsName, HirFileId,
+    SourceFileItems, SourceItemId, DefKind, DefId, Name, AsName, HirFileId,
    MacroCallLoc,
    db::HirDatabase,
    function::FnScopes,
@@ -23,11 +23,10 @@ use crate::{
    adt::{StructData, EnumData},
 };
-pub(super) fn fn_scopes(db: &impl HirDatabase, def_id: DefId) -> Arc<FnScopes> {
+pub(super) fn fn_scopes(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<FnScopes>> {
-    let function = Function::new(def_id);
+    let body = db.body_hir(def_id)?;
-    let syntax = function.syntax(db);
+    let res = FnScopes::new(body);
-    let res = FnScopes::new(syntax.borrowed());
+    Ok(Arc::new(res))
-    Arc::new(res)
 }
 pub(super) fn struct_data(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<StructData>> {
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index e33762e0d..8c320a705 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -31,10 +31,11 @@ use ra_syntax::{
 };
 use crate::{
-    Def, DefId, FnScopes, Module, Function, Struct, Enum, Path, Name, AsName, ImplBlock,
+    Def, DefId, Module, Function, Struct, Enum, Path, Name, AsName, ImplBlock,
    db::HirDatabase,
    type_ref::{TypeRef, Mutability},
    name::KnownName,
+    ScopesWithSyntaxMapping,
 };
 /// The ID of a type variable.
@@ -305,7 +306,7 @@ impl Ty {
                return Ok(Ty::Uint(uint_ty));
            } else if let Some(float_ty) = primitive::FloatTy::from_name(name) {
                return Ok(Ty::Float(float_ty));
-            } else if name.as_known_name() == Some(KnownName::Self_) {
+            } else if name.as_known_name() == Some(KnownName::SelfType) {
                return Ty::from_hir_opt(db, module, None, impl_block.map(|i| i.target_type()));
            }
        }
@@ -515,7 +516,7 @@ impl InferenceResult {
 #[derive(Clone, Debug)]
 struct InferenceContext<'a, D: HirDatabase> {
    db: &'a D,
-    scopes: Arc<FnScopes>,
+    scopes: ScopesWithSyntaxMapping,
    /// The self param for the current method, if it exists.
    self_param: Option<LocalSyntaxPtr>,
    module: Module,
@@ -529,7 +530,7 @@ struct InferenceContext<'a, D: HirDatabase> {
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    fn new(
        db: &'a D,
-        scopes: Arc<FnScopes>,
+        scopes: ScopesWithSyntaxMapping,
        module: Module,
        impl_block: Option<ImplBlock>,
    ) -> Self {
@@ -826,10 +827,6 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                self.infer_expr_opt(e.expr(), &Expectation::none())?;
                Ty::Never
            }
-            ast::Expr::MatchArmList(_) | ast::Expr::MatchArm(_) | ast::Expr::MatchGuard(_) => {
-                // Can this even occur outside of a match expression?
-                Ty::Unknown
-            }
            ast::Expr::StructLit(e) => {
                let (ty, def_id) = self.resolve_variant(e.path())?;
                if let Some(nfl) = e.named_field_list() {
@@ -845,10 +842,6 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                }
                ty
            }
-            ast::Expr::NamedFieldList(_) | ast::Expr::NamedField(_) => {
-                // Can this even occur outside of a struct literal?
-                Ty::Unknown
-            }
            ast::Expr::IndexExpr(_e) => Ty::Unknown,
            ast::Expr::FieldExpr(e) => {
                let receiver_ty = self.infer_expr_opt(e.expr(), &Expectation::none())?;
@@ -1016,7 +1009,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 pub fn infer(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<InferenceResult>> {
    let function = Function::new(def_id); // TODO: consts also need inference
-    let scopes = function.scopes(db);
+    let scopes = function.scopes(db)?;
    let module = function.module(db)?;
    let impl_block = function.impl_block(db)?;
    let mut ctx = InferenceContext::new(db, scopes, module, impl_block);
author	Florian Diebold <[email protected]>	2019-01-05 21:37:59 +0000
committer	Florian Diebold <[email protected]>	2019-01-05 23:29:36 +0000
commit	8e3e5ab2c81f238ea4e731f55eac79b74d9d84c3 (patch)
tree	e0388878b4d94ae71fbf82d3e3163c49c8e69c16 /crates/ra_hir
parent	136aba1cf32646278c4034541ee415f656f8bb5e (diff)