squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity
rust/crates/ra_hir/src/expr.rs

1028 lines
35 KiB
Rust
Raw Normal View History

Various small code review improvements
2019-01-06 00:33:58 +01:00
use std::ops::Index;
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
use std::sync::Arc;
use rustc_hash::FxHashMap;
Introduce ArenaMap
2019-01-06 23:57:39 +01:00
use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap};
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
use ra_syntax::{
SyntaxNodePtr, AstNode,
ast::{self, LoopBodyOwner, ArgListOwner, NameOwner, LiteralFlavor}
};
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
Functions use new id scheme
2019-01-24 13:28:50 +01:00
use crate::{
Sketching the resolver API
2019-01-19 21:23:26 +01:00
Path, Name, HirDatabase, Function, Resolver,
name::AsName,
Functions use new id scheme
2019-01-24 13:28:50 +01:00
type_ref::{Mutability, TypeRef},
};
Fixup tests
2019-01-14 19:30:21 +01:00
use crate::ty::primitive::{UintTy, UncertainIntTy, UncertainFloatTy};
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
Rename FnScopes -> ExprScopes The reason for this is that it describes scopes for any body expression, not just that of a function. It did not actually refer to functions at all anymore.
2019-01-19 19:47:56 +01:00
pub use self::scope::{ExprScopes, ScopesWithSyntaxMapping, ScopeEntryWithSyntax};
Sketching the resolver API
2019-01-19 21:23:26 +01:00
pub(crate) mod scope;
Rename FnScopes -> ExprScopes The reason for this is that it describes scopes for any body expression, not just that of a function. It did not actually refer to functions at all anymore.
2019-01-19 19:47:56 +01:00
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ExprId(RawId);
impl_arena_id!(ExprId);
/// The body of an item (function, const etc.).
#[derive(Debug, Eq, PartialEq)]
pub struct Body {
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
// TODO: this should be more general, consts & statics also have bodies
/// The Function of the item this body belongs to
owner: Function,
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
exprs: Arena<ExprId, Expr>,
pats: Arena<PatId, Pat>,
args -> params
2019-01-12 21:58:16 +01:00
/// The patterns for the function's parameters. While the parameter types are
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
/// part of the function signature, the patterns are not (they don't change
/// the external type of the function).
///
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.
2019-01-05 22:37:59 +01:00
/// If this `Body` is for the body of a constant, this will just be
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
/// empty.
args -> params
2019-01-12 21:58:16 +01:00
params: Vec<PatId>,
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
/// The `ExprId` of the actual body expression.
body_expr: ExprId,
}
/// An item body together with the mapping from syntax nodes to HIR expression
/// IDs. This is needed to go from e.g. a position in a file to the HIR
/// expression containing it; but for type inference etc., we want to operate on
/// a structure that is agnostic to the actual positions of expressions in the
Fix typos in ARCHITECTURE.md and a number of crates specifically: gen_lsp_server, ra_arena, ra_cli, ra_db, ra_hir
2019-01-09 00:47:12 +01:00
/// file, so that we don't recompute types whenever some whitespace is typed.
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
#[derive(Debug, Eq, PartialEq)]
pub struct BodySyntaxMapping {
body: Arc<Body>,
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
expr_syntax_mapping: FxHashMap<SyntaxNodePtr, ExprId>,
expr_syntax_mapping_back: ArenaMap<ExprId, SyntaxNodePtr>,
pat_syntax_mapping: FxHashMap<SyntaxNodePtr, PatId>,
pat_syntax_mapping_back: ArenaMap<PatId, SyntaxNodePtr>,
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
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.
2019-01-05 22:37:59 +01:00
impl Body {
args -> params
2019-01-12 21:58:16 +01:00
pub fn params(&self) -> &[PatId] {
&self.params
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.
2019-01-05 22:37:59 +01:00
}
pub fn body_expr(&self) -> ExprId {
self.body_expr
}
Sketching the resolver API
2019-01-19 21:23:26 +01:00
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
pub fn owner(&self) -> Function {
self.owner
Sketching the resolver API
2019-01-19 21:23:26 +01:00
}
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.
2019-01-05 22:37:59 +01:00
}
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
// needs arbitrary_self_types to be a method... or maybe move to the def?
Use the new Resolver API in completion
2019-01-27 20:50:57 +01:00
pub fn resolver_for_expr(
body: Arc<Body>,
db: &impl HirDatabase,
expr_id: ExprId,
) -> Resolver<'static> {
let scopes = db.expr_scopes(body.owner);
resolver_for_scope(body, db, scopes.scope_for(expr_id))
}
pub fn resolver_for_scope(
body: Arc<Body>,
db: &impl HirDatabase,
scope_id: Option<scope::ScopeId>,
) -> Resolver<'static> {
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
let mut r = body.owner.resolver(db);
let scopes = db.expr_scopes(body.owner);
Use the new Resolver API in completion
2019-01-27 20:50:57 +01:00
let scope_chain = scopes.scope_chain_for(scope_id).collect::<Vec<_>>();
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
for scope in scope_chain.into_iter().rev() {
r = r.push_expr_scope(Arc::clone(&scopes), scope);
}
r
}
Various small code review improvements
2019-01-06 00:33:58 +01:00
impl Index<ExprId> for Body {
type Output = Expr;
fn index(&self, expr: ExprId) -> &Expr {
&self.exprs[expr]
}
}
impl Index<PatId> for Body {
type Output = Pat;
fn index(&self, pat: PatId) -> &Pat {
&self.pats[pat]
}
}
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.
2019-01-05 22:37:59 +01:00
impl BodySyntaxMapping {
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
pub fn expr_syntax(&self, expr: ExprId) -> Option<SyntaxNodePtr> {
Introduce ArenaMap
2019-01-06 23:57:39 +01:00
self.expr_syntax_mapping_back.get(expr).cloned()
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.
2019-01-05 22:37:59 +01:00
}
Fix typos in ARCHITECTURE.md and a number of crates specifically: gen_lsp_server, ra_arena, ra_cli, ra_db, ra_hir
2019-01-09 00:47:12 +01:00
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
pub fn syntax_expr(&self, ptr: SyntaxNodePtr) -> Option<ExprId> {
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.
2019-01-05 22:37:59 +01:00
self.expr_syntax_mapping.get(&ptr).cloned()
}
Fix typos in ARCHITECTURE.md and a number of crates specifically: gen_lsp_server, ra_arena, ra_cli, ra_db, ra_hir
2019-01-09 00:47:12 +01:00
migrate ra_analysis to new rowan
2019-01-08 09:47:28 +01:00
pub fn node_expr(&self, node: &ast::Expr) -> Option<ExprId> {
Use HIR Expr for type inference Now we can reuse the type inference inside a function when typing whitespace etc. :)
2019-01-06 16:47:59 +01:00
self.expr_syntax_mapping
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
.get(&SyntaxNodePtr::new(node.syntax()))
Use HIR Expr for type inference Now we can reuse the type inference inside a function when typing whitespace etc. :)
2019-01-06 16:47:59 +01:00
.cloned()
}
Fix typos in ARCHITECTURE.md and a number of crates specifically: gen_lsp_server, ra_arena, ra_cli, ra_db, ra_hir
2019-01-09 00:47:12 +01:00
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
pub fn pat_syntax(&self, pat: PatId) -> Option<SyntaxNodePtr> {
Introduce ArenaMap
2019-01-06 23:57:39 +01:00
self.pat_syntax_mapping_back.get(pat).cloned()
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.
2019-01-05 22:37:59 +01:00
}
Fix typos in ARCHITECTURE.md and a number of crates specifically: gen_lsp_server, ra_arena, ra_cli, ra_db, ra_hir
2019-01-09 00:47:12 +01:00
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
pub fn syntax_pat(&self, ptr: SyntaxNodePtr) -> Option<PatId> {
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.
2019-01-05 22:37:59 +01:00
self.pat_syntax_mapping.get(&ptr).cloned()
}
Fix typos in ARCHITECTURE.md and a number of crates specifically: gen_lsp_server, ra_arena, ra_cli, ra_db, ra_hir
2019-01-09 00:47:12 +01:00
migrate ra_analysis to new rowan
2019-01-08 09:47:28 +01:00
pub fn node_pat(&self, node: &ast::Pat) -> Option<PatId> {
Use HIR Expr for type inference Now we can reuse the type inference inside a function when typing whitespace etc. :)
2019-01-06 16:47:59 +01:00
self.pat_syntax_mapping
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
.get(&SyntaxNodePtr::new(node.syntax()))
Use HIR Expr for type inference Now we can reuse the type inference inside a function when typing whitespace etc. :)
2019-01-06 16:47:59 +01:00
.cloned()
}
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.
2019-01-05 22:37:59 +01:00
pub fn body(&self) -> &Arc<Body> {
&self.body
}
}
Implement type inference for literals (WIP)
2019-01-10 13:54:58 +01:00
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Literal {
String(String),
ByteString(Vec<u8>),
Char(char),
Bool(bool),
Try implementing integer type inference (WIP)
2019-01-10 16:03:15 +01:00
Int(u64, UncertainIntTy),
Float(u64, UncertainFloatTy), // FIXME: f64 is not Eq
Implement type inference for literals (WIP)
2019-01-10 13:54:58 +01:00
}
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Expr {
/// This is produced if syntax tree does not have a required expression piece.
Missing,
Path(Path),
If {
condition: ExprId,
then_branch: ExprId,
else_branch: Option<ExprId>,
},
Block {
statements: Vec<Statement>,
tail: Option<ExprId>,
},
Loop {
body: ExprId,
},
While {
condition: ExprId,
body: ExprId,
},
For {
iterable: ExprId,
pat: PatId,
body: ExprId,
},
Call {
callee: ExprId,
args: Vec<ExprId>,
},
MethodCall {
receiver: ExprId,
method_name: Name,
args: Vec<ExprId>,
},
Match {
expr: ExprId,
arms: Vec<MatchArm>,
},
Continue,
Break {
expr: Option<ExprId>,
},
Return {
expr: Option<ExprId>,
},
StructLit {
path: Option<Path>,
fields: Vec<StructLitField>,
spread: Option<ExprId>,
},
Field {
expr: ExprId,
name: Name,
},
Try {
expr: ExprId,
},
Cast {
expr: ExprId,
type_ref: TypeRef,
},
Ref {
expr: ExprId,
mutability: Mutability,
},
UnaryOp {
expr: ExprId,
Implement rudimentary type inference for unary operators
2019-01-14 23:15:16 +01:00
op: UnaryOp,
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
},
Use HIR Expr for type inference Now we can reuse the type inference inside a function when typing whitespace etc. :)
2019-01-06 16:47:59 +01:00
BinaryOp {
lhs: ExprId,
rhs: ExprId,
op: Option<BinaryOp>,
},
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.
2019-01-05 22:37:59 +01:00
Lambda {
args: Vec<PatId>,
arg_types: Vec<Option<TypeRef>>,
body: ExprId,
},
Implement tuple inference
2019-01-13 13:00:27 +01:00
Tuple {
exprs: Vec<ExprId>,
},
Implement array inference
2019-01-13 14:46:36 +01:00
Array {
exprs: Vec<ExprId>,
},
Implement type inference for literals (WIP)
2019-01-10 13:54:58 +01:00
Literal(Literal),
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
Use HIR Expr for type inference Now we can reuse the type inference inside a function when typing whitespace etc. :)
2019-01-06 16:47:59 +01:00
pub use ra_syntax::ast::PrefixOp as UnaryOp;
pub use ra_syntax::ast::BinOp as BinaryOp;
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct MatchArm {
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.
2019-01-05 22:37:59 +01:00
pub pats: Vec<PatId>,
Infer type of match guard
2019-01-28 23:06:11 +01:00
pub guard: Option<ExprId>,
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.
2019-01-05 22:37:59 +01:00
pub expr: ExprId,
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct StructLitField {
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.
2019-01-05 22:37:59 +01:00
pub name: Name,
pub expr: ExprId,
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Statement {
Let {
pat: PatId,
type_ref: Option<TypeRef>,
initializer: Option<ExprId>,
},
Expr(ExprId),
}
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.
2019-01-05 22:37:59 +01:00
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);
}
Use HIR Expr for type inference Now we can reuse the type inference inside a function when typing whitespace etc. :)
2019-01-06 16:47:59 +01:00
Expr::BinaryOp { lhs, rhs, .. } => {
f(*lhs);
f(*rhs);
}
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.
2019-01-05 22:37:59 +01:00
Expr::Field { expr, .. }
| Expr::Try { expr }
| Expr::Cast { expr, .. }
| Expr::Ref { expr, .. }
| Expr::UnaryOp { expr, .. } => {
f(*expr);
}
Implement array inference
2019-01-13 14:46:36 +01:00
Expr::Tuple { exprs } | Expr::Array { exprs } => {
Implement tuple inference
2019-01-13 13:00:27 +01:00
for expr in exprs {
f(*expr);
}
}
don't try to treat arrays and tuples as literals
2019-01-11 09:47:31 +01:00
Expr::Literal(_) => {}
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.
2019-01-05 22:37:59 +01:00
}
}
}
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct PatId(RawId);
impl_arena_id!(PatId);
Add initial (flawed) implementation of binding annotations
2019-01-17 13:08:18 +01:00
/// Explicit binding annotations given in the HIR for a binding. Note
/// that this is not the final binding *mode* that we infer after type
/// inference.
#[derive(Clone, PartialEq, Eq, Debug, Copy)]
pub enum BindingAnnotation {
/// No binding annotation given: this means that the final binding mode
/// will depend on whether we have skipped through a `&` reference
/// when matching. For example, the `x` in `Some(x)` will have binding
/// mode `None`; if you do `let Some(x) = &Some(22)`, it will
/// ultimately be inferred to be by-reference.
Unannotated,
/// Annotated with `mut x` -- could be either ref or not, similar to `None`.
Mutable,
/// Annotated as `ref`, like `ref x`
Ref,
/// Annotated as `ref mut x`.
RefMut,
}
impl BindingAnnotation {
fn new(is_mutable: bool, is_ref: bool) -> Self {
match (is_mutable, is_ref) {
(true, true) => BindingAnnotation::RefMut,
(false, true) => BindingAnnotation::Ref,
(true, false) => BindingAnnotation::Mutable,
(false, false) => BindingAnnotation::Unannotated,
}
}
}
Create struct patterns up to the hir level
2019-01-16 19:35:27 +01:00
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct FieldPat {
Get basic struct pattern type inference working!
2019-01-16 20:26:58 +01:00
pub(crate) name: Name,
Implement unlabeled struct field pattern inference
2019-01-17 00:08:10 +01:00
pub(crate) pat: PatId,
Create struct patterns up to the hir level
2019-01-16 19:35:27 +01:00
}
Add additional pattern variants
2019-01-15 15:24:04 +01:00
/// Close relative to rustc's hir::PatKind
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
#[derive(Debug, Clone, Eq, PartialEq)]
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.
2019-01-05 22:37:59 +01:00
pub enum Pat {
Address issues flagged in review
2019-01-18 00:41:02 +01:00
Missing,
Add additional pattern variants
2019-01-15 15:24:04 +01:00
Wild,
Tuple(Vec<PatId>),
Create struct patterns up to the hir level
2019-01-16 19:35:27 +01:00
Struct {
path: Option<Path>,
args: Vec<FieldPat>,
// TODO: 'ellipsis' option
},
Add additional pattern variants
2019-01-15 15:24:04 +01:00
Range {
start: ExprId,
end: ExprId,
},
Slice {
prefix: Vec<PatId>,
rest: Option<PatId>,
suffix: Vec<PatId>,
},
Path(Path),
Lit(ExprId),
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.
2019-01-05 22:37:59 +01:00
Bind {
Add initial (flawed) implementation of binding annotations
2019-01-17 13:08:18 +01:00
mode: BindingAnnotation,
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.
2019-01-05 22:37:59 +01:00
name: Name,
Fixup annotated bindings
2019-01-17 13:40:45 +01:00
subpat: Option<PatId>,
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.
2019-01-05 22:37:59 +01:00
},
TupleStruct {
path: Option<Path>,
args: Vec<PatId>,
},
support ref-patterns
2019-01-13 11:34:57 +01:00
Ref {
pat: PatId,
mutability: Mutability,
},
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.
2019-01-05 22:37:59 +01:00
}
impl Pat {
support ref-patterns
2019-01-13 11:34:57 +01:00
pub fn walk_child_pats(&self, mut f: impl FnMut(PatId)) {
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.
2019-01-05 22:37:59 +01:00
match self {
Fixup annotated bindings
2019-01-17 13:40:45 +01:00
Pat::Range { .. } | Pat::Lit(..) | Pat::Path(..) | Pat::Wild | Pat::Missing => {}
Pat::Bind { subpat, .. } => {
subpat.iter().map(|pat| *pat).for_each(f);
}
Add additional pattern variants
2019-01-15 15:24:04 +01:00
Pat::Tuple(args) | Pat::TupleStruct { args, .. } => {
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.
2019-01-05 22:37:59 +01:00
args.iter().map(|pat| *pat).for_each(f);
}
Address issues flagged in review
2019-01-18 00:41:02 +01:00
Pat::Ref { pat, .. } => f(*pat),
Add additional pattern variants
2019-01-15 15:24:04 +01:00
Pat::Slice {
prefix,
rest,
suffix,
} => {
let total_iter = prefix.iter().chain(rest.iter()).chain(suffix.iter());
total_iter.map(|pat| *pat).for_each(f);
}
Get basic struct pattern type inference working!
2019-01-16 20:26:58 +01:00
Pat::Struct { args, .. } => {
Implement unlabeled struct field pattern inference
2019-01-17 00:08:10 +01:00
args.iter().map(|f| f.pat).for_each(f);
Get basic struct pattern type inference working!
2019-01-16 20:26:58 +01:00
}
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.
2019-01-05 22:37:59 +01:00
}
}
}
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
// Queries
Functions use new id scheme
2019-01-24 13:28:50 +01:00
pub(crate) fn body_hir(db: &impl HirDatabase, func: Function) -> Arc<Body> {
Arc::clone(&body_syntax_mapping(db, func).body)
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
struct ExprCollector {
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
owner: Function,
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
exprs: Arena<ExprId, Expr>,
pats: Arena<PatId, Pat>,
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
expr_syntax_mapping: FxHashMap<SyntaxNodePtr, ExprId>,
expr_syntax_mapping_back: ArenaMap<ExprId, SyntaxNodePtr>,
pat_syntax_mapping: FxHashMap<SyntaxNodePtr, PatId>,
pat_syntax_mapping_back: ArenaMap<PatId, SyntaxNodePtr>,
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
params: Vec<PatId>,
body_expr: Option<ExprId>,
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
impl ExprCollector {
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
fn new(owner: Function) -> Self {
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.
2019-01-05 22:37:59 +01:00
ExprCollector {
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
owner,
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.
2019-01-05 22:37:59 +01:00
exprs: Arena::default(),
pats: Arena::default(),
expr_syntax_mapping: FxHashMap::default(),
Introduce ArenaMap
2019-01-06 23:57:39 +01:00
expr_syntax_mapping_back: ArenaMap::default(),
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.
2019-01-05 22:37:59 +01:00
pat_syntax_mapping: FxHashMap::default(),
Introduce ArenaMap
2019-01-06 23:57:39 +01:00
pat_syntax_mapping_back: ArenaMap::default(),
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
params: Vec::new(),
body_expr: None,
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.
2019-01-05 22:37:59 +01:00
}
}
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
fn alloc_expr(&mut self, expr: Expr, syntax_ptr: SyntaxNodePtr) -> ExprId {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let id = self.exprs.alloc(expr);
self.expr_syntax_mapping.insert(syntax_ptr, id);
self.expr_syntax_mapping_back.insert(id, syntax_ptr);
id
}
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
fn alloc_pat(&mut self, pat: Pat, syntax_ptr: SyntaxNodePtr) -> PatId {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let id = self.pats.alloc(pat);
self.pat_syntax_mapping.insert(syntax_ptr, id);
self.pat_syntax_mapping_back.insert(id, syntax_ptr);
id
}
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.
2019-01-05 22:37:59 +01:00
fn empty_block(&mut self) -> ExprId {
let block = Expr::Block {
statements: Vec::new(),
tail: None,
};
self.exprs.alloc(block)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
fn collect_expr(&mut self, expr: &ast::Expr) -> ExprId {
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
let syntax_ptr = SyntaxNodePtr::new(expr.syntax());
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
match expr.kind() {
ast::ExprKind::IfExpr(e) => {
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.
2019-01-05 22:37:59 +01:00
if let Some(pat) = e.condition().and_then(|c| c.pat()) {
// 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()
fix AST for if expressions then is not always a block...
2019-01-26 22:23:07 +01:00
.map(|b| match b {
ast::ElseBranchFlavor::Block(it) => self.collect_block(it),
ast::ElseBranchFlavor::IfExpr(elif) => {
let expr: &ast::Expr = ast::Expr::cast(elif.syntax()).unwrap();
self.collect_expr(expr)
}
})
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.
2019-01-05 22:37:59 +01:00
.unwrap_or_else(|| self.empty_block());
let placeholder_pat = self.pats.alloc(Pat::Missing);
let arms = vec![
MatchArm {
pats: vec![pat],
expr: then_branch,
Infer type of match guard
2019-01-28 23:06:11 +01:00
guard: None,
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.
2019-01-05 22:37:59 +01:00
},
MatchArm {
pats: vec![placeholder_pat],
expr: else_branch,
Infer type of match guard
2019-01-28 23:06:11 +01:00
guard: None,
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.
2019-01-05 22:37:59 +01:00
},
];
self.alloc_expr(
Expr::Match {
expr: match_expr,
arms,
},
syntax_ptr,
)
} else {
Various small code review improvements
2019-01-06 00:33:58 +01:00
let condition = self.collect_expr_opt(e.condition().and_then(|c| c.expr()));
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.
2019-01-05 22:37:59 +01:00
let then_branch = self.collect_block_opt(e.then_branch());
fix AST for if expressions then is not always a block...
2019-01-26 22:23:07 +01:00
let else_branch = e.else_branch().map(|b| match b {
ast::ElseBranchFlavor::Block(it) => self.collect_block(it),
ast::ElseBranchFlavor::IfExpr(elif) => {
let expr: &ast::Expr = ast::Expr::cast(elif.syntax()).unwrap();
self.collect_expr(expr)
}
});
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.
2019-01-05 22:37:59 +01:00
self.alloc_expr(
Expr::If {
condition,
then_branch,
else_branch,
},
syntax_ptr,
)
}
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::BlockExpr(e) => self.collect_block_opt(e.block()),
ast::ExprKind::LoopExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let body = self.collect_block_opt(e.loop_body());
self.alloc_expr(Expr::Loop { body }, syntax_ptr)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::WhileExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let condition = if let Some(condition) = e.condition() {
if condition.pat().is_none() {
self.collect_expr_opt(condition.expr())
} else {
// TODO handle while let
return self.alloc_expr(Expr::Missing, syntax_ptr);
}
} else {
self.exprs.alloc(Expr::Missing)
};
let body = self.collect_block_opt(e.loop_body());
self.alloc_expr(Expr::While { condition, body }, syntax_ptr)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::ForExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let iterable = self.collect_expr_opt(e.iterable());
let pat = self.collect_pat_opt(e.pat());
let body = self.collect_block_opt(e.loop_body());
self.alloc_expr(
Expr::For {
iterable,
pat,
body,
},
syntax_ptr,
)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::CallExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let callee = self.collect_expr_opt(e.expr());
let args = if let Some(arg_list) = e.arg_list() {
arg_list.args().map(|e| self.collect_expr(e)).collect()
} else {
Vec::new()
};
self.alloc_expr(Expr::Call { callee, args }, syntax_ptr)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::MethodCallExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let receiver = self.collect_expr_opt(e.expr());
let args = if let Some(arg_list) = e.arg_list() {
arg_list.args().map(|e| self.collect_expr(e)).collect()
} else {
Vec::new()
};
let method_name = e
.name_ref()
.map(|nr| nr.as_name())
.unwrap_or_else(Name::missing);
self.alloc_expr(
Expr::MethodCall {
receiver,
method_name,
args,
},
syntax_ptr,
)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::MatchExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let expr = self.collect_expr_opt(e.expr());
let arms = if let Some(match_arm_list) = e.match_arm_list() {
match_arm_list
.arms()
.map(|arm| MatchArm {
pats: arm.pats().map(|p| self.collect_pat(p)).collect(),
expr: self.collect_expr_opt(arm.expr()),
Add test for passing on ref expectations
2019-01-30 21:14:26 +01:00
guard: arm
.guard()
.and_then(|guard| guard.expr())
.map(|e| self.collect_expr(e)),
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
})
.collect()
} else {
Vec::new()
};
self.alloc_expr(Expr::Match { expr, arms }, syntax_ptr)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::PathExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let path = e
.path()
.and_then(Path::from_ast)
.map(Expr::Path)
.unwrap_or(Expr::Missing);
self.alloc_expr(path, syntax_ptr)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::ContinueExpr(_e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
// TODO: labels
self.alloc_expr(Expr::Continue, syntax_ptr)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::BreakExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let expr = e.expr().map(|e| self.collect_expr(e));
self.alloc_expr(Expr::Break { expr }, syntax_ptr)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::ParenExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let inner = self.collect_expr_opt(e.expr());
// make the paren expr point to the inner expression as well
self.expr_syntax_mapping.insert(syntax_ptr, inner);
inner
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::ReturnExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let expr = e.expr().map(|e| self.collect_expr(e));
self.alloc_expr(Expr::Return { expr }, syntax_ptr)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::StructLit(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let path = e.path().and_then(Path::from_ast);
let fields = if let Some(nfl) = e.named_field_list() {
nfl.fields()
.map(|field| StructLitField {
name: field
.name_ref()
.map(|nr| nr.as_name())
.unwrap_or_else(Name::missing),
expr: if let Some(e) = field.expr() {
self.collect_expr(e)
} else if let Some(nr) = field.name_ref() {
// field shorthand
let id = self.exprs.alloc(Expr::Path(Path::from_name_ref(nr)));
self.expr_syntax_mapping
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
.insert(SyntaxNodePtr::new(nr.syntax()), id);
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
self.expr_syntax_mapping_back
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
.insert(id, SyntaxNodePtr::new(nr.syntax()));
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
id
} else {
self.exprs.alloc(Expr::Missing)
},
})
.collect()
} else {
Vec::new()
};
let spread = e.spread().map(|s| self.collect_expr(s));
self.alloc_expr(
Expr::StructLit {
path,
fields,
spread,
},
syntax_ptr,
)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::FieldExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let expr = self.collect_expr_opt(e.expr());
let name = e
.name_ref()
.map(|nr| nr.as_name())
.unwrap_or_else(Name::missing);
self.alloc_expr(Expr::Field { expr, name }, syntax_ptr)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::TryExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let expr = self.collect_expr_opt(e.expr());
self.alloc_expr(Expr::Try { expr }, syntax_ptr)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::CastExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let expr = self.collect_expr_opt(e.expr());
let type_ref = TypeRef::from_ast_opt(e.type_ref());
self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::RefExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let expr = self.collect_expr_opt(e.expr());
let mutability = Mutability::from_mutable(e.is_mut());
self.alloc_expr(Expr::Ref { expr, mutability }, syntax_ptr)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::PrefixExpr(e) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let expr = self.collect_expr_opt(e.expr());
Implement rudimentary type inference for unary operators
2019-01-14 23:15:16 +01:00
if let Some(op) = e.op() {
self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
} else {
self.alloc_expr(Expr::Missing, syntax_ptr)
}
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::LambdaExpr(e) => {
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.
2019-01-05 22:37:59 +01:00
let mut args = Vec::new();
let mut arg_types = Vec::new();
if let Some(pl) = e.param_list() {
for param in pl.params() {
let pat = self.collect_pat_opt(param.pat());
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,
)
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::BinExpr(e) => {
Use HIR Expr for type inference Now we can reuse the type inference inside a function when typing whitespace etc. :)
2019-01-06 16:47:59 +01:00
let lhs = self.collect_expr_opt(e.lhs());
let rhs = self.collect_expr_opt(e.rhs());
let op = e.op();
self.alloc_expr(Expr::BinaryOp { lhs, rhs, op }, syntax_ptr)
}
Implement tuple inference
2019-01-13 13:00:27 +01:00
ast::ExprKind::TupleExpr(e) => {
let exprs = e.exprs().map(|expr| self.collect_expr(expr)).collect();
self.alloc_expr(Expr::Tuple { exprs }, syntax_ptr)
}
Implement array inference
2019-01-13 14:46:36 +01:00
ast::ExprKind::ArrayExpr(e) => {
let exprs = e.exprs().map(|expr| self.collect_expr(expr)).collect();
self.alloc_expr(Expr::Array { exprs }, syntax_ptr)
}
Fixup tests
2019-01-14 19:30:21 +01:00
ast::ExprKind::Literal(e) => {
let child = if let Some(child) = e.literal_expr() {
child
} else {
return self.alloc_expr(Expr::Missing, syntax_ptr);
};
let lit = match child.flavor() {
LiteralFlavor::IntNumber { suffix } => {
let known_name = suffix
.map(|s| Name::new(s))
.and_then(|name| UncertainIntTy::from_name(&name));
Address issues found in review
2019-01-14 21:52:08 +01:00
Literal::Int(
Default::default(),
known_name.unwrap_or(UncertainIntTy::Unknown),
)
Fixup tests
2019-01-14 19:30:21 +01:00
}
LiteralFlavor::FloatNumber { suffix } => {
let known_name = suffix
.map(|s| Name::new(s))
.and_then(|name| UncertainFloatTy::from_name(&name));
Address issues found in review
2019-01-14 21:52:08 +01:00
Literal::Float(
Default::default(),
known_name.unwrap_or(UncertainFloatTy::Unknown),
)
Fixup tests
2019-01-14 19:30:21 +01:00
}
Give literal expression default values for now
2019-01-14 19:46:10 +01:00
LiteralFlavor::ByteString => Literal::ByteString(Default::default()),
LiteralFlavor::String => Literal::String(Default::default()),
Fixup tests
2019-01-14 19:30:21 +01:00
LiteralFlavor::Byte => {
Give literal expression default values for now
2019-01-14 19:46:10 +01:00
Literal::Int(Default::default(), UncertainIntTy::Unsigned(UintTy::U8))
Fixup tests
2019-01-14 19:30:21 +01:00
}
Give literal expression default values for now
2019-01-14 19:46:10 +01:00
LiteralFlavor::Bool => Literal::Bool(Default::default()),
LiteralFlavor::Char => Literal::Char(Default::default()),
Fixup tests
2019-01-14 19:30:21 +01:00
};
self.alloc_expr(Expr::Literal(lit), syntax_ptr)
Implement type inference for literals (WIP)
2019-01-10 13:54:58 +01:00
}
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
// TODO implement HIR for these:
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::ExprKind::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
ast::ExprKind::IndexExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
ast::ExprKind::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
fn collect_expr_opt(&mut self, expr: Option<&ast::Expr>) -> ExprId {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
if let Some(expr) = expr {
self.collect_expr(expr)
} else {
self.exprs.alloc(Expr::Missing)
}
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
fn collect_block(&mut self, block: &ast::Block) -> ExprId {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let statements = block
.statements()
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
.map(|s| match s.kind() {
ast::StmtKind::LetStmt(stmt) => {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let pat = self.collect_pat_opt(stmt.pat());
let type_ref = stmt.type_ref().map(TypeRef::from_ast);
let initializer = stmt.initializer().map(|e| self.collect_expr(e));
Statement::Let {
pat,
type_ref,
initializer,
}
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::StmtKind::ExprStmt(stmt) => {
Statement::Expr(self.collect_expr_opt(stmt.expr()))
}
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
})
.collect();
let tail = block.expr().map(|e| self.collect_expr(e));
self.alloc_expr(
Expr::Block { statements, tail },
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
SyntaxNodePtr::new(block.syntax()),
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
)
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
fn collect_block_opt(&mut self, block: Option<&ast::Block>) -> ExprId {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
if let Some(block) = block {
self.collect_block(block)
} else {
self.exprs.alloc(Expr::Missing)
}
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
fn collect_pat(&mut self, pat: &ast::Pat) -> PatId {
Add additional pattern variants
2019-01-15 15:24:04 +01:00
let pattern = match pat.kind() {
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::PatKind::BindPat(bp) => {
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.
2019-01-05 22:37:59 +01:00
let name = bp
.name()
.map(|nr| nr.as_name())
.unwrap_or_else(Name::missing);
Add initial (flawed) implementation of binding annotations
2019-01-17 13:08:18 +01:00
let annotation = BindingAnnotation::new(bp.is_mutable(), bp.is_ref());
Fixup annotated bindings
2019-01-17 13:40:45 +01:00
let subpat = bp.pat().map(|subpat| self.collect_pat(subpat));
Add initial (flawed) implementation of binding annotations
2019-01-17 13:08:18 +01:00
Pat::Bind {
name,
mode: annotation,
Fixup annotated bindings
2019-01-17 13:40:45 +01:00
subpat,
Add initial (flawed) implementation of binding annotations
2019-01-17 13:08:18 +01:00
}
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.
2019-01-05 22:37:59 +01:00
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
ast::PatKind::TupleStructPat(p) => {
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.
2019-01-05 22:37:59 +01:00
let path = p.path().and_then(Path::from_ast);
let args = p.args().map(|p| self.collect_pat(p)).collect();
Add additional pattern variants
2019-01-15 15:24:04 +01:00
Pat::TupleStruct { path, args }
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.
2019-01-05 22:37:59 +01:00
}
support ref-patterns
2019-01-13 11:34:57 +01:00
ast::PatKind::RefPat(p) => {
let pat = self.collect_pat_opt(p.pat());
let mutability = Mutability::from_mutable(p.is_mut());
Add additional pattern variants
2019-01-15 15:24:04 +01:00
Pat::Ref { pat, mutability }
support ref-patterns
2019-01-13 11:34:57 +01:00
}
Add additional pattern variants
2019-01-15 15:24:04 +01:00
ast::PatKind::PathPat(p) => {
let path = p.path().and_then(Path::from_ast);
path.map(|path| Pat::Path(path)).unwrap_or(Pat::Missing)
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.
2019-01-05 22:37:59 +01:00
}
Add additional pattern variants
2019-01-15 15:24:04 +01:00
ast::PatKind::TuplePat(p) => {
let args = p.args().map(|p| self.collect_pat(p)).collect();
Pat::Tuple(args)
}
ast::PatKind::PlaceholderPat(_) => Pat::Wild,
Create struct patterns up to the hir level
2019-01-16 19:35:27 +01:00
ast::PatKind::StructPat(p) => {
let path = p.path().and_then(Path::from_ast);
Change parsing of struct field patterns
2019-01-19 01:02:38 +01:00
let field_pat_list = p
Get basic struct pattern type inference working!
2019-01-16 20:26:58 +01:00
.field_pat_list()
Change parsing of struct field patterns
2019-01-19 01:02:38 +01:00
.expect("every struct should have a field list");
let mut fields: Vec<_> = field_pat_list
.bind_pats()
.map(|bind_pat| {
let ast_pat = ast::Pat::cast(bind_pat.syntax()).expect("bind pat is a pat");
Move parsing of field pattern lists to the parser (where it belongs)
2019-01-18 14:52:31 +01:00
let pat = self.collect_pat(ast_pat);
Change parsing of struct field patterns
2019-01-19 01:02:38 +01:00
let name = bind_pat.name().expect("bind pat has a name").as_name();
Implement unlabeled struct field pattern inference
2019-01-17 00:08:10 +01:00
FieldPat { name, pat }
Get basic struct pattern type inference working!
2019-01-16 20:26:58 +01:00
})
.collect();
Change parsing of struct field patterns
2019-01-19 01:02:38 +01:00
let iter = field_pat_list.field_pats().map(|f| {
let ast_pat = f.pat().expect("field pat always contains a pattern");
let pat = self.collect_pat(ast_pat);
let name = f.name().expect("field pats always have a name").as_name();
FieldPat { name, pat }
});
fields.extend(iter);
Get basic struct pattern type inference working!
2019-01-16 20:26:58 +01:00
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
Pat::Struct { path, args: fields }
Create struct patterns up to the hir level
2019-01-16 19:35:27 +01:00
}
Add additional pattern variants
2019-01-15 15:24:04 +01:00
// TODO: implement
Create struct patterns up to the hir level
2019-01-16 19:35:27 +01:00
ast::PatKind::SlicePat(_) | ast::PatKind::RangePat(_) => Pat::Missing,
Add additional pattern variants
2019-01-15 15:24:04 +01:00
};
move SyntaxPtr to ra_syntax
2019-01-23 15:37:10 +01:00
let syntax_ptr = SyntaxNodePtr::new(pat.syntax());
Add additional pattern variants
2019-01-15 15:24:04 +01:00
self.alloc_pat(pattern, syntax_ptr)
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
migrate ra_hir to rowan 2.0
2019-01-08 09:28:42 +01:00
fn collect_pat_opt(&mut self, pat: Option<&ast::Pat>) -> PatId {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
if let Some(pat) = pat {
self.collect_pat(pat)
} else {
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.
2019-01-05 22:37:59 +01:00
self.pats.alloc(Pat::Missing)
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
}
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
fn collect_fn_body(&mut self, node: &ast::FnDef) {
if let Some(param_list) = node.param_list() {
if let Some(self_param) = param_list.self_param() {
let self_param = SyntaxNodePtr::new(
self_param
.self_kw()
.expect("self param without self keyword")
.syntax(),
);
let param_pat = self.alloc_pat(
Pat::Bind {
name: Name::self_param(),
mode: BindingAnnotation::Unannotated,
subpat: None,
},
self_param,
);
self.params.push(param_pat);
}
for param in param_list.params() {
let pat = if let Some(pat) = param.pat() {
pat
} else {
continue;
};
let param_pat = self.collect_pat(pat);
self.params.push(param_pat);
}
};
let body = self.collect_block_opt(node.body());
self.body_expr = Some(body);
}
fn into_body_syntax_mapping(self) -> BodySyntaxMapping {
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
let body = Body {
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
owner: self.owner,
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
exprs: self.exprs,
pats: self.pats,
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
params: self.params,
body_expr: self.body_expr.expect("A body should have been collected"),
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
};
BodySyntaxMapping {
body: Arc::new(body),
expr_syntax_mapping: self.expr_syntax_mapping,
expr_syntax_mapping_back: self.expr_syntax_mapping_back,
pat_syntax_mapping: self.pat_syntax_mapping,
pat_syntax_mapping_back: self.pat_syntax_mapping_back,
}
}
}
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
pub(crate) fn body_syntax_mapping(db: &impl HirDatabase, func: Function) -> Arc<BodySyntaxMapping> {
let mut collector = ExprCollector::new(func);
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.
2019-01-05 22:37:59 +01:00
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
// TODO: consts, etc.
collector.collect_fn_body(&func.source(db).1);
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.
2019-01-05 22:37:59 +01:00
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
Arc::new(collector.into_body_syntax_mapping())
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.
2019-01-05 22:37:59 +01:00
}
Implement methods to build a resolver
2019-01-23 23:08:41 +01:00
#[cfg(test)]
pub(crate) fn collect_fn_body_syntax(function: Function, node: &ast::FnDef) -> BodySyntaxMapping {
let mut collector = ExprCollector::new(function);
collector.collect_fn_body(node);
collector.into_body_syntax_mapping()
Add HIR Expr machinery
2019-01-05 16:32:07 +01:00
}
Reference in a new issue Copy permalink