Merge branch 'master' of https://github.com/rust-analyzer/rust-analyzer into find-cargo-toml-up-the-fs

Author: not-much-io

Cargo.lock

@@ -1,7 +1,8 @@
 //! `AstTransformer`s are functions that replace nodes in an AST and can be easily combined.
 use rustc_hash::FxHashMap;
 
-use hir::{db::HirDatabase, InFile, PathResolution};
+use hir::{InFile, PathResolution};
+use ra_ide_db::RootDatabase;
 use ra_syntax::ast::{self, AstNode};
 
 pub trait AstTransform<'a> {
@@ -33,18 +34,18 @@ impl<'a> AstTransform<'a> for NullTransformer {
     }
 }
 
-pub struct SubstituteTypeParams<'a, DB: HirDatabase> {
-    db: &'a DB,
+pub struct SubstituteTypeParams<'a> {
+    db: &'a RootDatabase,
     substs: FxHashMap<hir::TypeParam, ast::TypeRef>,
     previous: Box<dyn AstTransform<'a> + 'a>,
 }
 
-impl<'a, DB: HirDatabase> SubstituteTypeParams<'a, DB> {
+impl<'a> SubstituteTypeParams<'a> {
     pub fn for_trait_impl(
-        db: &'a DB,
+        db: &'a RootDatabase,
         trait_: hir::Trait,
         impl_block: ast::ImplBlock,
-    ) -> SubstituteTypeParams<'a, DB> {
+    ) -> SubstituteTypeParams<'a> {
         let substs = get_syntactic_substs(impl_block).unwrap_or_default();
         let generic_def: hir::GenericDef = trait_.into();
         let substs_by_param: FxHashMap<_, _> = generic_def
@@ -95,7 +96,7 @@ impl<'a, DB: HirDatabase> SubstituteTypeParams<'a, DB> {
     }
 }
 
-impl<'a, DB: HirDatabase> AstTransform<'a> for SubstituteTypeParams<'a, DB> {
+impl<'a> AstTransform<'a> for SubstituteTypeParams<'a> {
     fn get_substitution(
         &self,
         node: InFile<&ra_syntax::SyntaxNode>,
@@ -107,14 +108,14 @@ impl<'a, DB: HirDatabase> AstTransform<'a> for SubstituteTypeParams<'a, DB> {
     }
 }
 
-pub struct QualifyPaths<'a, DB: HirDatabase> {
-    db: &'a DB,
+pub struct QualifyPaths<'a> {
+    db: &'a RootDatabase,
     from: Option<hir::Module>,
     previous: Box<dyn AstTransform<'a> + 'a>,
 }
 
-impl<'a, DB: HirDatabase> QualifyPaths<'a, DB> {
-    pub fn new(db: &'a DB, from: Option<hir::Module>) -> Self {
+impl<'a> QualifyPaths<'a> {
+    pub fn new(db: &'a RootDatabase, from: Option<hir::Module>) -> Self {
         Self { db, from, previous: Box::new(NullTransformer) }
     }
 
@@ -168,7 +169,7 @@ pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: InFile<N>
     N::cast(result).unwrap()
 }
 
-impl<'a, DB: HirDatabase> AstTransform<'a> for QualifyPaths<'a, DB> {
+impl<'a> AstTransform<'a> for QualifyPaths<'a> {
     fn get_substitution(
         &self,
         node: InFile<&ra_syntax::SyntaxNode>,

crates/ra_assists/src/ast_transform.rs

@@ -43,15 +43,35 @@ pub fn unwrap_trivial_block(block: ast::BlockExpr) -> ast::Expr {
 
 pub fn extract_trivial_expression(block: &ast::BlockExpr) -> Option<ast::Expr> {
     let block = block.block()?;
-    let expr = block.expr()?;
-    let non_trivial_children = block.syntax().children().filter(|it| match it.kind() {
-        WHITESPACE | T!['{'] | T!['}'] => false,
-        _ => it != expr.syntax(),
-    });
-    if non_trivial_children.count() > 0 {
-        return None;
+    let has_anything_else = |thing: &SyntaxNode| -> bool {
+        let mut non_trivial_children =
+            block.syntax().children_with_tokens().filter(|it| match it.kind() {
+                WHITESPACE | T!['{'] | T!['}'] => false,
+                _ => it.as_node() != Some(thing),
+            });
+        non_trivial_children.next().is_some()
+    };
+
+    if let Some(expr) = block.expr() {
+        if has_anything_else(expr.syntax()) {
+            return None;
+        }
+        return Some(expr);
+    } else {
+        // Unwrap `{ continue; }`
+        let (stmt,) = block.statements().next_tuple()?;
+        if has_anything_else(stmt.syntax()) {
+            return None;
+        }
+        if let ast::Stmt::ExprStmt(expr_stmt) = stmt {
+            let expr = expr_stmt.expr()?;
+            match expr.syntax().kind() {
+                CONTINUE_EXPR | BREAK_EXPR | RETURN_EXPR => return Some(expr),
+                _ => (),
+            }
+        }
     }
-    Some(expr)
+    None
 }
 
 pub fn compute_ws(left: SyntaxKind, right: SyntaxKind) -> &'static str {

crates/ra_fmt/src/lib.rs

@@ -21,9 +21,9 @@ ra_prof = { path = "../ra_prof" }
 ra_syntax = { path = "../ra_syntax" }
 test_utils = { path = "../test_utils" }
 
-chalk-solve =   { git = "https://github.com/rust-lang/chalk.git", rev = "af48f302a1f571b3ca418f7c5aa639a144a34f75" }
-chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "af48f302a1f571b3ca418f7c5aa639a144a34f75" }
-chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "af48f302a1f571b3ca418f7c5aa639a144a34f75" }
+chalk-solve =   { git = "https://github.com/rust-lang/chalk.git", rev = "2939913fb7bb94ac2a6721087dc086be11410702" }
+chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "2939913fb7bb94ac2a6721087dc086be11410702" }
+chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "2939913fb7bb94ac2a6721087dc086be11410702" }
 
 lalrpop-intern = "0.15.1"
 

crates/ra_hir_ty/Cargo.toml

@@ -14,15 +14,15 @@ use crate::db::HirDatabase;
 
 use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk};
 
-use self::chalk::{from_chalk, ToChalk, TypeFamily};
+use self::chalk::{from_chalk, Interner, ToChalk};
 
 pub(crate) mod chalk;
 mod builtin;
 
 #[derive(Debug, Clone)]
 pub struct TraitSolver {
     krate: CrateId,
-    inner: Arc<Mutex<chalk_solve::Solver<TypeFamily>>>,
+    inner: Arc<Mutex<chalk_solve::Solver<Interner>>>,
 }
 
 /// We need eq for salsa
@@ -38,8 +38,8 @@ impl TraitSolver {
     fn solve(
         &self,
         db: &impl HirDatabase,
-        goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal<TypeFamily>>>,
-    ) -> Option<chalk_solve::Solution<TypeFamily>> {
+        goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>>,
+    ) -> Option<chalk_solve::Solution<Interner>> {
         let context = ChalkContext { db, krate: self.krate };
         log::debug!("solve goal: {:?}", goal);
         let mut solver = match self.inner.lock() {
@@ -110,7 +110,7 @@ pub(crate) fn trait_solver_query(
     TraitSolver { krate, inner: Arc::new(Mutex::new(create_chalk_solver())) }
 }
 
-fn create_chalk_solver() -> chalk_solve::Solver<TypeFamily> {
+fn create_chalk_solver() -> chalk_solve::Solver<Interner> {
     let solver_choice =
         chalk_solve::SolverChoice::SLG { max_size: CHALK_SOLVER_MAX_SIZE, expected_answers: None };
     solver_choice.into_solver()
@@ -242,9 +242,9 @@ pub(crate) fn trait_solve_query(
 
 fn solution_from_chalk(
     db: &impl HirDatabase,
-    solution: chalk_solve::Solution<TypeFamily>,
+    solution: chalk_solve::Solution<Interner>,
 ) -> Solution {
-    let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<TypeFamily>>| {
+    let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<Interner>>| {
         let value = subst
             .value
             .into_iter()