Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2025-01-02 16:28:46 +00:00
Code Issues Projects Releases Packages Wiki Activity
rust-analyzer/crates/ra_hir/src/expr.rs

1166 lines
41 KiB
Rust
Raw Normal View History

Various small code review improvements
2019-01-05 23:33:58 +00:00
use std::ops::Index;
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
use std::sync::Arc;
use rustc_hash::FxHashMap;
allow rustfmt to reorder imports This wasn't a right decision in the first place, the feature flag was broken in the last rustfmt release, and syntax highlighting of imports is more important anyway
2019-07-04 20:05:17 +00:00
use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
move SyntaxPtr to ra_syntax
2019-01-23 14:37:10 +00:00
use ra_syntax::{
allow rustfmt to reorder imports This wasn't a right decision in the first place, the feature flag was broken in the last rustfmt release, and syntax highlighting of imports is more important anyway
2019-07-04 20:05:17 +00:00
ast::{
self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, NameOwner,
remove useless trait
2019-09-02 16:45:41 +00:00
TypeAscriptionOwner,
allow rustfmt to reorder imports This wasn't a right decision in the first place, the feature flag was broken in the last rustfmt release, and syntax highlighting of imports is more important anyway
2019-07-04 20:05:17 +00:00
},
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
AstNode, AstPtr,
move SyntaxPtr to ra_syntax
2019-01-23 14:37:10 +00:00
};
implement while let desugaring
2019-08-07 13:14:22 +00:00
use test_utils::tested_by;
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
Functions use new id scheme
2019-01-24 12:28:50 +00:00
use crate::{
Constify KnownName's
2019-07-07 21:29:38 +00:00
name::{AsName, SELF_PARAM},
implement while let desugaring
2019-08-07 13:14:22 +00:00
path::GenericArgs,
ty::primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy},
Functions use new id scheme
2019-01-24 12:28:50 +00:00
type_ref::{Mutability, TypeRef},
allow rustfmt to reorder imports This wasn't a right decision in the first place, the feature flag was broken in the last rustfmt release, and syntax highlighting of imports is more important anyway
2019-07-04 20:05:17 +00:00
DefWithBody, Either, HasSource, HirDatabase, HirFileId, MacroCallLoc, MacroFileKind, Name,
Path, Resolver,
};
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
move ScopeEntryWithSyntax
2019-04-13 08:24:09 +00:00
pub use self::scope::ExprScopes;
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 18:47:56 +00:00
Sketching the resolver API
2019-01-19 20:23:26 +00:00
pub(crate) mod scope;
fill struct fields diagnostic
2019-04-10 21:00:56 +00:00
pub(crate) mod validation;
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 18:47:56 +00:00
Add HIR Expr machinery
2019-01-05 15:32:07 +00: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 {
Added const bodies and static body to the ast and added inference the inference test reduce code duplication
2019-03-30 11:17:31 +00:00
/// The def of the item this body belongs to
Added defWithBody
2019-03-30 10:50:00 +00:00
owner: DefWithBody,
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
exprs: Arena<ExprId, Expr>,
pats: Arena<PatId, Pat>,
args -> params
2019-01-12 20:58:16 +00:00
/// The patterns for the function's parameters. While the parameter types are
Add HIR Expr machinery
2019-01-05 15:32:07 +00: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 21:37:59 +00:00
/// If this `Body` is for the body of a constant, this will just be
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
/// empty.
args -> params
2019-01-12 20:58:16 +00:00
params: Vec<PatId>,
Add HIR Expr machinery
2019-01-05 15:32:07 +00: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-08 23:47:12 +00:00
/// file, so that we don't recompute types whenever some whitespace is typed.
dont store body inside source map
2019-03-02 13:18:40 +00:00
#[derive(Default, Debug, Eq, PartialEq)]
rename syntax-mapping -> source-map
2019-03-02 12:14:37 +00:00
pub struct BodySourceMap {
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
expr_map: FxHashMap<ExprPtr, ExprId>,
expr_map_back: ArenaMap<ExprId, ExprPtr>,
fix typo
2019-04-11 08:13:31 +00:00
pat_map: FxHashMap<PatPtr, PatId>,
pat_map_back: ArenaMap<PatId, PatPtr>,
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
field_map: FxHashMap<(ExprId, usize), AstPtr<ast::RecordField>>,
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
type ExprPtr = Either<AstPtr<ast::Expr>, AstPtr<ast::RecordField>>;
fix typo
2019-04-11 08:13:31 +00:00
type PatPtr = Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>;
type-safer source-map for bindings
2019-04-10 07:46:43 +00: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 21:37:59 +00:00
impl Body {
args -> params
2019-01-12 20:58:16 +00: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 21:37:59 +00:00
}
pub fn body_expr(&self) -> ExprId {
self.body_expr
}
Sketching the resolver API
2019-01-19 20:23:26 +00:00
Added defWithBody
2019-03-30 10:50:00 +00:00
pub fn owner(&self) -> DefWithBody {
Implement methods to build a resolver
2019-01-23 22:08:41 +00:00
self.owner
Sketching the resolver API
2019-01-19 20:23:26 +00:00
}
Use the new Resolver API for goto def
2019-01-29 19:49:31 +00:00
Add an ra_cli command that analyses all crates in the current workspace ... and prints various stats about how many expressions have a type etc.
2019-02-09 17:27:11 +00:00
pub fn exprs(&self) -> impl Iterator<Item = (ExprId, &Expr)> {
self.exprs.iter()
}
pub fn pats(&self) -> impl Iterator<Item = (PatId, &Pat)> {
self.pats.iter()
}
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 21:37:59 +00:00
}
Implement methods to build a resolver
2019-01-23 22:08:41 +00:00
// needs arbitrary_self_types to be a method... or maybe move to the def?
make resolver private
2019-04-13 08:02:23 +00:00
pub(crate) fn resolver_for_expr(
body: Arc<Body>,
db: &impl HirDatabase,
expr_id: ExprId,
) -> Resolver {
Use the new Resolver API in completion
2019-01-27 19:50:57 +00:00
let scopes = db.expr_scopes(body.owner);
resolver_for_scope(body, db, scopes.scope_for(expr_id))
}
make resolver private
2019-04-13 08:02:23 +00:00
pub(crate) fn resolver_for_scope(
Use the new Resolver API in completion
2019-01-27 19:50:57 +00:00
body: Arc<Body>,
db: &impl HirDatabase,
scope_id: Option<scope::ScopeId>,
Cleanup
2019-01-27 16:23:49 +00:00
) -> Resolver {
Implement methods to build a resolver
2019-01-23 22:08:41 +00:00
let mut r = body.owner.resolver(db);
let scopes = db.expr_scopes(body.owner);
fold ScopeWithSyntax into SourceAnalyzer
2019-04-13 07:49:01 +00:00
let scope_chain = scopes.scope_chain(scope_id).collect::<Vec<_>>();
Implement methods to build a resolver
2019-01-23 22:08:41 +00: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-05 23:33:58 +00: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]
}
}
rename syntax-mapping -> source-map
2019-03-02 12:14:37 +00:00
impl BodySourceMap {
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
pub(crate) fn expr_syntax(&self, expr: ExprId) -> Option<ExprPtr> {
dont store body inside source map
2019-03-02 13:18:40 +00:00
self.expr_map_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 21:37:59 +00: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-08 23:47:12 +00:00
introduce SourceAnalyzer
2019-04-10 08:15:55 +00:00
pub(crate) fn node_expr(&self, node: &ast::Expr) -> Option<ExprId> {
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
self.expr_map.get(&Either::A(AstPtr::new(node))).cloned()
Use HIR Expr for type inference Now we can reuse the type inference inside a function when typing whitespace etc. :)
2019-01-06 15:47:59 +00: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-08 23:47:12 +00:00
introduce SourceAnalyzer
2019-04-10 08:15:55 +00:00
pub(crate) fn pat_syntax(&self, pat: PatId) -> Option<PatPtr> {
dont store body inside source map
2019-03-02 13:18:40 +00:00
self.pat_map_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 21:37:59 +00: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-08 23:47:12 +00:00
introduce SourceAnalyzer
2019-04-10 08:15:55 +00:00
pub(crate) fn node_pat(&self, node: &ast::Pat) -> Option<PatId> {
type-safer source-map for bindings
2019-04-10 07:46:43 +00:00
self.pat_map.get(&Either::A(AstPtr::new(node))).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 21:37:59 +00:00
}
diagnostics
2019-03-21 19:13:11 +00:00
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
pub(crate) fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr<ast::RecordField> {
Some clippy fixes for 1.36
2019-07-04 17:26:44 +00:00
self.field_map[&(expr, field)]
diagnostics
2019-03-21 19:13:11 +00: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 21:37:59 +00:00
}
Implement type inference for literals (WIP)
2019-01-10 12:54:58 +00: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 15:03:15 +00:00
Int(u64, UncertainIntTy),
Float(u64, UncertainFloatTy), // FIXME: f64 is not Eq
Implement type inference for literals (WIP)
2019-01-10 12:54:58 +00:00
}
Add HIR Expr machinery
2019-01-05 15:32:07 +00: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>,
Handle generic args for method calls
2019-02-16 22:05:57 +00:00
generic_args: Option<GenericArgs>,
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
},
Match {
expr: ExprId,
arms: Vec<MatchArm>,
},
Continue,
Break {
expr: Option<ExprId>,
},
Return {
expr: Option<ExprId>,
},
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
RecordLit {
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
path: Option<Path>,
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
fields: Vec<RecordLitField>,
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
spread: Option<ExprId>,
},
Field {
expr: ExprId,
name: Name,
},
add await expr to ast
2019-07-20 10:35:49 +00:00
Await {
expr: ExprId,
},
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
Try {
expr: ExprId,
},
[#1083] Try block syntax
2019-06-06 11:36:16 +00:00
TryBlock {
body: ExprId,
},
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
Cast {
expr: ExprId,
type_ref: TypeRef,
},
Ref {
expr: ExprId,
mutability: Mutability,
},
UnaryOp {
expr: ExprId,
Implement rudimentary type inference for unary operators
2019-01-14 22:15:16 +00:00
op: UnaryOp,
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
},
Use HIR Expr for type inference Now we can reuse the type inference inside a function when typing whitespace etc. :)
2019-01-06 15:47:59 +00:00
BinaryOp {
lhs: ExprId,
rhs: ExprId,
op: Option<BinaryOp>,
},
implement initial type inference for index expressions
2019-08-17 15:05:20 +00:00
Index {
base: ExprId,
index: 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 21:37:59 +00:00
Lambda {
args: Vec<PatId>,
arg_types: Vec<Option<TypeRef>>,
body: ExprId,
},
Implement tuple inference
2019-01-13 12:00:27 +00:00
Tuple {
exprs: Vec<ExprId>,
},
Added ArrayExprKind, changed the display for fixed array types, Added Array Enum to ra_hir/expr
2019-04-04 22:29:21 +00:00
Array(Array),
Implement type inference for literals (WIP)
2019-01-10 12:54:58 +00:00
Literal(Literal),
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
Introduce separate hir::BinaryOp Unlike ast::BinOp, it has significantly more structure to it, so it's easier to, say, handle all assignment-like operations in the same way.
2019-08-17 14:42:41 +00:00
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum BinaryOp {
LogicOp(LogicOp),
ArithOp(ArithOp),
CmpOp(CmpOp),
Assignment { op: Option<ArithOp> },
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicOp {
And,
Or,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum CmpOp {
normalize ordering ops
2019-08-17 14:51:01 +00:00
Eq { negated: bool },
Ord { ordering: Ordering, strict: bool },
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum Ordering {
Introduce separate hir::BinaryOp Unlike ast::BinOp, it has significantly more structure to it, so it's easier to, say, handle all assignment-like operations in the same way.
2019-08-17 14:42:41 +00:00
Less,
Greater,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum ArithOp {
Add,
Mul,
Sub,
Div,
Rem,
Shl,
Shr,
BitXor,
BitOr,
BitAnd,
}
allow rustfmt to reorder imports This wasn't a right decision in the first place, the feature flag was broken in the last rustfmt release, and syntax highlighting of imports is more important anyway
2019-07-04 20:05:17 +00:00
pub use ra_syntax::ast::PrefixOp as UnaryOp;
Added ArrayExprKind, changed the display for fixed array types, Added Array Enum to ra_hir/expr
2019-04-04 22:29:21 +00:00
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Array {
ElementList(Vec<ExprId>),
Repeat { initializer: ExprId, repeat: ExprId },
}
Add HIR Expr machinery
2019-01-05 15:32:07 +00: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 21:37:59 +00:00
pub pats: Vec<PatId>,
Infer type of match guard
2019-01-28 22:06:11 +00: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 21:37:59 +00:00
pub expr: ExprId,
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
#[derive(Debug, Clone, Eq, PartialEq)]
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
pub struct RecordLitField {
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 21:37:59 +00:00
pub name: Name,
pub expr: ExprId,
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Statement {
reformat the world
2019-02-08 11:49:43 +00:00
Let { pat: PatId, type_ref: Option<TypeRef>, initializer: Option<ExprId> },
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
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 21:37:59 +00:00
impl Expr {
pub fn walk_child_exprs(&self, mut f: impl FnMut(ExprId)) {
match self {
Expr::Missing => {}
Expr::Path(_) => {}
reformat the world
2019-02-08 11:49:43 +00:00
Expr::If { condition, then_branch, else_branch } => {
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 21:37:59 +00:00
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);
}
}
[#1083] Try block syntax
2019-06-06 11:36:16 +00:00
Expr::TryBlock { body } => f(*body),
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 21:37:59 +00:00
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);
}
}
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
Expr::RecordLit { fields, spread, .. } => {
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 21:37:59 +00:00
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 15:47:59 +00:00
Expr::BinaryOp { lhs, rhs, .. } => {
f(*lhs);
f(*rhs);
}
implement initial type inference for index expressions
2019-08-17 15:05:20 +00:00
Expr::Index { base, index } => {
f(*base);
f(*index);
}
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 21:37:59 +00:00
Expr::Field { expr, .. }
add await expr to ast
2019-07-20 10:35:49 +00:00
| Expr::Await { 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 21:37:59 +00:00
| Expr::Try { expr }
| Expr::Cast { expr, .. }
| Expr::Ref { expr, .. }
| Expr::UnaryOp { expr, .. } => {
f(*expr);
}
Added inference of array length
2019-04-03 22:23:58 +00:00
Expr::Tuple { exprs } => {
Implement tuple inference
2019-01-13 12:00:27 +00:00
for expr in exprs {
f(*expr);
}
}
Added ArrayExprKind, changed the display for fixed array types, Added Array Enum to ra_hir/expr
2019-04-04 22:29:21 +00:00
Expr::Array(a) => match a {
Array::ElementList(exprs) => {
for expr in exprs {
f(*expr);
}
Added inference of array length
2019-04-03 22:23:58 +00:00
}
Added ArrayExprKind, changed the display for fixed array types, Added Array Enum to ra_hir/expr
2019-04-04 22:29:21 +00:00
Array::Repeat { initializer, repeat } => {
f(*initializer);
f(*repeat)
Added inference of array length
2019-04-03 22:23:58 +00:00
}
Added ArrayExprKind, changed the display for fixed array types, Added Array Enum to ra_hir/expr
2019-04-04 22:29:21 +00:00
},
don't try to treat arrays and tuples as literals
2019-01-11 08:47:31 +00: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 21:37:59 +00:00
}
}
}
Add HIR Expr machinery
2019-01-05 15:32:07 +00: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 12:08:18 +00: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 18:35:27 +00:00
#[derive(Debug, Clone, Eq, PartialEq)]
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
pub struct RecordFieldPat {
Get basic struct pattern type inference working!
2019-01-16 19:26:58 +00:00
pub(crate) name: Name,
Implement unlabeled struct field pattern inference
2019-01-16 23:08:10 +00:00
pub(crate) pat: PatId,
Create struct patterns up to the hir level
2019-01-16 18:35:27 +00:00
}
Add additional pattern variants
2019-01-15 14:24:04 +00:00
/// Close relative to rustc's hir::PatKind
Add HIR Expr machinery
2019-01-05 15:32:07 +00: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 21:37:59 +00:00
pub enum Pat {
Address issues flagged in review
2019-01-17 23:41:02 +00:00
Missing,
Add additional pattern variants
2019-01-15 14:24:04 +00:00
Wild,
Tuple(Vec<PatId>),
Create struct patterns up to the hir level
2019-01-16 18:35:27 +00:00
Struct {
path: Option<Path>,
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
args: Vec<RecordFieldPat>,
replace todo with fixme
2019-03-23 07:53:48 +00:00
// FIXME: 'ellipsis' option
Create struct patterns up to the hir level
2019-01-16 18:35:27 +00:00
},
Add additional pattern variants
2019-01-15 14:24:04 +00: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 21:37:59 +00:00
Bind {
Add initial (flawed) implementation of binding annotations
2019-01-17 12:08:18 +00: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 21:37:59 +00:00
name: Name,
Fixup annotated bindings
2019-01-17 12:40:45 +00: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 21:37:59 +00:00
},
TupleStruct {
path: Option<Path>,
args: Vec<PatId>,
},
support ref-patterns
2019-01-13 10:34:57 +00: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 21:37:59 +00:00
}
impl Pat {
support ref-patterns
2019-01-13 10:34:57 +00: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 21:37:59 +00:00
match self {
Fixup annotated bindings
2019-01-17 12:40:45 +00:00
Pat::Range { .. } | Pat::Lit(..) | Pat::Path(..) | Pat::Wild | Pat::Missing => {}
Pat::Bind { subpat, .. } => {
Some clippy fixes for 1.36
2019-07-04 17:26:44 +00:00
subpat.iter().copied().for_each(f);
Fixup annotated bindings
2019-01-17 12:40:45 +00:00
}
Add additional pattern variants
2019-01-15 14:24:04 +00:00
Pat::Tuple(args) | Pat::TupleStruct { args, .. } => {
Some clippy fixes for 1.36
2019-07-04 17:26:44 +00:00
args.iter().copied().for_each(f);
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 21:37:59 +00:00
}
Address issues flagged in review
2019-01-17 23:41:02 +00:00
Pat::Ref { pat, .. } => f(*pat),
reformat the world
2019-02-08 11:49:43 +00:00
Pat::Slice { prefix, rest, suffix } => {
Add additional pattern variants
2019-01-15 14:24:04 +00:00
let total_iter = prefix.iter().chain(rest.iter()).chain(suffix.iter());
Some clippy fixes for 1.36
2019-07-04 17:26:44 +00:00
total_iter.copied().for_each(f);
Add additional pattern variants
2019-01-15 14:24:04 +00:00
}
Get basic struct pattern type inference working!
2019-01-16 19:26:58 +00:00
Pat::Struct { args, .. } => {
Implement unlabeled struct field pattern inference
2019-01-16 23:08:10 +00:00
args.iter().map(|f| f.pat).for_each(f);
Get basic struct pattern type inference working!
2019-01-16 19:26:58 +00: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 21:37:59 +00:00
}
}
}
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
// Queries
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
pub(crate) struct ExprCollector<DB> {
db: DB,
Added defWithBody
2019-03-30 10:50:00 +00:00
owner: DefWithBody,
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
exprs: Arena<ExprId, Expr>,
pats: Arena<PatId, Pat>,
dont store body inside source map
2019-03-02 13:18:40 +00:00
source_map: BodySourceMap,
Implement methods to build a resolver
2019-01-23 22:08:41 +00:00
params: Vec<PatId>,
body_expr: Option<ExprId>,
Addeded resolver and db
2019-04-15 09:09:58 +00:00
resolver: Resolver,
Use correct FileId when expanding macros in expressions
2019-05-01 12:53:13 +00:00
// Expr collector expands macros along the way. original points to the file
// we started with, current points to the current macro expansion. source
// maps don't support macros yet, so we only record info into source map if
// current == original (see #1196)
original_file_id: HirFileId,
current_file_id: HirFileId,
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
impl<'a, DB> ExprCollector<&'a DB>
where
DB: HirDatabase,
{
Use correct FileId when expanding macros in expressions
2019-05-01 12:53:13 +00:00
fn new(owner: DefWithBody, file_id: HirFileId, resolver: Resolver, db: &'a DB) -> Self {
Introduced resolve_macro_call on resolver changed to manual expansion fix for nested macros
2019-04-18 18:35:47 +00:00
ExprCollector {
owner,
resolver,
db,
exprs: Arena::default(),
pats: Arena::default(),
source_map: BodySourceMap::default(),
params: Vec::new(),
body_expr: None,
Use correct FileId when expanding macros in expressions
2019-05-01 12:53:13 +00:00
original_file_id: file_id,
current_file_id: file_id,
Introduced resolve_macro_call on resolver changed to manual expansion fix for nested macros
2019-04-18 18:35:47 +00:00
}
}
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
fn alloc_expr(&mut self, expr: Expr, ptr: AstPtr<ast::Expr>) -> ExprId {
let ptr = Either::A(ptr);
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
let id = self.exprs.alloc(expr);
Use correct FileId when expanding macros in expressions
2019-05-01 12:53:13 +00:00
if self.current_file_id == self.original_file_id {
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
self.source_map.expr_map.insert(ptr, id);
self.source_map.expr_map_back.insert(id, ptr);
Introduced resolve_macro_call on resolver changed to manual expansion fix for nested macros
2019-04-18 18:35:47 +00:00
}
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
id
}
fix typo
2019-04-11 08:13:31 +00:00
fn alloc_pat(&mut self, pat: Pat, ptr: PatPtr) -> PatId {
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
let id = self.pats.alloc(pat);
Introduced resolve_macro_call on resolver changed to manual expansion fix for nested macros
2019-04-18 18:35:47 +00:00
Use correct FileId when expanding macros in expressions
2019-05-01 12:53:13 +00:00
if self.current_file_id == self.original_file_id {
Introduced resolve_macro_call on resolver changed to manual expansion fix for nested macros
2019-04-18 18:35:47 +00:00
self.source_map.pat_map.insert(ptr, id);
self.source_map.pat_map_back.insert(id, ptr);
}
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
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 21:37:59 +00:00
fn empty_block(&mut self) -> ExprId {
reformat the world
2019-02-08 11:49:43 +00:00
let block = Expr::Block { statements: Vec::new(), tail: 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 21:37:59 +00:00
self.exprs.alloc(block)
}
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
let syntax_ptr = AstPtr::new(&expr);
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
match expr {
ast::Expr::IfExpr(e) => {
refactor if lowering
2019-08-07 10:32:32 +00:00
let then_branch = self.collect_block_opt(e.then_branch());
refactor if-let lowering mainly to get rid of unwraps
2019-08-07 11:51:54 +00:00
refactor if lowering
2019-08-07 10:32:32 +00:00
let else_branch = e.else_branch().map(|b| match b {
ast::ElseBranch::Block(it) => self.collect_block(it),
ast::ElseBranch::IfExpr(elif) => {
let expr: ast::Expr = ast::Expr::cast(elif.syntax().clone()).unwrap();
self.collect_expr(expr)
}
});
refactor if-let lowering mainly to get rid of unwraps
2019-08-07 11:51:54 +00:00
let condition = match e.condition() {
None => self.exprs.alloc(Expr::Missing),
Some(condition) => match condition.pat() {
None => self.collect_expr_opt(condition.expr()),
// if let -- desugar to match
Some(pat) => {
let pat = self.collect_pat(pat);
let match_expr = self.collect_expr_opt(condition.expr());
let placeholder_pat = self.pats.alloc(Pat::Missing);
let arms = vec![
MatchArm { pats: vec![pat], expr: then_branch, guard: None },
MatchArm {
pats: vec![placeholder_pat],
expr: else_branch.unwrap_or_else(|| self.empty_block()),
guard: None,
},
];
return self
.alloc_expr(Expr::Match { expr: match_expr, arms }, syntax_ptr);
}
},
};
self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr)
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::TryBlockExpr(e) => {
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
let body = self.collect_block_opt(e.body());
[#1083] Try block syntax
2019-06-06 11:36:16 +00:00
self.alloc_expr(Expr::TryBlock { body }, syntax_ptr)
}
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
ast::Expr::BlockExpr(e) => self.collect_block(e),
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::LoopExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let body = self.collect_block_opt(e.loop_body());
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
self.alloc_expr(Expr::Loop { body }, syntax_ptr)
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::WhileExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let body = self.collect_block_opt(e.loop_body());
implement while let desugaring
2019-08-07 13:14:22 +00:00
let condition = match e.condition() {
None => self.exprs.alloc(Expr::Missing),
Some(condition) => match condition.pat() {
None => self.collect_expr_opt(condition.expr()),
// if let -- desugar to match
Some(pat) => {
tested_by!(infer_while_let);
let pat = self.collect_pat(pat);
let match_expr = self.collect_expr_opt(condition.expr());
let placeholder_pat = self.pats.alloc(Pat::Missing);
let break_ = self.exprs.alloc(Expr::Break { expr: None });
let arms = vec![
MatchArm { pats: vec![pat], expr: body, guard: None },
MatchArm { pats: vec![placeholder_pat], expr: break_, guard: None },
];
let match_expr =
self.exprs.alloc(Expr::Match { expr: match_expr, arms });
return self.alloc_expr(Expr::Loop { body: match_expr }, syntax_ptr);
}
},
};
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
self.alloc_expr(Expr::While { condition, body }, syntax_ptr)
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::ForExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let iterable = self.collect_expr_opt(e.iterable());
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
let pat = self.collect_pat_opt(e.pat());
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let body = self.collect_block_opt(e.loop_body());
reformat the world
2019-02-08 11:49:43 +00:00
self.alloc_expr(Expr::For { iterable, pat, body }, syntax_ptr)
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::CallExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let callee = self.collect_expr_opt(e.expr());
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
let args = if let Some(arg_list) = e.arg_list() {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
arg_list.args().map(|e| self.collect_expr(e)).collect()
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
} else {
Vec::new()
};
self.alloc_expr(Expr::Call { callee, args }, syntax_ptr)
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::MethodCallExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let receiver = self.collect_expr_opt(e.expr());
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
let args = if let Some(arg_list) = e.arg_list() {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
arg_list.args().map(|e| self.collect_expr(e)).collect()
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
} else {
Vec::new()
};
reformat the world
2019-02-08 11:49:43 +00:00
let method_name = e.name_ref().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
Handle generic args for method calls
2019-02-16 22:05:57 +00:00
let generic_args = e.type_arg_list().and_then(GenericArgs::from_ast);
self.alloc_expr(
Expr::MethodCall { receiver, method_name, args, generic_args },
syntax_ptr,
)
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::MatchExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let expr = self.collect_expr_opt(e.expr());
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
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(),
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
expr: self.collect_expr_opt(arm.expr()),
Add test for passing on ref expectations
2019-01-30 20:14:26 +00:00
guard: arm
.guard()
.and_then(|guard| guard.expr())
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
.map(|e| self.collect_expr(e)),
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
})
.collect()
} else {
Vec::new()
};
self.alloc_expr(Expr::Match { expr, arms }, syntax_ptr)
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::PathExpr(e) => {
reformat the world
2019-02-08 11:49:43 +00:00
let path =
e.path().and_then(Path::from_ast).map(Expr::Path).unwrap_or(Expr::Missing);
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
self.alloc_expr(path, syntax_ptr)
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::ContinueExpr(_e) => {
replace todo with fixme
2019-03-23 07:53:48 +00:00
// FIXME: labels
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
self.alloc_expr(Expr::Continue, syntax_ptr)
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::BreakExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let expr = e.expr().map(|e| self.collect_expr(e));
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
self.alloc_expr(Expr::Break { expr }, syntax_ptr)
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::ParenExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let inner = self.collect_expr_opt(e.expr());
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
// make the paren expr point to the inner expression as well
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
self.source_map.expr_map.insert(Either::A(syntax_ptr), inner);
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
inner
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::ReturnExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let expr = e.expr().map(|e| self.collect_expr(e));
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
self.alloc_expr(Expr::Return { expr }, syntax_ptr)
}
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
ast::Expr::RecordLit(e) => {
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
let path = e.path().and_then(Path::from_ast);
diagnostics
2019-03-21 19:13:11 +00:00
let mut field_ptrs = Vec::new();
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
let record_lit = if let Some(nfl) = e.record_field_list() {
fill struct fields diagnostic
2019-04-10 21:00:56 +00:00
let fields = nfl
.fields()
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
.inspect(|field| field_ptrs.push(AstPtr::new(field)))
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
.map(|field| RecordLitField {
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
name: field
.name_ref()
.map(|nr| nr.as_name())
.unwrap_or_else(Name::missing),
expr: if let Some(e) = field.expr() {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
self.collect_expr(e)
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
} else if let Some(nr) = field.name_ref() {
// field shorthand
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
let id = self.exprs.alloc(Expr::Path(Path::from_name_ref(&nr)));
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
let ptr = Either::B(AstPtr::new(&field));
self.source_map.expr_map.insert(ptr, id);
self.source_map.expr_map_back.insert(id, ptr);
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
id
} else {
self.exprs.alloc(Expr::Missing)
},
})
fill struct fields diagnostic
2019-04-10 21:00:56 +00:00
.collect();
let spread = nfl.spread().map(|s| self.collect_expr(s));
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
Expr::RecordLit { path, fields, spread }
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
} else {
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
Expr::RecordLit { path, fields: Vec::new(), spread: None }
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
};
fill struct fields diagnostic
2019-04-10 21:00:56 +00:00
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
let res = self.alloc_expr(record_lit, syntax_ptr);
diagnostics
2019-03-21 19:13:11 +00:00
for (i, ptr) in field_ptrs.into_iter().enumerate() {
self.source_map.field_map.insert((res, i), ptr);
}
res
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::FieldExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let expr = self.collect_expr_opt(e.expr());
Parse and infer tuple indices
2019-04-05 20:34:45 +00:00
let name = match e.field_access() {
Some(kind) => kind.as_name(),
_ => Name::missing(),
};
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
self.alloc_expr(Expr::Field { expr, name }, syntax_ptr)
add await expr to ast
2019-07-20 10:35:49 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::AwaitExpr(e) => {
add await expr to ast
2019-07-20 10:35:49 +00:00
let expr = self.collect_expr_opt(e.expr());
self.alloc_expr(Expr::Await { expr }, syntax_ptr)
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::TryExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let expr = self.collect_expr_opt(e.expr());
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
self.alloc_expr(Expr::Try { expr }, syntax_ptr)
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::CastExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let expr = self.collect_expr_opt(e.expr());
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
let type_ref = TypeRef::from_ast_opt(e.type_ref());
self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::RefExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let expr = self.collect_expr_opt(e.expr());
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
let mutability = Mutability::from_mutable(e.is_mut());
self.alloc_expr(Expr::Ref { expr, mutability }, syntax_ptr)
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::PrefixExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let expr = self.collect_expr_opt(e.expr());
Target only the actual operator. Renamed `BinExpr::op()` and `PrefixExpr::op()` to `op_kind`. Now `op()` returns the `SyntaxNode`.
2019-03-24 21:21:22 +00:00
if let Some(op) = e.op_kind() {
Implement rudimentary type inference for unary operators
2019-01-14 22:15:16 +00:00
self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
} else {
self.alloc_expr(Expr::Missing, syntax_ptr)
}
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::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 21:37:59 +00: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());
Remove `TypeRef` from item opts which implement TypeAscriptionOwner
2019-02-27 12:00:08 +00:00
let type_ref = param.ascribed_type().map(TypeRef::from_ast);
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 21:37:59 +00:00
args.push(pat);
arg_types.push(type_ref);
}
}
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let body = self.collect_expr_opt(e.body());
reformat the world
2019-02-08 11:49:43 +00:00
self.alloc_expr(Expr::Lambda { args, arg_types, body }, syntax_ptr)
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::BinExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let lhs = self.collect_expr_opt(e.lhs());
let rhs = self.collect_expr_opt(e.rhs());
Introduce separate hir::BinaryOp Unlike ast::BinOp, it has significantly more structure to it, so it's easier to, say, handle all assignment-like operations in the same way.
2019-08-17 14:42:41 +00:00
let op = e.op_kind().map(BinaryOp::from);
Use HIR Expr for type inference Now we can reuse the type inference inside a function when typing whitespace etc. :)
2019-01-06 15:47:59 +00:00
self.alloc_expr(Expr::BinaryOp { lhs, rhs, op }, syntax_ptr)
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::TupleExpr(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let exprs = e.exprs().map(|expr| self.collect_expr(expr)).collect();
Implement tuple inference
2019-01-13 12:00:27 +00:00
self.alloc_expr(Expr::Tuple { exprs }, syntax_ptr)
}
Added ArrayExprKind, changed the display for fixed array types, Added Array Enum to ra_hir/expr
2019-04-04 22:29:21 +00:00
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::ArrayExpr(e) => {
Added ArrayExprKind, changed the display for fixed array types, Added Array Enum to ra_hir/expr
2019-04-04 22:29:21 +00:00
let kind = e.kind();
match kind {
ArrayExprKind::ElementList(e) => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let exprs = e.map(|expr| self.collect_expr(expr)).collect();
Added ArrayExprKind, changed the display for fixed array types, Added Array Enum to ra_hir/expr
2019-04-04 22:29:21 +00:00
self.alloc_expr(Expr::Array(Array::ElementList(exprs)), syntax_ptr)
}
ArrayExprKind::Repeat { initializer, repeat } => {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let initializer = self.collect_expr_opt(initializer);
let repeat = self.collect_expr_opt(repeat);
Added ArrayExprKind, changed the display for fixed array types, Added Array Enum to ra_hir/expr
2019-04-04 22:29:21 +00:00
self.alloc_expr(
Expr::Array(Array::Repeat { initializer, repeat }),
syntax_ptr,
)
}
}
Implement array inference
2019-01-13 13:46:36 +00:00
}
Added ArrayExprKind, changed the display for fixed array types, Added Array Enum to ra_hir/expr
2019-04-04 22:29:21 +00:00
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::Literal(e) => {
rename flavor to kind
2019-04-02 09:48:14 +00:00
let lit = match e.kind() {
LiteralKind::IntNumber { suffix } => {
Refactor primitive types into more orthogonal representation
2019-03-22 09:09:35 +00:00
let known_name = suffix
.and_then(|it| IntTy::from_suffix(&it).map(UncertainIntTy::Known));
Fixup tests
2019-01-14 18:30:21 +00:00
Address issues found in review
2019-01-14 20:52:08 +00:00
Literal::Int(
Default::default(),
known_name.unwrap_or(UncertainIntTy::Unknown),
)
Fixup tests
2019-01-14 18:30:21 +00:00
}
rename flavor to kind
2019-04-02 09:48:14 +00:00
LiteralKind::FloatNumber { suffix } => {
Refactor primitive types into more orthogonal representation
2019-03-22 09:09:35 +00:00
let known_name = suffix
.and_then(|it| FloatTy::from_suffix(&it).map(UncertainFloatTy::Known));
Fixup tests
2019-01-14 18:30:21 +00:00
Address issues found in review
2019-01-14 20:52:08 +00:00
Literal::Float(
Default::default(),
known_name.unwrap_or(UncertainFloatTy::Unknown),
)
Fixup tests
2019-01-14 18:30:21 +00:00
}
rename flavor to kind
2019-04-02 09:48:14 +00:00
LiteralKind::ByteString => Literal::ByteString(Default::default()),
LiteralKind::String => Literal::String(Default::default()),
LiteralKind::Byte => {
Refactor primitive types into more orthogonal representation
2019-03-22 09:09:35 +00:00
Literal::Int(Default::default(), UncertainIntTy::Known(IntTy::u8()))
Fixup tests
2019-01-14 18:30:21 +00:00
}
rename flavor to kind
2019-04-02 09:48:14 +00:00
LiteralKind::Bool => Literal::Bool(Default::default()),
LiteralKind::Char => Literal::Char(Default::default()),
Fixup tests
2019-01-14 18:30:21 +00:00
};
self.alloc_expr(Expr::Literal(lit), syntax_ptr)
Implement type inference for literals (WIP)
2019-01-10 12:54:58 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::IndexExpr(e) => {
implement initial type inference for index expressions
2019-08-17 15:05:20 +00:00
let base = self.collect_expr_opt(e.base());
let index = self.collect_expr_opt(e.index());
self.alloc_expr(Expr::Index { base, index }, syntax_ptr)
}
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
replace todo with fixme
2019-03-23 07:53:48 +00:00
// FIXME implement HIR for these:
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
ast::Expr::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
ast::Expr::MacroCall(e) => {
Use correct FileId when expanding macros in expressions
2019-05-01 12:53:13 +00:00
let ast_id = self
.db
.ast_id_map(self.current_file_id)
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
.ast_id(&e)
Use correct FileId when expanding macros in expressions
2019-05-01 12:53:13 +00:00
.with_file_id(self.current_file_id);
remove some hacks from nameresolution for macros
2019-06-08 17:42:02 +00:00
if let Some(path) = e.path().and_then(Path::from_ast) {
if let Some(def) = self.resolver.resolve_path_as_macro(self.db, &path) {
let call_id = MacroCallLoc { def: def.id, ast_id }.id(self.db);
let file_id = call_id.as_file(MacroFileKind::Expr);
if let Some(node) = self.db.parse_or_expand(file_id) {
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
if let Some(expr) = ast::Expr::cast(node) {
move debug_dump to fmt::Debug
2019-07-20 09:48:24 +00:00
log::debug!("macro expansion {:#?}", expr.syntax());
remove some hacks from nameresolution for macros
2019-06-08 17:42:02 +00:00
let old_file_id =
std::mem::replace(&mut self.current_file_id, file_id);
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
let id = self.collect_expr(expr);
remove some hacks from nameresolution for macros
2019-06-08 17:42:02 +00:00
self.current_file_id = old_file_id;
return id;
}
introduce macro_arg intermediate query Currently, when expanding macros, we look at the source code directly (we invoke ast_id_to_node query via to_node method). This is less then ideal, because it make us re-expand macros after every source change. This commit establishes a salsa-firewall: a query to get macro call's token tree. Unlike the syntax tree, token tree changes only if we actually modify the macro itself.
2019-05-04 14:38:09 +00:00
}
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
}
}
introduce macro_arg intermediate query Currently, when expanding macros, we look at the source code directly (we invoke ast_id_to_node query via to_node method). This is less then ideal, because it make us re-expand macros after every source change. This commit establishes a salsa-firewall: a query to get macro call's token tree. Unlike the syntax tree, token tree changes only if we actually modify the macro itself.
2019-05-04 14:38:09 +00:00
// FIXME: Instead of just dropping the error from expansion
// report it
self.alloc_expr(Expr::Missing, syntax_ptr)
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
}
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
}
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
fn collect_expr_opt(&mut self, expr: Option<ast::Expr>) -> ExprId {
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
if let Some(expr) = expr {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
self.collect_expr(expr)
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
} else {
self.exprs.alloc(Expr::Missing)
}
}
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
fn collect_block(&mut self, expr: ast::BlockExpr) -> ExprId {
let syntax_node_ptr = AstPtr::new(&expr.clone().into());
let block = match expr.block() {
Some(block) => block,
None => return self.alloc_expr(Expr::Missing, syntax_node_ptr),
};
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
let statements = block
.statements()
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
.map(|s| match s {
ast::Stmt::LetStmt(stmt) => {
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
let pat = self.collect_pat_opt(stmt.pat());
Remove `TypeRef` from item opts which implement TypeAscriptionOwner
2019-02-27 12:00:08 +00:00
let type_ref = stmt.ascribed_type().map(TypeRef::from_ast);
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let initializer = stmt.initializer().map(|e| self.collect_expr(e));
reformat the world
2019-02-08 11:49:43 +00:00
Statement::Let { pat, type_ref, initializer }
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Stmt::ExprStmt(stmt) => Statement::Expr(self.collect_expr_opt(stmt.expr())),
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
})
.collect();
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let tail = block.expr().map(|e| self.collect_expr(e));
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
self.alloc_expr(Expr::Block { statements, tail }, syntax_node_ptr)
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
fix hir for new block syntax
2019-09-02 18:23:19 +00:00
fn collect_block_opt(&mut self, expr: Option<ast::BlockExpr>) -> ExprId {
if let Some(block) = expr {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
self.collect_block(block)
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
} else {
self.exprs.alloc(Expr::Missing)
}
}
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
fn collect_pat(&mut self, pat: ast::Pat) -> PatId {
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
let pattern = match &pat {
ast::Pat::BindPat(bp) => {
reformat the world
2019-02-08 11:49:43 +00: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 12:08:18 +00:00
let annotation = BindingAnnotation::new(bp.is_mutable(), bp.is_ref());
Fixup annotated bindings
2019-01-17 12:40:45 +00:00
let subpat = bp.pat().map(|subpat| self.collect_pat(subpat));
reformat the world
2019-02-08 11:49:43 +00:00
Pat::Bind { name, mode: annotation, subpat }
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 21:37:59 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Pat::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 21:37:59 +00: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 14:24:04 +00: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 21:37:59 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Pat::RefPat(p) => {
support ref-patterns
2019-01-13 10:34:57 +00:00
let pat = self.collect_pat_opt(p.pat());
let mutability = Mutability::from_mutable(p.is_mut());
Add additional pattern variants
2019-01-15 14:24:04 +00:00
Pat::Ref { pat, mutability }
support ref-patterns
2019-01-13 10:34:57 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Pat::PathPat(p) => {
Add additional pattern variants
2019-01-15 14:24:04 +00:00
let path = p.path().and_then(Path::from_ast);
Some clippy cleanups
2019-02-06 20:50:26 +00:00
path.map(Pat::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 21:37:59 +00:00
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Pat::TuplePat(p) => {
Add additional pattern variants
2019-01-15 14:24:04 +00:00
let args = p.args().map(|p| self.collect_pat(p)).collect();
Pat::Tuple(args)
}
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Pat::PlaceholderPat(_) => Pat::Wild,
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
ast::Pat::RecordPat(p) => {
Create struct patterns up to the hir level
2019-01-16 18:35:27 +00:00
let path = p.path().and_then(Path::from_ast);
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
let record_field_pat_list =
p.record_field_pat_list().expect("every struct should have a field list");
let mut fields: Vec<_> = record_field_pat_list
Change parsing of struct field patterns
2019-01-19 00:02:38 +00:00
.bind_pats()
Fix another crash found when analyzing rustc
2019-02-09 19:55:51 +00:00
.filter_map(|bind_pat| {
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
let ast_pat =
ast::Pat::cast(bind_pat.syntax().clone()).expect("bind pat is a pat");
Move parsing of field pattern lists to the parser (where it belongs)
2019-01-18 13:52:31 +00:00
let pat = self.collect_pat(ast_pat);
Fix another crash found when analyzing rustc
2019-02-09 19:55:51 +00:00
let name = bind_pat.name()?.as_name();
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
Some(RecordFieldPat { name, pat })
Get basic struct pattern type inference working!
2019-01-16 19:26:58 +00:00
})
.collect();
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
let iter = record_field_pat_list.record_field_pats().filter_map(|f| {
Fix another crash found when analyzing rustc
2019-02-09 19:55:51 +00:00
let ast_pat = f.pat()?;
Change parsing of struct field patterns
2019-01-19 00:02:38 +00:00
let pat = self.collect_pat(ast_pat);
Fix another crash found when analyzing rustc
2019-02-09 19:55:51 +00:00
let name = f.name()?.as_name();
rename struct -> record, pos -> tuple
2019-08-23 12:55:21 +00:00
Some(RecordFieldPat { name, pat })
Change parsing of struct field patterns
2019-01-19 00:02:38 +00:00
});
fields.extend(iter);
Get basic struct pattern type inference working!
2019-01-16 19:26:58 +00:00
Implement methods to build a resolver
2019-01-23 22:08:41 +00:00
Pat::Struct { path, args: fields }
Create struct patterns up to the hir level
2019-01-16 18:35:27 +00:00
}
replace todo with fixme
2019-03-23 07:53:48 +00:00
// FIXME: implement
Convert `BoxPat` to `Missing` in HIR
2019-08-23 21:07:32 +00:00
ast::Pat::BoxPat(_) => Pat::Missing,
remove ast::*Kind from hir
2019-08-19 11:04:51 +00:00
ast::Pat::LiteralPat(_) => Pat::Missing,
ast::Pat::SlicePat(_) | ast::Pat::RangePat(_) => Pat::Missing,
Add additional pattern variants
2019-01-15 14:24:04 +00:00
};
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
let ptr = AstPtr::new(&pat);
type-safer source-map for bindings
2019-04-10 07:46:43 +00:00
self.alloc_pat(pattern, Either::A(ptr))
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
fn collect_pat_opt(&mut self, pat: Option<ast::Pat>) -> PatId {
Add HIR Expr machinery
2019-01-05 15:32:07 +00: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 21:37:59 +00:00
self.pats.alloc(Pat::Missing)
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
}
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
fn collect_const_body(&mut self, node: ast::ConstDef) {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let body = self.collect_expr_opt(node.body());
Added const bodies and static body to the ast and added inference the inference test reduce code duplication
2019-03-30 11:17:31 +00:00
self.body_expr = Some(body);
Added defWithBody
2019-03-30 10:50:00 +00:00
}
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
fn collect_static_body(&mut self, node: ast::StaticDef) {
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let body = self.collect_expr_opt(node.body());
Added const bodies and static body to the ast and added inference the inference test reduce code duplication
2019-03-30 11:17:31 +00:00
self.body_expr = Some(body);
Added defWithBody
2019-03-30 10:50:00 +00:00
}
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
fn collect_fn_body(&mut self, node: ast::FnDef) {
Implement methods to build a resolver
2019-01-23 22:08:41 +00:00
if let Some(param_list) = node.param_list() {
if let Some(self_param) = param_list.self_param() {
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
let ptr = AstPtr::new(&self_param);
Implement methods to build a resolver
2019-01-23 22:08:41 +00:00
let param_pat = self.alloc_pat(
Pat::Bind {
Constify KnownName's
2019-07-07 21:29:38 +00:00
name: SELF_PARAM,
Implement methods to build a resolver
2019-01-23 22:08:41 +00:00
mode: BindingAnnotation::Unannotated,
subpat: None,
},
type-safer source-map for bindings
2019-04-10 07:46:43 +00:00
Either::B(ptr),
Implement methods to build a resolver
2019-01-23 22:08:41 +00:00
);
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);
}
};
Added macro resolution and expansion
2019-04-15 10:01:29 +00:00
let body = self.collect_block_opt(node.body());
Implement methods to build a resolver
2019-01-23 22:08:41 +00:00
self.body_expr = Some(body);
}
dont store body inside source map
2019-03-02 13:18:40 +00:00
fn finish(self) -> (Body, BodySourceMap) {
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
let body = Body {
Implement methods to build a resolver
2019-01-23 22:08:41 +00:00
owner: self.owner,
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
exprs: self.exprs,
pats: self.pats,
Implement methods to build a resolver
2019-01-23 22:08:41 +00:00
params: self.params,
body_expr: self.body_expr.expect("A body should have been collected"),
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
};
dont store body inside source map
2019-03-02 13:18:40 +00:00
(body, self.source_map)
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
}
Introduce separate hir::BinaryOp Unlike ast::BinOp, it has significantly more structure to it, so it's easier to, say, handle all assignment-like operations in the same way.
2019-08-17 14:42:41 +00:00
impl From<ast::BinOp> for BinaryOp {
fn from(ast_op: ast::BinOp) -> Self {
match ast_op {
ast::BinOp::BooleanOr => BinaryOp::LogicOp(LogicOp::Or),
ast::BinOp::BooleanAnd => BinaryOp::LogicOp(LogicOp::And),
normalize ordering ops
2019-08-17 14:51:01 +00:00
ast::BinOp::EqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: false }),
ast::BinOp::NegatedEqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: true }),
ast::BinOp::LesserEqualTest => {
BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: false })
}
ast::BinOp::GreaterEqualTest => {
BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: false })
}
ast::BinOp::LesserTest => {
BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: true })
}
ast::BinOp::GreaterTest => {
BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: true })
}
Introduce separate hir::BinaryOp Unlike ast::BinOp, it has significantly more structure to it, so it's easier to, say, handle all assignment-like operations in the same way.
2019-08-17 14:42:41 +00:00
ast::BinOp::Addition => BinaryOp::ArithOp(ArithOp::Add),
ast::BinOp::Multiplication => BinaryOp::ArithOp(ArithOp::Mul),
ast::BinOp::Subtraction => BinaryOp::ArithOp(ArithOp::Sub),
ast::BinOp::Division => BinaryOp::ArithOp(ArithOp::Div),
ast::BinOp::Remainder => BinaryOp::ArithOp(ArithOp::Rem),
ast::BinOp::LeftShift => BinaryOp::ArithOp(ArithOp::Shl),
ast::BinOp::RightShift => BinaryOp::ArithOp(ArithOp::Shr),
ast::BinOp::BitwiseXor => BinaryOp::ArithOp(ArithOp::BitXor),
ast::BinOp::BitwiseOr => BinaryOp::ArithOp(ArithOp::BitOr),
ast::BinOp::BitwiseAnd => BinaryOp::ArithOp(ArithOp::BitAnd),
ast::BinOp::Assignment => BinaryOp::Assignment { op: None },
ast::BinOp::AddAssign => BinaryOp::Assignment { op: Some(ArithOp::Add) },
ast::BinOp::DivAssign => BinaryOp::Assignment { op: Some(ArithOp::Div) },
ast::BinOp::MulAssign => BinaryOp::Assignment { op: Some(ArithOp::Mul) },
ast::BinOp::RemAssign => BinaryOp::Assignment { op: Some(ArithOp::Rem) },
ast::BinOp::ShlAssign => BinaryOp::Assignment { op: Some(ArithOp::Shl) },
ast::BinOp::ShrAssign => BinaryOp::Assignment { op: Some(ArithOp::Shr) },
ast::BinOp::SubAssign => BinaryOp::Assignment { op: Some(ArithOp::Sub) },
ast::BinOp::BitOrAssign => BinaryOp::Assignment { op: Some(ArithOp::BitOr) },
ast::BinOp::BitAndAssign => BinaryOp::Assignment { op: Some(ArithOp::BitAnd) },
ast::BinOp::BitXorAssign => BinaryOp::Assignment { op: Some(ArithOp::BitXor) },
}
}
}
dont store body inside source map
2019-03-02 13:18:40 +00:00
pub(crate) fn body_with_source_map_query(
db: &impl HirDatabase,
Added defWithBody
2019-03-30 10:50:00 +00:00
def: DefWithBody,
dont store body inside source map
2019-03-02 13:18:40 +00:00
) -> (Arc<Body>, Arc<BodySourceMap>) {
Use correct FileId when expanding macros in expressions
2019-05-01 12:53:13 +00:00
let mut collector;
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 21:37:59 +00:00
Added defWithBody
2019-03-30 10:50:00 +00:00
match def {
Use correct FileId when expanding macros in expressions
2019-05-01 12:53:13 +00:00
DefWithBody::Const(ref c) => {
use Source for statics and consts
2019-06-11 14:13:20 +00:00
let src = c.source(db);
collector = ExprCollector::new(def, src.file_id, def.resolver(db), db);
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
collector.collect_const_body(src.ast)
Use correct FileId when expanding macros in expressions
2019-05-01 12:53:13 +00:00
}
DefWithBody::Function(ref f) => {
use Source for Function
2019-06-11 13:49:56 +00:00
let src = f.source(db);
collector = ExprCollector::new(def, src.file_id, def.resolver(db), db);
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
collector.collect_fn_body(src.ast)
Use correct FileId when expanding macros in expressions
2019-05-01 12:53:13 +00:00
}
DefWithBody::Static(ref s) => {
use Source for statics and consts
2019-06-11 14:13:20 +00:00
let src = s.source(db);
collector = ExprCollector::new(def, src.file_id, def.resolver(db), db);
migrate ra_hir to the new rowan
2019-07-19 07:43:01 +00:00
collector.collect_static_body(src.ast)
Use correct FileId when expanding macros in expressions
2019-05-01 12:53:13 +00:00
}
Added defWithBody
2019-03-30 10:50:00 +00: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 21:37:59 +00:00
dont store body inside source map
2019-03-02 13:18:40 +00:00
let (body, source_map) = collector.finish();
(Arc::new(body), Arc::new(source_map))
}
Added defWithBody
2019-03-30 10:50:00 +00:00
pub(crate) fn body_hir_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<Body> {
Added const bodies and static body to the ast and added inference the inference test reduce code duplication
2019-03-30 11:17:31 +00:00
db.body_with_source_map(def).0
Add HIR Expr machinery
2019-01-05 15:32:07 +00:00
}
Reference in a new issue Copy permalink