diff --git a/crates/ra_cfg/src/lib.rs b/crates/ra_cfg/src/lib.rs index 1bee3eb995..51d953f6e8 100644 --- a/crates/ra_cfg/src/lib.rs +++ b/crates/ra_cfg/src/lib.rs @@ -1,11 +1,12 @@ //! ra_cfg defines conditional compiling options, `cfg` attibute parser and evaluator + +mod cfg_expr; + use std::iter::IntoIterator; use ra_syntax::SmolStr; use rustc_hash::FxHashSet; -mod cfg_expr; - pub use cfg_expr::{parse_cfg, CfgExpr}; /// Configuration options used for conditional compilition on items with `cfg` attributes. diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs index f5dd59f840..ee883b6154 100644 --- a/crates/ra_db/src/fixture.rs +++ b/crates/ra_db/src/fixture.rs @@ -1,5 +1,6 @@ //! FIXME: write short doc here +use std::str::FromStr; use std::sync::Arc; use ra_cfg::CfgOptions; @@ -164,7 +165,7 @@ fn parse_meta(meta: &str) -> ParsedMeta { match key { "crate" => krate = Some(value.to_string()), "deps" => deps = value.split(',').map(|it| it.to_string()).collect(), - "edition" => edition = Edition::from_string(&value), + "edition" => edition = Edition::from_str(&value).unwrap(), "cfg" => { for key in value.split(',') { match split1(key, '=') { diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs index 60f7dc8815..c0d95a13fa 100644 --- a/crates/ra_db/src/input.rs +++ b/crates/ra_db/src/input.rs @@ -13,6 +13,7 @@ use ra_syntax::SmolStr; use rustc_hash::FxHashSet; use crate::{RelativePath, RelativePathBuf}; +use std::str::FromStr; /// `FileId` is an integer which uniquely identifies a file. File paths are /// messy and system-dependent, so most of the code should work directly with @@ -97,12 +98,18 @@ pub enum Edition { Edition2015, } -impl Edition { - //FIXME: replace with FromStr with proper error handling - pub fn from_string(s: &str) -> Edition { +#[derive(Debug)] +pub struct ParseEditionError { + pub msg: String, +} + +impl FromStr for Edition { + type Err = ParseEditionError; + fn from_str(s: &str) -> Result { match s { - "2015" => Edition::Edition2015, - "2018" | _ => Edition::Edition2018, + "2015" => Ok(Edition::Edition2015), + "2018" => Ok(Edition::Edition2018), + _ => Err(ParseEditionError { msg: format!("unknown edition: {}", s) }), } } } diff --git a/crates/ra_fmt/src/lib.rs b/crates/ra_fmt/src/lib.rs index e22ac9753f..a30ed4cbb8 100644 --- a/crates/ra_fmt/src/lib.rs +++ b/crates/ra_fmt/src/lib.rs @@ -1,5 +1,7 @@ //! This crate provides some utilities for indenting rust code. -//! + +use std::iter::successors; + use itertools::Itertools; use ra_syntax::{ ast::{self, AstNode, AstToken}, @@ -7,7 +9,6 @@ use ra_syntax::{ SyntaxKind::*, SyntaxNode, SyntaxToken, T, }; -use std::iter::successors; pub fn reindent(text: &str, indent: &str) -> String { let indent = format!("\n{}", indent); diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs index 5a0bd0c192..2fd4ccb109 100644 --- a/crates/ra_hir/src/code_model.rs +++ b/crates/ra_hir/src/code_model.rs @@ -550,7 +550,7 @@ where } fn body(self, db: &impl HirDatabase) -> Arc { - db.body_hir(self.into()) + db.body(self.into()) } fn body_source_map(self, db: &impl HirDatabase) -> Arc { @@ -564,7 +564,7 @@ impl HasBody for DefWithBody { } fn body(self, db: &impl HirDatabase) -> Arc { - db.body_hir(self) + db.body(self) } fn body_source_map(self, db: &impl HirDatabase) -> Arc { @@ -666,7 +666,7 @@ impl Function { } pub fn body(self, db: &impl HirDatabase) -> Arc { - db.body_hir(self.into()) + db.body(self.into()) } pub fn ty(self, db: &impl HirDatabase) -> Ty { @@ -1079,7 +1079,7 @@ pub struct Local { impl Local { pub fn name(self, db: &impl HirDatabase) -> Option { - let body = db.body_hir(self.parent); + let body = db.body(self.parent); match &body[self.pat_id] { Pat::Bind { name, .. } => Some(name.clone()), _ => None, @@ -1091,7 +1091,7 @@ impl Local { } pub fn is_mut(self, db: &impl HirDatabase) -> bool { - let body = db.body_hir(self.parent); + let body = db.body(self.parent); match &body[self.pat_id] { Pat::Bind { mode, .. } => match mode { BindingAnnotation::Mutable | BindingAnnotation::RefMut => true, diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index 75c322c999..9ac811232f 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -8,6 +8,7 @@ use ra_syntax::SmolStr; use crate::{ debug::HirDebugDatabase, + expr::{Body, BodySourceMap}, generics::{GenericDef, GenericParams}, ids, impl_block::{ImplBlock, ImplSourceMap, ModuleImplBlocks}, @@ -113,13 +114,10 @@ pub trait HirDatabase: DefDatabase + AstDatabase { fn generic_defaults(&self, def: GenericDef) -> Substs; #[salsa::invoke(crate::expr::body_with_source_map_query)] - fn body_with_source_map( - &self, - def: DefWithBody, - ) -> (Arc, Arc); + fn body_with_source_map(&self, def: DefWithBody) -> (Arc, Arc); - #[salsa::invoke(crate::expr::body_hir_query)] - fn body_hir(&self, def: DefWithBody) -> Arc; + #[salsa::invoke(crate::expr::body_query)] + fn body(&self, def: DefWithBody) -> Arc; #[salsa::invoke(crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query)] fn impls_in_crate(&self, krate: Crate) -> Arc; diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs index 6e23197a4d..82955fa558 100644 --- a/crates/ra_hir/src/expr.rs +++ b/crates/ra_hir/src/expr.rs @@ -1,549 +1,24 @@ //! FIXME: write short doc here -pub(crate) mod lower; pub(crate) mod scope; pub(crate) mod validation; -use std::{ops::Index, sync::Arc}; +use std::sync::Arc; -use hir_def::{ - path::GenericArgs, - type_ref::{Mutability, TypeRef}, -}; -use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId}; use ra_syntax::{ast, AstPtr}; -use rustc_hash::FxHashMap; -use crate::{ - db::HirDatabase, - ty::primitive::{UncertainFloatTy, UncertainIntTy}, - DefWithBody, Either, HasSource, Name, Path, Resolver, Source, -}; +use crate::{db::HirDatabase, DefWithBody, HasSource, Resolver}; pub use self::scope::ExprScopes; -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ExprId(RawId); -impl_arena_id!(ExprId); - -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct PatId(RawId); -impl_arena_id!(PatId); - -/// The body of an item (function, const etc.). -#[derive(Debug, Eq, PartialEq)] -pub struct Body { - /// The def of the item this body belongs to - owner: DefWithBody, - exprs: Arena, - pats: Arena, - /// The patterns for the function's parameters. While the parameter types are - /// part of the function signature, the patterns are not (they don't change - /// the external type of the function). - /// - /// If this `Body` is for the body of a constant, this will just be - /// empty. - params: Vec, - /// The `ExprId` of the actual body expression. - body_expr: ExprId, -} - -type ExprPtr = Either, AstPtr>; -type ExprSource = Source; - -type PatPtr = Either, AstPtr>; -type PatSource = Source; - -/// 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 -/// file, so that we don't recompute types whenever some whitespace is typed. -/// -/// One complication here is that, due to macro expansion, a single `Body` might -/// be spread across several files. So, for each ExprId and PatId, we record -/// both the HirFileId and the position inside the file. However, we only store -/// AST -> ExprId mapping for non-macro files, as it is not clear how to handle -/// this properly for macros. -#[derive(Default, Debug, Eq, PartialEq)] -pub struct BodySourceMap { - expr_map: FxHashMap, - expr_map_back: ArenaMap, - pat_map: FxHashMap, - pat_map_back: ArenaMap, - field_map: FxHashMap<(ExprId, usize), AstPtr>, -} - -impl Body { - pub fn params(&self) -> &[PatId] { - &self.params - } - - pub fn body_expr(&self) -> ExprId { - self.body_expr - } - - pub fn owner(&self) -> DefWithBody { - self.owner - } - - pub fn exprs(&self) -> impl Iterator { - self.exprs.iter() - } - - pub fn pats(&self) -> impl Iterator { - self.pats.iter() - } -} - -// needs arbitrary_self_types to be a method... or maybe move to the def? -pub(crate) fn resolver_for_expr( - body: Arc, - db: &impl HirDatabase, - expr_id: ExprId, -) -> Resolver { - let scopes = db.expr_scopes(body.owner); - resolver_for_scope(body, db, scopes.scope_for(expr_id)) -} - -pub(crate) fn resolver_for_scope( - body: Arc, - db: &impl HirDatabase, - scope_id: Option, -) -> Resolver { - let mut r = body.owner.resolver(db); - let scopes = db.expr_scopes(body.owner); - let scope_chain = scopes.scope_chain(scope_id).collect::>(); - for scope in scope_chain.into_iter().rev() { - r = r.push_expr_scope(Arc::clone(&scopes), scope); - } - r -} - -impl Index for Body { - type Output = Expr; - - fn index(&self, expr: ExprId) -> &Expr { - &self.exprs[expr] - } -} - -impl Index for Body { - type Output = Pat; - - fn index(&self, pat: PatId) -> &Pat { - &self.pats[pat] - } -} - -impl BodySourceMap { - pub(crate) fn expr_syntax(&self, expr: ExprId) -> Option { - self.expr_map_back.get(expr).copied() - } - - pub(crate) fn node_expr(&self, node: &ast::Expr) -> Option { - self.expr_map.get(&Either::A(AstPtr::new(node))).cloned() - } - - pub(crate) fn pat_syntax(&self, pat: PatId) -> Option { - self.pat_map_back.get(pat).copied() - } - - pub(crate) fn node_pat(&self, node: &ast::Pat) -> Option { - self.pat_map.get(&Either::A(AstPtr::new(node))).cloned() - } - - pub(crate) fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr { - self.field_map[&(expr, field)] - } -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub enum Literal { - String(String), - ByteString(Vec), - Char(char), - Bool(bool), - Int(u64, UncertainIntTy), - Float(u64, UncertainFloatTy), // FIXME: f64 is not Eq -} - -#[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, +pub use hir_def::{ + body::{Body, BodySourceMap, ExprPtr, ExprSource, PatPtr, PatSource}, + expr::{ + ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp, + MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement, UnaryOp, }, - Block { - statements: Vec, - tail: Option, - }, - Loop { - body: ExprId, - }, - While { - condition: ExprId, - body: ExprId, - }, - For { - iterable: ExprId, - pat: PatId, - body: ExprId, - }, - Call { - callee: ExprId, - args: Vec, - }, - MethodCall { - receiver: ExprId, - method_name: Name, - args: Vec, - generic_args: Option, - }, - Match { - expr: ExprId, - arms: Vec, - }, - Continue, - Break { - expr: Option, - }, - Return { - expr: Option, - }, - RecordLit { - path: Option, - fields: Vec, - spread: Option, - }, - Field { - expr: ExprId, - name: Name, - }, - Await { - expr: ExprId, - }, - Try { - expr: ExprId, - }, - TryBlock { - body: ExprId, - }, - Cast { - expr: ExprId, - type_ref: TypeRef, - }, - Ref { - expr: ExprId, - mutability: Mutability, - }, - Box { - expr: ExprId, - }, - UnaryOp { - expr: ExprId, - op: UnaryOp, - }, - BinaryOp { - lhs: ExprId, - rhs: ExprId, - op: Option, - }, - Index { - base: ExprId, - index: ExprId, - }, - Lambda { - args: Vec, - arg_types: Vec>, - body: ExprId, - }, - Tuple { - exprs: Vec, - }, - Array(Array), - Literal(Literal), -} +}; -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] -pub enum BinaryOp { - LogicOp(LogicOp), - ArithOp(ArithOp), - CmpOp(CmpOp), - Assignment { op: Option }, -} - -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] -pub enum LogicOp { - And, - Or, -} - -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] -pub enum CmpOp { - Eq { negated: bool }, - Ord { ordering: Ordering, strict: bool }, -} - -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] -pub enum Ordering { - Less, - Greater, -} - -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] -pub enum ArithOp { - Add, - Mul, - Sub, - Div, - Rem, - Shl, - Shr, - BitXor, - BitOr, - BitAnd, -} - -pub use ra_syntax::ast::PrefixOp as UnaryOp; -#[derive(Debug, Clone, Eq, PartialEq)] -pub enum Array { - ElementList(Vec), - Repeat { initializer: ExprId, repeat: ExprId }, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct MatchArm { - pub pats: Vec, - pub guard: Option, - pub expr: ExprId, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct RecordLitField { - pub name: Name, - pub expr: ExprId, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub enum Statement { - Let { pat: PatId, type_ref: Option, initializer: Option }, - Expr(ExprId), -} - -impl Expr { - pub fn walk_child_exprs(&self, mut f: impl FnMut(ExprId)) { - match self { - Expr::Missing => {} - Expr::Path(_) => {} - Expr::If { condition, then_branch, else_branch } => { - f(*condition); - f(*then_branch); - if let Some(else_branch) = else_branch { - f(*else_branch); - } - } - Expr::Block { statements, tail } => { - for stmt in statements { - match stmt { - Statement::Let { initializer, .. } => { - if let Some(expr) = initializer { - f(*expr); - } - } - Statement::Expr(e) => f(*e), - } - } - if let Some(expr) = tail { - f(*expr); - } - } - Expr::TryBlock { body } => f(*body), - 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::RecordLit { fields, spread, .. } => { - for field in fields { - f(field.expr); - } - if let Some(expr) = spread { - f(*expr); - } - } - Expr::Lambda { body, .. } => { - f(*body); - } - Expr::BinaryOp { lhs, rhs, .. } => { - f(*lhs); - f(*rhs); - } - Expr::Index { base, index } => { - f(*base); - f(*index); - } - Expr::Field { expr, .. } - | Expr::Await { expr } - | Expr::Try { expr } - | Expr::Cast { expr, .. } - | Expr::Ref { expr, .. } - | Expr::UnaryOp { expr, .. } - | Expr::Box { expr } => { - f(*expr); - } - Expr::Tuple { exprs } => { - for expr in exprs { - f(*expr); - } - } - Expr::Array(a) => match a { - Array::ElementList(exprs) => { - for expr in exprs { - f(*expr); - } - } - Array::Repeat { initializer, repeat } => { - f(*initializer); - f(*repeat) - } - }, - Expr::Literal(_) => {} - } - } -} - -/// 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, - } - } -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct RecordFieldPat { - pub(crate) name: Name, - pub(crate) pat: PatId, -} - -/// Close relative to rustc's hir::PatKind -#[derive(Debug, Clone, Eq, PartialEq)] -pub enum Pat { - Missing, - Wild, - Tuple(Vec), - Record { - path: Option, - args: Vec, - // FIXME: 'ellipsis' option - }, - Range { - start: ExprId, - end: ExprId, - }, - Slice { - prefix: Vec, - rest: Option, - suffix: Vec, - }, - Path(Path), - Lit(ExprId), - Bind { - mode: BindingAnnotation, - name: Name, - subpat: Option, - }, - TupleStruct { - path: Option, - args: Vec, - }, - Ref { - pat: PatId, - mutability: Mutability, - }, -} - -impl Pat { - pub fn walk_child_pats(&self, mut f: impl FnMut(PatId)) { - match self { - Pat::Range { .. } | Pat::Lit(..) | Pat::Path(..) | Pat::Wild | Pat::Missing => {} - Pat::Bind { subpat, .. } => { - subpat.iter().copied().for_each(f); - } - Pat::Tuple(args) | Pat::TupleStruct { args, .. } => { - args.iter().copied().for_each(f); - } - Pat::Ref { pat, .. } => f(*pat), - Pat::Slice { prefix, rest, suffix } => { - let total_iter = prefix.iter().chain(rest.iter()).chain(suffix.iter()); - total_iter.copied().for_each(f); - } - Pat::Record { args, .. } => { - args.iter().map(|f| f.pat).for_each(f); - } - } - } -} - -// Queries pub(crate) fn body_with_source_map_query( db: &impl HirDatabase, def: DefWithBody, @@ -565,11 +40,35 @@ pub(crate) fn body_with_source_map_query( (src.file_id, src.ast.body()) } }; - - let (body, source_map) = lower::lower(db, def.resolver(db), file_id, def, params, body); + let resolver = hir_def::body::MacroResolver::new(db, def.module(db).id); + let (body, source_map) = Body::new(db, resolver, file_id, params, body); (Arc::new(body), Arc::new(source_map)) } -pub(crate) fn body_hir_query(db: &impl HirDatabase, def: DefWithBody) -> Arc { +pub(crate) fn body_query(db: &impl HirDatabase, def: DefWithBody) -> Arc { db.body_with_source_map(def).0 } + +// needs arbitrary_self_types to be a method... or maybe move to the def? +pub(crate) fn resolver_for_expr( + db: &impl HirDatabase, + owner: DefWithBody, + expr_id: ExprId, +) -> Resolver { + let scopes = db.expr_scopes(owner); + resolver_for_scope(db, owner, scopes.scope_for(expr_id)) +} + +pub(crate) fn resolver_for_scope( + db: &impl HirDatabase, + owner: DefWithBody, + scope_id: Option, +) -> Resolver { + let mut r = owner.resolver(db); + let scopes = db.expr_scopes(owner); + let scope_chain = scopes.scope_chain(scope_id).collect::>(); + for scope in scope_chain.into_iter().rev() { + r = r.push_expr_scope(Arc::clone(&scopes), scope); + } + r +} diff --git a/crates/ra_hir/src/expr/scope.rs b/crates/ra_hir/src/expr/scope.rs index daf8d8d079..0e49a28d6c 100644 --- a/crates/ra_hir/src/expr/scope.rs +++ b/crates/ra_hir/src/expr/scope.rs @@ -46,7 +46,7 @@ pub(crate) struct ScopeData { impl ExprScopes { pub(crate) fn expr_scopes_query(db: &impl HirDatabase, def: DefWithBody) -> Arc { - let body = db.body_hir(def); + let body = db.body(def); let res = ExprScopes::new(body); Arc::new(res) } diff --git a/crates/ra_hir/src/marks.rs b/crates/ra_hir/src/marks.rs index 0d4fa5b673..0f754eb9c7 100644 --- a/crates/ra_hir/src/marks.rs +++ b/crates/ra_hir/src/marks.rs @@ -5,6 +5,5 @@ test_utils::marks!( type_var_cycles_resolve_as_possible type_var_resolves_to_int_var match_ergonomics_ref - infer_while_let coerce_merge_fail_fallback ); diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs index fe4211819e..f28e9c931a 100644 --- a/crates/ra_hir/src/source_binder.rs +++ b/crates/ra_hir/src/source_binder.rs @@ -150,7 +150,7 @@ impl SourceAnalyzer { None => scope_for(&scopes, &source_map, &node), Some(offset) => scope_for_offset(&scopes, &source_map, file_id.into(), offset), }; - let resolver = expr::resolver_for_scope(def.body(db), db, scope); + let resolver = expr::resolver_for_scope(db, def, scope); SourceAnalyzer { resolver, body_owner: Some(def), diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs index 2370e8d4f5..f17c6c6143 100644 --- a/crates/ra_hir/src/ty/infer.rs +++ b/crates/ra_hir/src/ty/infer.rs @@ -43,7 +43,7 @@ use crate::{ expr::{BindingAnnotation, Body, ExprId, PatId}, resolve::{Resolver, TypeNs}, ty::infer::diagnostics::InferenceDiagnostic, - Adt, AssocItem, ConstData, DefWithBody, FnData, Function, HasBody, Path, StructField, + Adt, AssocItem, ConstData, DefWithBody, FnData, Function, Path, StructField, }; macro_rules! ty_app { @@ -64,9 +64,8 @@ mod coerce; /// The entry point of type inference. pub fn infer_query(db: &impl HirDatabase, def: DefWithBody) -> Arc { let _p = profile("infer_query"); - let body = def.body(db); let resolver = def.resolver(db); - let mut ctx = InferenceContext::new(db, body, resolver); + let mut ctx = InferenceContext::new(db, def, resolver); match def { DefWithBody::Const(ref c) => ctx.collect_const(&c.data(db)), @@ -187,6 +186,7 @@ impl Index for InferenceResult { #[derive(Clone, Debug)] struct InferenceContext<'a, D: HirDatabase> { db: &'a D, + owner: DefWithBody, body: Arc, resolver: Resolver, var_unification_table: InPlaceUnificationTable, @@ -204,7 +204,7 @@ struct InferenceContext<'a, D: HirDatabase> { } impl<'a, D: HirDatabase> InferenceContext<'a, D> { - fn new(db: &'a D, body: Arc, resolver: Resolver) -> Self { + fn new(db: &'a D, owner: DefWithBody, resolver: Resolver) -> Self { InferenceContext { result: InferenceResult::default(), var_unification_table: InPlaceUnificationTable::new(), @@ -213,7 +213,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { trait_env: lower::trait_env(db, &resolver), coerce_unsized_map: Self::init_coerce_unsized_map(db, &resolver), db, - body, + owner, + body: db.body(owner), resolver, } } diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs index 4af1d65ee4..c6802487a0 100644 --- a/crates/ra_hir/src/ty/infer/expr.rs +++ b/crates/ra_hir/src/ty/infer/expr.rs @@ -130,10 +130,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1 }, Substs(sig_tys.into()), ); - let closure_ty = Ty::apply_one( - TypeCtor::Closure { def: self.body.owner(), expr: tgt_expr }, - sig_ty, - ); + let closure_ty = + Ty::apply_one(TypeCtor::Closure { def: self.owner, expr: tgt_expr }, sig_ty); // Eagerly try to relate the closure type with the expected // type, otherwise we often won't have enough information to @@ -184,7 +182,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { } Expr::Path(p) => { // FIXME this could be more efficient... - let resolver = expr::resolver_for_expr(self.body.clone(), self.db, tgt_expr); + let resolver = expr::resolver_for_expr(self.db, self.owner, tgt_expr); self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown) } Expr::Continue => Ty::simple(TypeCtor::Never), @@ -452,8 +450,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { Ty::apply_one(TypeCtor::Ref(Mutability::Shared), slice_type) } Literal::Char(..) => Ty::simple(TypeCtor::Char), - Literal::Int(_v, ty) => Ty::simple(TypeCtor::Int(*ty)), - Literal::Float(_v, ty) => Ty::simple(TypeCtor::Float(*ty)), + Literal::Int(_v, ty) => Ty::simple(TypeCtor::Int((*ty).into())), + Literal::Float(_v, ty) => Ty::simple(TypeCtor::Float((*ty).into())), }, }; // use a new type variable if we got Ty::Unknown here diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs index 1fed5025eb..1832fcf504 100644 --- a/crates/ra_hir/src/ty/lower.rs +++ b/crates/ra_hir/src/ty/lower.rs @@ -9,7 +9,7 @@ use std::iter; use std::sync::Arc; use hir_def::{ - builtin_type::BuiltinType, + builtin_type::{BuiltinFloat, BuiltinInt, BuiltinType}, path::{GenericArg, PathSegment}, type_ref::{TypeBound, TypeRef}, }; @@ -25,7 +25,7 @@ use crate::{ generics::{GenericDef, WherePredicate}, resolve::{Resolver, TypeNs}, ty::{ - primitive::{FloatTy, IntTy}, + primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy}, Adt, }, util::make_mut_slice, @@ -657,13 +657,41 @@ fn type_for_builtin(def: BuiltinType) -> Ty { BuiltinType::Char => TypeCtor::Char, BuiltinType::Bool => TypeCtor::Bool, BuiltinType::Str => TypeCtor::Str, - BuiltinType::Int { signedness, bitness } => { - TypeCtor::Int(IntTy { signedness, bitness }.into()) - } - BuiltinType::Float { bitness } => TypeCtor::Float(FloatTy { bitness }.into()), + BuiltinType::Int(t) => TypeCtor::Int(IntTy::from(t).into()), + BuiltinType::Float(t) => TypeCtor::Float(FloatTy::from(t).into()), }) } +impl From for IntTy { + fn from(t: BuiltinInt) -> Self { + IntTy { signedness: t.signedness, bitness: t.bitness } + } +} + +impl From for FloatTy { + fn from(t: BuiltinFloat) -> Self { + FloatTy { bitness: t.bitness } + } +} + +impl From> for UncertainIntTy { + fn from(t: Option) -> Self { + match t { + None => UncertainIntTy::Unknown, + Some(t) => UncertainIntTy::Known(t.into()), + } + } +} + +impl From> for UncertainFloatTy { + fn from(t: Option) -> Self { + match t { + None => UncertainFloatTy::Unknown, + Some(t) => UncertainFloatTy::Known(t.into()), + } + } +} + fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig { let struct_data = db.struct_data(def.id.into()); let fields = match struct_data.variant_data.fields() { diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs index 1749752f10..7362de4c3f 100644 --- a/crates/ra_hir/src/ty/primitive.rs +++ b/crates/ra_hir/src/ty/primitive.rs @@ -129,24 +129,6 @@ impl IntTy { (Signedness::Unsigned, IntBitness::X128) => "u128", } } - - pub(crate) fn from_suffix(suffix: &str) -> Option { - match suffix { - "isize" => Some(IntTy::isize()), - "i8" => Some(IntTy::i8()), - "i16" => Some(IntTy::i16()), - "i32" => Some(IntTy::i32()), - "i64" => Some(IntTy::i64()), - "i128" => Some(IntTy::i128()), - "usize" => Some(IntTy::usize()), - "u8" => Some(IntTy::u8()), - "u16" => Some(IntTy::u16()), - "u32" => Some(IntTy::u32()), - "u64" => Some(IntTy::u64()), - "u128" => Some(IntTy::u128()), - _ => None, - } - } } #[derive(Copy, Clone, PartialEq, Eq, Hash)] @@ -181,12 +163,4 @@ impl FloatTy { FloatBitness::X64 => "f64", } } - - pub(crate) fn from_suffix(suffix: &str) -> Option { - match suffix { - "f32" => Some(FloatTy::f32()), - "f64" => Some(FloatTy::f64()), - _ => None, - } - } } diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs index 896bf2924b..8863c36087 100644 --- a/crates/ra_hir/src/ty/tests.rs +++ b/crates/ra_hir/src/ty/tests.rs @@ -222,7 +222,6 @@ mod collections { #[test] fn infer_while_let() { - covers!(infer_while_let); let (db, pos) = TestDB::with_position( r#" //- /main.rs @@ -4825,7 +4824,7 @@ fn main() { @r###" ![0; 1) '6': i32 [64; 88) '{ ...!(); }': () - [74; 75) 'x': i32 + [74; 75) 'x': i32 "### ); } diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs index 14c54b9fb4..de322dd523 100644 --- a/crates/ra_hir/src/ty/traits/chalk.rs +++ b/crates/ra_hir/src/ty/traits/chalk.rs @@ -714,7 +714,7 @@ fn closure_fn_trait_impl_datum( let fn_once_trait = get_fn_trait(db, krate, super::FnTrait::FnOnce)?; let trait_ = get_fn_trait(db, krate, data.fn_trait)?; // get corresponding fn trait - let num_args: u16 = match &db.body_hir(data.def)[data.expr] { + let num_args: u16 = match &db.body(data.def)[data.expr] { crate::expr::Expr::Lambda { args, .. } => args.len() as u16, _ => { log::warn!("closure for closure type {:?} not found", data); diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs new file mode 100644 index 0000000000..ac8f8261b8 --- /dev/null +++ b/crates/ra_hir_def/src/body.rs @@ -0,0 +1,144 @@ +//! FIXME: write short doc here +mod lower; + +use std::{ops::Index, sync::Arc}; + +use hir_expand::{either::Either, HirFileId, MacroDefId, Source}; +use ra_arena::{map::ArenaMap, Arena}; +use ra_syntax::{ast, AstPtr}; +use rustc_hash::FxHashMap; + +use crate::{ + db::DefDatabase2, + expr::{Expr, ExprId, Pat, PatId}, + nameres::CrateDefMap, + path::Path, + ModuleId, +}; + +pub struct MacroResolver { + crate_def_map: Arc, + module: ModuleId, +} + +impl MacroResolver { + pub fn new(db: &impl DefDatabase2, module: ModuleId) -> MacroResolver { + MacroResolver { crate_def_map: db.crate_def_map(module.krate), module } + } + + pub(crate) fn resolve_path_as_macro( + &self, + db: &impl DefDatabase2, + path: &Path, + ) -> Option { + self.crate_def_map.resolve_path(db, self.module.module_id, path).0.get_macros() + } +} + +/// The body of an item (function, const etc.). +#[derive(Debug, Eq, PartialEq)] +pub struct Body { + exprs: Arena, + pats: Arena, + /// The patterns for the function's parameters. While the parameter types are + /// part of the function signature, the patterns are not (they don't change + /// the external type of the function). + /// + /// If this `Body` is for the body of a constant, this will just be + /// empty. + params: Vec, + /// The `ExprId` of the actual body expression. + body_expr: ExprId, +} + +pub type ExprPtr = Either, AstPtr>; +pub type ExprSource = Source; + +pub type PatPtr = Either, AstPtr>; +pub type PatSource = Source; + +/// 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 +/// file, so that we don't recompute types whenever some whitespace is typed. +/// +/// One complication here is that, due to macro expansion, a single `Body` might +/// be spread across several files. So, for each ExprId and PatId, we record +/// both the HirFileId and the position inside the file. However, we only store +/// AST -> ExprId mapping for non-macro files, as it is not clear how to handle +/// this properly for macros. +#[derive(Default, Debug, Eq, PartialEq)] +pub struct BodySourceMap { + expr_map: FxHashMap, + expr_map_back: ArenaMap, + pat_map: FxHashMap, + pat_map_back: ArenaMap, + field_map: FxHashMap<(ExprId, usize), AstPtr>, +} + +impl Body { + pub fn new( + db: &impl DefDatabase2, + resolver: MacroResolver, + file_id: HirFileId, + params: Option, + body: Option, + ) -> (Body, BodySourceMap) { + lower::lower(db, resolver, file_id, params, body) + } + + pub fn params(&self) -> &[PatId] { + &self.params + } + + pub fn body_expr(&self) -> ExprId { + self.body_expr + } + + pub fn exprs(&self) -> impl Iterator { + self.exprs.iter() + } + + pub fn pats(&self) -> impl Iterator { + self.pats.iter() + } +} + +impl Index for Body { + type Output = Expr; + + fn index(&self, expr: ExprId) -> &Expr { + &self.exprs[expr] + } +} + +impl Index for Body { + type Output = Pat; + + fn index(&self, pat: PatId) -> &Pat { + &self.pats[pat] + } +} + +impl BodySourceMap { + pub fn expr_syntax(&self, expr: ExprId) -> Option { + self.expr_map_back.get(expr).copied() + } + + pub fn node_expr(&self, node: &ast::Expr) -> Option { + self.expr_map.get(&Either::A(AstPtr::new(node))).cloned() + } + + pub fn pat_syntax(&self, pat: PatId) -> Option { + self.pat_map_back.get(pat).copied() + } + + pub fn node_pat(&self, node: &ast::Pat) -> Option { + self.pat_map.get(&Either::A(AstPtr::new(node))).cloned() + } + + pub fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr { + self.field_map[&(expr, field)] + } +} diff --git a/crates/ra_hir/src/expr/lower.rs b/crates/ra_hir_def/src/body/lower.rs similarity index 93% rename from crates/ra_hir/src/expr/lower.rs rename to crates/ra_hir_def/src/body/lower.rs index 6463dd65e1..2aa863c9ec 100644 --- a/crates/ra_hir/src/expr/lower.rs +++ b/crates/ra_hir_def/src/body/lower.rs @@ -1,9 +1,10 @@ //! FIXME: write short doc here -use hir_def::{path::GenericArgs, type_ref::TypeRef}; use hir_expand::{ + either::Either, hygiene::Hygiene, name::{self, AsName, Name}, + AstId, HirFileId, MacroCallLoc, MacroFileKind, Source, }; use ra_arena::Arena; use ra_syntax::{ @@ -13,25 +14,24 @@ use ra_syntax::{ }, AstNode, AstPtr, }; -use test_utils::tested_by; use crate::{ - db::HirDatabase, - ty::primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy}, - AstId, DefWithBody, Either, HirFileId, MacroCallLoc, MacroFileKind, Mutability, Path, Resolver, - Source, -}; - -use super::{ - ArithOp, Array, BinaryOp, BindingAnnotation, Body, BodySourceMap, CmpOp, Expr, ExprId, Literal, - LogicOp, MatchArm, Ordering, Pat, PatId, PatPtr, RecordFieldPat, RecordLitField, Statement, + body::{Body, BodySourceMap, MacroResolver, PatPtr}, + builtin_type::{BuiltinFloat, BuiltinInt}, + db::DefDatabase2, + expr::{ + ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp, + MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement, + }, + path::GenericArgs, + path::Path, + type_ref::{Mutability, TypeRef}, }; pub(super) fn lower( - db: &impl HirDatabase, - resolver: Resolver, + db: &impl DefDatabase2, + resolver: MacroResolver, file_id: HirFileId, - owner: DefWithBody, params: Option, body: Option, ) -> (Body, BodySourceMap) { @@ -42,11 +42,10 @@ pub(super) fn lower( current_file_id: file_id, source_map: BodySourceMap::default(), body: Body { - owner, exprs: Arena::default(), pats: Arena::default(), params: Vec::new(), - body_expr: ExprId((!0).into()), + body_expr: ExprId::dummy(), }, } .collect(params, body) @@ -54,11 +53,7 @@ pub(super) fn lower( struct ExprCollector { db: DB, - resolver: Resolver, - // 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) + resolver: MacroResolver, original_file_id: HirFileId, current_file_id: HirFileId, @@ -68,7 +63,7 @@ struct ExprCollector { impl<'a, DB> ExprCollector<&'a DB> where - DB: HirDatabase, + DB: DefDatabase2, { fn collect( mut self, @@ -209,7 +204,6 @@ where 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.missing_pat(); @@ -423,28 +417,18 @@ where ast::Expr::Literal(e) => { let lit = match e.kind() { LiteralKind::IntNumber { suffix } => { - let known_name = suffix - .and_then(|it| IntTy::from_suffix(&it).map(UncertainIntTy::Known)); + let known_name = suffix.and_then(|it| BuiltinInt::from_suffix(&it)); - Literal::Int( - Default::default(), - known_name.unwrap_or(UncertainIntTy::Unknown), - ) + Literal::Int(Default::default(), known_name) } LiteralKind::FloatNumber { suffix } => { - let known_name = suffix - .and_then(|it| FloatTy::from_suffix(&it).map(UncertainFloatTy::Known)); + let known_name = suffix.and_then(|it| BuiltinFloat::from_suffix(&it)); - Literal::Float( - Default::default(), - known_name.unwrap_or(UncertainFloatTy::Unknown), - ) + Literal::Float(Default::default(), known_name) } LiteralKind::ByteString => Literal::ByteString(Default::default()), LiteralKind::String => Literal::String(Default::default()), - LiteralKind::Byte => { - Literal::Int(Default::default(), UncertainIntTy::Known(IntTy::u8())) - } + LiteralKind::Byte => Literal::Int(Default::default(), Some(BuiltinInt::U8)), LiteralKind::Bool => Literal::Bool(Default::default()), LiteralKind::Char => Literal::Char(Default::default()), }; @@ -467,7 +451,7 @@ where if let Some(path) = e.path().and_then(|path| self.parse_path(path)) { if let Some(def) = self.resolver.resolve_path_as_macro(self.db, &path) { - let call_id = self.db.intern_macro(MacroCallLoc { def: def.id, ast_id }); + let call_id = self.db.intern_macro(MacroCallLoc { def, ast_id }); let file_id = call_id.as_file(MacroFileKind::Expr); if let Some(node) = self.db.parse_or_expand(file_id) { if let Some(expr) = ast::Expr::cast(node) { diff --git a/crates/ra_hir_def/src/builtin_type.rs b/crates/ra_hir_def/src/builtin_type.rs index 2ec0c83fe5..5e81571443 100644 --- a/crates/ra_hir_def/src/builtin_type.rs +++ b/crates/ra_hir_def/src/builtin_type.rs @@ -29,13 +29,24 @@ pub enum FloatBitness { X64, } +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct BuiltinInt { + pub signedness: Signedness, + pub bitness: IntBitness, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct BuiltinFloat { + pub bitness: FloatBitness, +} + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub enum BuiltinType { Char, Bool, Str, - Int { signedness: Signedness, bitness: IntBitness }, - Float { bitness: FloatBitness }, + Int(BuiltinInt), + Float(BuiltinFloat), } impl BuiltinType { @@ -45,22 +56,22 @@ impl BuiltinType { (name::BOOL, BuiltinType::Bool), (name::STR, BuiltinType::Str ), - (name::ISIZE, BuiltinType::Int { signedness: Signedness::Signed, bitness: IntBitness::Xsize }), - (name::I8, BuiltinType::Int { signedness: Signedness::Signed, bitness: IntBitness::X8 }), - (name::I16, BuiltinType::Int { signedness: Signedness::Signed, bitness: IntBitness::X16 }), - (name::I32, BuiltinType::Int { signedness: Signedness::Signed, bitness: IntBitness::X32 }), - (name::I64, BuiltinType::Int { signedness: Signedness::Signed, bitness: IntBitness::X64 }), - (name::I128, BuiltinType::Int { signedness: Signedness::Signed, bitness: IntBitness::X128 }), + (name::ISIZE, BuiltinType::Int(BuiltinInt::ISIZE)), + (name::I8, BuiltinType::Int(BuiltinInt::I8)), + (name::I16, BuiltinType::Int(BuiltinInt::I16)), + (name::I32, BuiltinType::Int(BuiltinInt::I32)), + (name::I64, BuiltinType::Int(BuiltinInt::I64)), + (name::I128, BuiltinType::Int(BuiltinInt::I128)), - (name::USIZE, BuiltinType::Int { signedness: Signedness::Unsigned, bitness: IntBitness::Xsize }), - (name::U8, BuiltinType::Int { signedness: Signedness::Unsigned, bitness: IntBitness::X8 }), - (name::U16, BuiltinType::Int { signedness: Signedness::Unsigned, bitness: IntBitness::X16 }), - (name::U32, BuiltinType::Int { signedness: Signedness::Unsigned, bitness: IntBitness::X32 }), - (name::U64, BuiltinType::Int { signedness: Signedness::Unsigned, bitness: IntBitness::X64 }), - (name::U128, BuiltinType::Int { signedness: Signedness::Unsigned, bitness: IntBitness::X128 }), + (name::USIZE, BuiltinType::Int(BuiltinInt::USIZE)), + (name::U8, BuiltinType::Int(BuiltinInt::U8)), + (name::U16, BuiltinType::Int(BuiltinInt::U16)), + (name::U32, BuiltinType::Int(BuiltinInt::U32)), + (name::U64, BuiltinType::Int(BuiltinInt::U64)), + (name::U128, BuiltinType::Int(BuiltinInt::U128)), - (name::F32, BuiltinType::Float { bitness: FloatBitness::X32 }), - (name::F64, BuiltinType::Float { bitness: FloatBitness::X64 }), + (name::F32, BuiltinType::Float(BuiltinFloat::F32)), + (name::F64, BuiltinType::Float(BuiltinFloat::F64)), ]; } @@ -70,7 +81,7 @@ impl fmt::Display for BuiltinType { BuiltinType::Char => "char", BuiltinType::Bool => "bool", BuiltinType::Str => "str", - BuiltinType::Int { signedness, bitness } => match (signedness, bitness) { + BuiltinType::Int(BuiltinInt { signedness, bitness }) => match (signedness, bitness) { (Signedness::Signed, IntBitness::Xsize) => "isize", (Signedness::Signed, IntBitness::X8) => "i8", (Signedness::Signed, IntBitness::X16) => "i16", @@ -85,7 +96,7 @@ impl fmt::Display for BuiltinType { (Signedness::Unsigned, IntBitness::X64) => "u64", (Signedness::Unsigned, IntBitness::X128) => "u128", }, - BuiltinType::Float { bitness } => match bitness { + BuiltinType::Float(BuiltinFloat { bitness }) => match bitness { FloatBitness::X32 => "f32", FloatBitness::X64 => "f64", }, @@ -93,3 +104,57 @@ impl fmt::Display for BuiltinType { f.write_str(type_name) } } + +#[rustfmt::skip] +impl BuiltinInt { + pub const ISIZE: BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::Xsize }; + pub const I8 : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X8 }; + pub const I16 : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X16 }; + pub const I32 : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X32 }; + pub const I64 : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X64 }; + pub const I128 : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X128 }; + + pub const USIZE: BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::Xsize }; + pub const U8 : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X8 }; + pub const U16 : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X16 }; + pub const U32 : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X32 }; + pub const U64 : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X64 }; + pub const U128 : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X128 }; + + + pub fn from_suffix(suffix: &str) -> Option { + let res = match suffix { + "isize" => Self::ISIZE, + "i8" => Self::I8, + "i16" => Self::I16, + "i32" => Self::I32, + "i64" => Self::I64, + "i128" => Self::I128, + + "usize" => Self::USIZE, + "u8" => Self::U8, + "u16" => Self::U16, + "u32" => Self::U32, + "u64" => Self::U64, + "u128" => Self::U128, + + _ => return None, + }; + Some(res) + } +} + +#[rustfmt::skip] +impl BuiltinFloat { + pub const F32: BuiltinFloat = BuiltinFloat { bitness: FloatBitness::X32 }; + pub const F64: BuiltinFloat = BuiltinFloat { bitness: FloatBitness::X64 }; + + pub fn from_suffix(suffix: &str) -> Option { + let res = match suffix { + "f32" => BuiltinFloat::F32, + "f64" => BuiltinFloat::F64, + _ => return None, + }; + Some(res) + } +} diff --git a/crates/ra_hir_def/src/expr.rs b/crates/ra_hir_def/src/expr.rs new file mode 100644 index 0000000000..04c1d8f69b --- /dev/null +++ b/crates/ra_hir_def/src/expr.rs @@ -0,0 +1,421 @@ +//! This module describes hir-level representation of expressions. +//! +//! This representaion is: +//! +//! 1. Identity-based. Each expression has an `id`, so we can distinguish +//! between different `1` in `1 + 1`. +//! 2. Independent of syntax. Though syntactic provenance information can be +//! attached separately via id-based side map. +//! 3. Unresolved. Paths are stored as sequences of names, and not as defs the +//! names refer to. +//! 4. Desugared. There's no `if let`. +//! +//! See also a neighboring `body` module. + +use hir_expand::name::Name; +use ra_arena::{impl_arena_id, RawId}; + +use crate::{ + builtin_type::{BuiltinFloat, BuiltinInt}, + path::{GenericArgs, Path}, + type_ref::{Mutability, TypeRef}, +}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ExprId(RawId); +impl_arena_id!(ExprId); + +impl ExprId { + pub fn dummy() -> ExprId { + ExprId((!0).into()) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct PatId(RawId); +impl_arena_id!(PatId); + +#[derive(Debug, Clone, Eq, PartialEq)] +pub enum Literal { + String(String), + ByteString(Vec), + Char(char), + Bool(bool), + Int(u64, Option), + Float(u64, Option), // FIXME: f64 is not Eq +} + +#[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, + }, + Block { + statements: Vec, + tail: Option, + }, + Loop { + body: ExprId, + }, + While { + condition: ExprId, + body: ExprId, + }, + For { + iterable: ExprId, + pat: PatId, + body: ExprId, + }, + Call { + callee: ExprId, + args: Vec, + }, + MethodCall { + receiver: ExprId, + method_name: Name, + args: Vec, + generic_args: Option, + }, + Match { + expr: ExprId, + arms: Vec, + }, + Continue, + Break { + expr: Option, + }, + Return { + expr: Option, + }, + RecordLit { + path: Option, + fields: Vec, + spread: Option, + }, + Field { + expr: ExprId, + name: Name, + }, + Await { + expr: ExprId, + }, + Try { + expr: ExprId, + }, + TryBlock { + body: ExprId, + }, + Cast { + expr: ExprId, + type_ref: TypeRef, + }, + Ref { + expr: ExprId, + mutability: Mutability, + }, + Box { + expr: ExprId, + }, + UnaryOp { + expr: ExprId, + op: UnaryOp, + }, + BinaryOp { + lhs: ExprId, + rhs: ExprId, + op: Option, + }, + Index { + base: ExprId, + index: ExprId, + }, + Lambda { + args: Vec, + arg_types: Vec>, + body: ExprId, + }, + Tuple { + exprs: Vec, + }, + Array(Array), + Literal(Literal), +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub enum BinaryOp { + LogicOp(LogicOp), + ArithOp(ArithOp), + CmpOp(CmpOp), + Assignment { op: Option }, +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub enum LogicOp { + And, + Or, +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub enum CmpOp { + Eq { negated: bool }, + Ord { ordering: Ordering, strict: bool }, +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub enum Ordering { + Less, + Greater, +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub enum ArithOp { + Add, + Mul, + Sub, + Div, + Rem, + Shl, + Shr, + BitXor, + BitOr, + BitAnd, +} + +pub use ra_syntax::ast::PrefixOp as UnaryOp; +#[derive(Debug, Clone, Eq, PartialEq)] +pub enum Array { + ElementList(Vec), + Repeat { initializer: ExprId, repeat: ExprId }, +} + +#[derive(Debug, Clone, Eq, PartialEq)] +pub struct MatchArm { + pub pats: Vec, + pub guard: Option, + pub expr: ExprId, +} + +#[derive(Debug, Clone, Eq, PartialEq)] +pub struct RecordLitField { + pub name: Name, + pub expr: ExprId, +} + +#[derive(Debug, Clone, Eq, PartialEq)] +pub enum Statement { + Let { pat: PatId, type_ref: Option, initializer: Option }, + Expr(ExprId), +} + +impl Expr { + pub fn walk_child_exprs(&self, mut f: impl FnMut(ExprId)) { + match self { + Expr::Missing => {} + Expr::Path(_) => {} + Expr::If { condition, then_branch, else_branch } => { + f(*condition); + f(*then_branch); + if let Some(else_branch) = else_branch { + f(*else_branch); + } + } + Expr::Block { statements, tail } => { + for stmt in statements { + match stmt { + Statement::Let { initializer, .. } => { + if let Some(expr) = initializer { + f(*expr); + } + } + Statement::Expr(e) => f(*e), + } + } + if let Some(expr) = tail { + f(*expr); + } + } + Expr::TryBlock { body } => f(*body), + 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::RecordLit { fields, spread, .. } => { + for field in fields { + f(field.expr); + } + if let Some(expr) = spread { + f(*expr); + } + } + Expr::Lambda { body, .. } => { + f(*body); + } + Expr::BinaryOp { lhs, rhs, .. } => { + f(*lhs); + f(*rhs); + } + Expr::Index { base, index } => { + f(*base); + f(*index); + } + Expr::Field { expr, .. } + | Expr::Await { expr } + | Expr::Try { expr } + | Expr::Cast { expr, .. } + | Expr::Ref { expr, .. } + | Expr::UnaryOp { expr, .. } + | Expr::Box { expr } => { + f(*expr); + } + Expr::Tuple { exprs } => { + for expr in exprs { + f(*expr); + } + } + Expr::Array(a) => match a { + Array::ElementList(exprs) => { + for expr in exprs { + f(*expr); + } + } + Array::Repeat { initializer, repeat } => { + f(*initializer); + f(*repeat) + } + }, + Expr::Literal(_) => {} + } + } +} + +/// 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 { + pub 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, + } + } +} + +#[derive(Debug, Clone, Eq, PartialEq)] +pub struct RecordFieldPat { + pub name: Name, + pub pat: PatId, +} + +/// Close relative to rustc's hir::PatKind +#[derive(Debug, Clone, Eq, PartialEq)] +pub enum Pat { + Missing, + Wild, + Tuple(Vec), + Record { + path: Option, + args: Vec, + // FIXME: 'ellipsis' option + }, + Range { + start: ExprId, + end: ExprId, + }, + Slice { + prefix: Vec, + rest: Option, + suffix: Vec, + }, + Path(Path), + Lit(ExprId), + Bind { + mode: BindingAnnotation, + name: Name, + subpat: Option, + }, + TupleStruct { + path: Option, + args: Vec, + }, + Ref { + pat: PatId, + mutability: Mutability, + }, +} + +impl Pat { + pub fn walk_child_pats(&self, mut f: impl FnMut(PatId)) { + match self { + Pat::Range { .. } | Pat::Lit(..) | Pat::Path(..) | Pat::Wild | Pat::Missing => {} + Pat::Bind { subpat, .. } => { + subpat.iter().copied().for_each(f); + } + Pat::Tuple(args) | Pat::TupleStruct { args, .. } => { + args.iter().copied().for_each(f); + } + Pat::Ref { pat, .. } => f(*pat), + Pat::Slice { prefix, rest, suffix } => { + let total_iter = prefix.iter().chain(rest.iter()).chain(suffix.iter()); + total_iter.copied().for_each(f); + } + Pat::Record { args, .. } => { + args.iter().map(|f| f.pat).for_each(f); + } + } + } +} diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs index 239317efe3..4a758bb835 100644 --- a/crates/ra_hir_def/src/lib.rs +++ b/crates/ra_hir_def/src/lib.rs @@ -14,6 +14,8 @@ pub mod type_ref; pub mod builtin_type; pub mod adt; pub mod diagnostics; +pub mod expr; +pub mod body; #[cfg(test)] mod test_db; diff --git a/crates/ra_ide_api/src/change.rs b/crates/ra_ide_api/src/change.rs index 4416421ae0..010b45141f 100644 --- a/crates/ra_ide_api/src/change.rs +++ b/crates/ra_ide_api/src/change.rs @@ -276,7 +276,7 @@ impl RootDatabase { self.query(hir::db::ExprScopesQuery).sweep(sweep); self.query(hir::db::InferQuery).sweep(sweep); - self.query(hir::db::BodyHirQuery).sweep(sweep); + self.query(hir::db::BodyQuery).sweep(sweep); } pub(crate) fn per_query_memory_usage(&mut self) -> Vec<(String, Bytes)> { @@ -333,7 +333,7 @@ impl RootDatabase { hir::db::GenericPredicatesQuery hir::db::GenericDefaultsQuery hir::db::BodyWithSourceMapQuery - hir::db::BodyHirQuery + hir::db::BodyQuery hir::db::ImplsInCrateQuery hir::db::ImplsForTraitQuery hir::db::AssociatedTyDataQuery diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs index 28dadea9d7..cf88911b75 100644 --- a/crates/ra_project_model/src/cargo_workspace.rs +++ b/crates/ra_project_model/src/cargo_workspace.rs @@ -1,6 +1,7 @@ //! FIXME: write short doc here use std::path::{Path, PathBuf}; +use std::str::FromStr; use cargo_metadata::{CargoOpt, MetadataCommand}; use ra_arena::{impl_arena_id, Arena, RawId}; @@ -140,18 +141,21 @@ impl CargoWorkspace { let ws_members = &meta.workspace_members; for meta_pkg in meta.packages { - let is_member = ws_members.contains(&meta_pkg.id); + let cargo_metadata::Package { id, edition, name, manifest_path, .. } = meta_pkg; + let is_member = ws_members.contains(&id); + let edition = Edition::from_str(&edition) + .map_err(|e| (format!("metadata for package {} failed: {}", &name, e.msg)))?; let pkg = packages.alloc(PackageData { - name: meta_pkg.name, - manifest: meta_pkg.manifest_path.clone(), + name, + manifest: manifest_path, targets: Vec::new(), is_member, - edition: Edition::from_string(&meta_pkg.edition), + edition, dependencies: Vec::new(), features: Vec::new(), }); let pkg_data = &mut packages[pkg]; - pkg_by_id.insert(meta_pkg.id.clone(), pkg); + pkg_by_id.insert(id, pkg); for meta_tgt in meta_pkg.targets { let tgt = targets.alloc(TargetData { pkg, diff --git a/xtask/tests/tidy-tests/docs.rs b/xtask/tests/tidy-tests/docs.rs index 227937f462..1412198601 100644 --- a/xtask/tests/tidy-tests/docs.rs +++ b/xtask/tests/tidy-tests/docs.rs @@ -1,10 +1,6 @@ -use std::fs; -use std::io::prelude::*; -use std::io::BufReader; -use std::path::Path; +use std::{collections::HashMap, fs, io::prelude::*, io::BufReader, path::Path}; use walkdir::{DirEntry, WalkDir}; - use xtask::project_root; fn is_exclude_dir(p: &Path) -> bool { @@ -37,6 +33,7 @@ fn no_docs_comments() { let crates = project_root().join("crates"); let iter = WalkDir::new(crates); let mut missing_docs = Vec::new(); + let mut contains_fixme = Vec::new(); for f in iter.into_iter().filter_entry(|e| !is_hidden(e)) { let f = f.unwrap(); if f.file_type().is_dir() { @@ -54,7 +51,12 @@ fn no_docs_comments() { let mut reader = BufReader::new(fs::File::open(f.path()).unwrap()); let mut line = String::new(); reader.read_line(&mut line).unwrap(); - if !line.starts_with("//!") { + + if line.starts_with("//!") { + if line.contains("FIXME") { + contains_fixme.push(f.path().to_path_buf()) + } + } else { missing_docs.push(f.path().display().to_string()); } } @@ -65,4 +67,39 @@ fn no_docs_comments() { missing_docs.join("\n") ) } + + let whitelist = [ + "ra_batch", + "ra_cli", + "ra_db", + "ra_hir", + "ra_hir_expand", + "ra_hir_def", + "ra_ide_api", + "ra_lsp_server", + "ra_mbe", + "ra_parser", + "ra_prof", + "ra_project_model", + "ra_syntax", + "ra_text_edit", + "ra_tt", + ]; + + let mut has_fixmes = whitelist.iter().map(|it| (*it, false)).collect::>(); + 'outer: for path in contains_fixme { + for krate in whitelist.iter() { + if path.components().any(|it| it.as_os_str() == *krate) { + has_fixmes.insert(krate, true); + continue 'outer; + } + } + panic!("FIXME doc in a fully-documented crate: {}", path.display()) + } + + for (krate, has_fixme) in has_fixmes.iter() { + if !has_fixme { + panic!("crate {} is fully documented, remove it from the white list", krate) + } + } }