12 files changed, 170 insertions, 157 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 2e86b3fee..df79334c9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -884,9 +884,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.6"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54a21852a652ad6f610c9510194f398ff6f8692e334fd1145fed931f7fbe44ea"
+checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
 dependencies = [
  "proc-macro2",
 ]
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index 2e16e5120..f965eb2b5 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -39,8 +39,7 @@ use ra_syntax::SmolStr;
 use super::{
     primitive::{FloatTy, IntTy},
     traits::{Guidance, Obligation, ProjectionPredicate, Solution},
-    ApplicationTy, InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeCtor,
-    TypeWalk, Uncertain,
+    InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeCtor, TypeWalk,
 };
 use crate::{
     db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
@@ -312,12 +311,6 @@ impl<'a> InferenceContext<'a> {
     fn insert_type_vars_shallow(&mut self, ty: Ty) -> Ty {
         match ty {
             Ty::Unknown => self.table.new_type_var(),
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::Int(Uncertain::Unknown), .. }) => {
-                self.table.new_integer_var()
-            }
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::Float(Uncertain::Unknown), .. }) => {
-                self.table.new_float_var()
-            }
             _ => ty,
         }
     }
@@ -664,8 +657,8 @@ impl InferTy {
     fn fallback_value(self) -> Ty {
         match self {
             InferTy::TypeVar(..) => Ty::Unknown,
-            InferTy::IntVar(..) => Ty::simple(TypeCtor::Int(Uncertain::Known(IntTy::i32()))),
-            InferTy::FloatVar(..) => Ty::simple(TypeCtor::Float(Uncertain::Known(FloatTy::f64()))),
+            InferTy::IntVar(..) => Ty::simple(TypeCtor::Int(IntTy::i32())),
+            InferTy::FloatVar(..) => Ty::simple(TypeCtor::Float(FloatTy::f64())),
             InferTy::MaybeNeverTypeVar(..) => Ty::simple(TypeCtor::Never),
         }
     }
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index 4a98e2deb..9fd310f69 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -18,7 +18,7 @@ use crate::{
     traits::InEnvironment,
     utils::{generics, variant_data, Generics},
     ApplicationTy, Binders, CallableDef, InferTy, IntTy, Mutability, Obligation, Rawness, Substs,
-    TraitRef, Ty, TypeCtor, Uncertain,
+    TraitRef, Ty, TypeCtor,
 };
 
 use super::{
@@ -426,15 +426,7 @@ impl<'a> InferenceContext<'a> {
                         match &inner_ty {
                             // Fast path for builtins
                             Ty::Apply(ApplicationTy {
-                                ctor:
-                                    TypeCtor::Int(Uncertain::Known(IntTy {
-                                        signedness: Signedness::Signed,
-                                        ..
-                                    })),
-                                ..
-                            })
-                            | Ty::Apply(ApplicationTy {
-                                ctor: TypeCtor::Int(Uncertain::Unknown),
+                                ctor: TypeCtor::Int(IntTy { signedness: Signedness::Signed, .. }),
                                 ..
                             })
                             | Ty::Apply(ApplicationTy { ctor: TypeCtor::Float(_), .. })
@@ -577,9 +569,7 @@ impl<'a> InferenceContext<'a> {
                         );
                         self.infer_expr(
                             *repeat,
-                            &Expectation::has_type(Ty::simple(TypeCtor::Int(Uncertain::Known(
-                                IntTy::usize(),
-                            )))),
+                            &Expectation::has_type(Ty::simple(TypeCtor::Int(IntTy::usize()))),
                         );
                     }
                 }
@@ -592,13 +582,19 @@ impl<'a> InferenceContext<'a> {
                     Ty::apply_one(TypeCtor::Ref(Mutability::Shared), Ty::simple(TypeCtor::Str))
                 }
                 Literal::ByteString(..) => {
-                    let byte_type = Ty::simple(TypeCtor::Int(Uncertain::Known(IntTy::u8())));
+                    let byte_type = Ty::simple(TypeCtor::Int(IntTy::u8()));
                     let array_type = Ty::apply_one(TypeCtor::Array, byte_type);
                     Ty::apply_one(TypeCtor::Ref(Mutability::Shared), array_type)
                 }
                 Literal::Char(..) => Ty::simple(TypeCtor::Char),
-                Literal::Int(_v, ty) => Ty::simple(TypeCtor::Int((*ty).into())),
-                Literal::Float(_v, ty) => Ty::simple(TypeCtor::Float((*ty).into())),
+                Literal::Int(_v, ty) => match ty {
+                    Some(int_ty) => Ty::simple(TypeCtor::Int((*int_ty).into())),
+                    None => self.table.new_integer_var(),
+                },
+                Literal::Float(_v, ty) => match ty {
+                    Some(float_ty) => Ty::simple(TypeCtor::Float((*float_ty).into())),
+                    None => self.table.new_float_var(),
+                },
             },
         };
         // use a new type variable if we got Ty::Unknown here
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index 135976fcd..2b9372b4b 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -58,7 +58,7 @@ use ra_db::{impl_intern_key, salsa, CrateId};
 
 use crate::{
     db::HirDatabase,
-    primitive::{FloatTy, IntTy, Uncertain},
+    primitive::{FloatTy, IntTy},
     utils::{generics, make_mut_slice, Generics},
 };
 use display::HirDisplay;
@@ -87,10 +87,10 @@ pub enum TypeCtor {
     Char,
 
     /// A primitive integer type. For example, `i32`.
-    Int(Uncertain<IntTy>),
+    Int(IntTy),
 
     /// A primitive floating-point type. For example, `f64`.
-    Float(Uncertain<FloatTy>),
+    Float(FloatTy),
 
     /// Structures, enumerations and unions.
     Adt(AdtId),
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index e19628fdf..e83b39456 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -16,12 +16,8 @@ use rustc_hash::{FxHashMap, FxHashSet};
 
 use super::Substs;
 use crate::{
-    autoderef,
-    db::HirDatabase,
-    primitive::{FloatBitness, Uncertain},
-    utils::all_super_traits,
-    ApplicationTy, Canonical, DebruijnIndex, InEnvironment, TraitEnvironment, TraitRef, Ty,
-    TypeCtor, TypeWalk,
+    autoderef, db::HirDatabase, primitive::FloatBitness, utils::all_super_traits, ApplicationTy,
+    Canonical, DebruijnIndex, InEnvironment, TraitEnvironment, TraitRef, Ty, TypeCtor, TypeWalk,
 };
 
 /// This is used as a key for indexing impls.
@@ -147,12 +143,12 @@ impl Ty {
                 }
                 TypeCtor::Bool => lang_item_crate!("bool"),
                 TypeCtor::Char => lang_item_crate!("char"),
-                TypeCtor::Float(Uncertain::Known(f)) => match f.bitness {
+                TypeCtor::Float(f) => match f.bitness {
                     // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
                     FloatBitness::X32 => lang_item_crate!("f32", "f32_runtime"),
                     FloatBitness::X64 => lang_item_crate!("f64", "f64_runtime"),
                 },
-                TypeCtor::Int(Uncertain::Known(i)) => lang_item_crate!(i.ty_to_string()),
+                TypeCtor::Int(i) => lang_item_crate!(i.ty_to_string()),
                 TypeCtor::Str => lang_item_crate!("str_alloc", "str"),
                 TypeCtor::Slice => lang_item_crate!("slice_alloc", "slice"),
                 TypeCtor::RawPtr(Mutability::Shared) => lang_item_crate!("const_ptr"),
diff --git a/crates/ra_hir_ty/src/primitive.rs b/crates/ra_hir_ty/src/primitive.rs
index 02a8179d9..37966b709 100644
--- a/crates/ra_hir_ty/src/primitive.rs
+++ b/crates/ra_hir_ty/src/primitive.rs
@@ -7,42 +7,6 @@ use std::fmt;
 
 pub use hir_def::builtin_type::{BuiltinFloat, BuiltinInt, FloatBitness, IntBitness, Signedness};
 
-#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
-pub enum Uncertain<T> {
-    Unknown,
-    Known(T),
-}
-
-impl From<IntTy> for Uncertain<IntTy> {
-    fn from(ty: IntTy) -> Self {
-        Uncertain::Known(ty)
-    }
-}
-
-impl fmt::Display for Uncertain<IntTy> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Uncertain::Unknown => write!(f, "{{integer}}"),
-            Uncertain::Known(ty) => write!(f, "{}", ty),
-        }
-    }
-}
-
-impl From<FloatTy> for Uncertain<FloatTy> {
-    fn from(ty: FloatTy) -> Self {
-        Uncertain::Known(ty)
-    }
-}
-
-impl fmt::Display for Uncertain<FloatTy> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Uncertain::Unknown => write!(f, "{{float}}"),
-            Uncertain::Known(ty) => write!(f, "{}", ty),
-        }
-    }
-}
-
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct IntTy {
     pub signedness: Signedness,
@@ -173,21 +137,3 @@ impl From<BuiltinFloat> for FloatTy {
         FloatTy { bitness: t.bitness }
     }
 }
-
-impl From<Option<BuiltinInt>> for Uncertain<IntTy> {
-    fn from(t: Option<BuiltinInt>) -> Self {
-        match t {
-            None => Uncertain::Unknown,
-            Some(t) => Uncertain::Known(t.into()),
-        }
-    }
-}
-
-impl From<Option<BuiltinFloat>> for Uncertain<FloatTy> {
-    fn from(t: Option<BuiltinFloat>) -> Self {
-        match t {
-            None => Uncertain::Unknown,
-            Some(t) => Uncertain::Known(t.into()),
-        }
-    }
-}
diff --git a/crates/ra_hir_ty/src/traits/chalk/mapping.rs b/crates/ra_hir_ty/src/traits/chalk/mapping.rs
index 28a5fbe3e..18e5c9c16 100644
--- a/crates/ra_hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/ra_hir_ty/src/traits/chalk/mapping.rs
@@ -14,7 +14,7 @@ use ra_db::salsa::InternKey;
 
 use crate::{
     db::HirDatabase,
-    primitive::{FloatBitness, FloatTy, IntBitness, IntTy, Signedness, Uncertain},
+    primitive::{FloatBitness, FloatTy, IntBitness, IntTy, Signedness},
     traits::{builtin, AssocTyValue, Canonical, Impl, Obligation},
     ApplicationTy, CallableDef, GenericPredicate, InEnvironment, OpaqueTy, OpaqueTyId,
     ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeCtor,
@@ -249,11 +249,11 @@ impl ToChalk for TypeCtor {
 
             TypeCtor::Bool => TypeName::Scalar(Scalar::Bool),
             TypeCtor::Char => TypeName::Scalar(Scalar::Char),
-            TypeCtor::Int(Uncertain::Known(int_ty)) => TypeName::Scalar(int_ty_to_chalk(int_ty)),
-            TypeCtor::Float(Uncertain::Known(FloatTy { bitness: FloatBitness::X32 })) => {
+            TypeCtor::Int(int_ty) => TypeName::Scalar(int_ty_to_chalk(int_ty)),
+            TypeCtor::Float(FloatTy { bitness: FloatBitness::X32 }) => {
                 TypeName::Scalar(Scalar::Float(chalk_ir::FloatTy::F32))
             }
-            TypeCtor::Float(Uncertain::Known(FloatTy { bitness: FloatBitness::X64 })) => {
+            TypeCtor::Float(FloatTy { bitness: FloatBitness::X64 }) => {
                 TypeName::Scalar(Scalar::Float(chalk_ir::FloatTy::F64))
             }
 
@@ -268,9 +268,7 @@ impl ToChalk for TypeCtor {
             }
             TypeCtor::Never => TypeName::Never,
 
-            TypeCtor::Int(Uncertain::Unknown)
-            | TypeCtor::Float(Uncertain::Unknown)
-            | TypeCtor::Adt(_)
+            TypeCtor::Adt(_)
             | TypeCtor::Array
             | TypeCtor::FnPtr { .. }
             | TypeCtor::Closure { .. } => {
@@ -291,19 +289,19 @@ impl ToChalk for TypeCtor {
 
             TypeName::Scalar(Scalar::Bool) => TypeCtor::Bool,
             TypeName::Scalar(Scalar::Char) => TypeCtor::Char,
-            TypeName::Scalar(Scalar::Int(int_ty)) => TypeCtor::Int(Uncertain::Known(IntTy {
+            TypeName::Scalar(Scalar::Int(int_ty)) => TypeCtor::Int(IntTy {
                 signedness: Signedness::Signed,
                 bitness: bitness_from_chalk_int(int_ty),
-            })),
-            TypeName::Scalar(Scalar::Uint(uint_ty)) => TypeCtor::Int(Uncertain::Known(IntTy {
+            }),
+            TypeName::Scalar(Scalar::Uint(uint_ty)) => TypeCtor::Int(IntTy {
                 signedness: Signedness::Unsigned,
                 bitness: bitness_from_chalk_uint(uint_ty),
-            })),
+            }),
             TypeName::Scalar(Scalar::Float(chalk_ir::FloatTy::F32)) => {
-                TypeCtor::Float(Uncertain::Known(FloatTy { bitness: FloatBitness::X32 }))
+                TypeCtor::Float(FloatTy { bitness: FloatBitness::X32 })
             }
             TypeName::Scalar(Scalar::Float(chalk_ir::FloatTy::F64)) => {
-                TypeCtor::Float(Uncertain::Known(FloatTy { bitness: FloatBitness::X64 }))
+                TypeCtor::Float(FloatTy { bitness: FloatBitness::X64 })
             }
             TypeName::Tuple(cardinality) => TypeCtor::Tuple { cardinality: cardinality as u16 },
             TypeName::Raw(mutability) => TypeCtor::RawPtr(from_chalk(db, mutability)),
diff --git a/crates/ra_ide/src/snapshots/highlight_strings.html b/crates/ra_ide/src/snapshots/highlight_strings.html
index e97192b61..6a5cf0e74 100644
--- a/crates/ra_ide/src/snapshots/highlight_strings.html
+++ b/crates/ra_ide/src/snapshots/highlight_strings.html
@@ -63,7 +63,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">^</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>);
     <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">&gt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>);
     <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">+</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">5</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="variable">x</span><span class="string_literal">}!"</span>, <span class="numeric_literal">27</span>);
+    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">27</span>);
     <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">5</span>);
     <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, -<span class="numeric_literal">5</span>);
     <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="numeric_literal">0</span><span class="numeric_literal">10</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">27</span>);
diff --git a/crates/ra_ide/src/syntax_highlighting/tests.rs b/crates/ra_ide/src/syntax_highlighting/tests.rs
index 36a1aa419..5e42c5b55 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -7,9 +7,21 @@ use crate::{
     FileRange, TextRange,
 };
 
+/// Highlights the code given by the `ra_fixture` argument, renders the
+/// result as HTML, and compares it with the HTML file given as `snapshot`.
+/// Note that the `snapshot` file is overwritten by the rendered HTML.
+fn check_highlighting(ra_fixture: &str, snapshot: &str, rainbow: bool) {
+    let (analysis, file_id) = single_file(ra_fixture);
+    let dst_file = project_dir().join(snapshot);
+    let actual_html = &analysis.highlight_as_html(file_id, rainbow).unwrap();
+    let expected_html = &read_text(&dst_file);
+    fs::write(dst_file, &actual_html).unwrap();
+    assert_eq_text!(expected_html, actual_html);
+}
+
 #[test]
 fn test_highlighting() {
-    let (analysis, file_id) = single_file(
+    check_highlighting(
         r#"
 #[derive(Clone, Debug)]
 struct Foo {
@@ -84,17 +96,14 @@ impl<T> Option<T> {
 }
 "#
         .trim(),
+        "crates/ra_ide/src/snapshots/highlighting.html",
+        false,
     );
-    let dst_file = project_dir().join("crates/ra_ide/src/snapshots/highlighting.html");
-    let actual_html = &analysis.highlight_as_html(file_id, false).unwrap();
-    let expected_html = &read_text(&dst_file);
-    fs::write(dst_file, &actual_html).unwrap();
-    assert_eq_text!(expected_html, actual_html);
 }
 
 #[test]
 fn test_rainbow_highlighting() {
-    let (analysis, file_id) = single_file(
+    check_highlighting(
         r#"
 fn main() {
     let hello = "hello";
@@ -110,12 +119,9 @@ fn bar() {
 }
 "#
         .trim(),
+        "crates/ra_ide/src/snapshots/rainbow_highlighting.html",
+        true,
     );
-    let dst_file = project_dir().join("crates/ra_ide/src/snapshots/rainbow_highlighting.html");
-    let actual_html = &analysis.highlight_as_html(file_id, true).unwrap();
-    let expected_html = &read_text(&dst_file);
-    fs::write(dst_file, &actual_html).unwrap();
-    assert_eq_text!(expected_html, actual_html);
 }
 
 #[test]
@@ -153,7 +159,7 @@ fn test_ranges() {
 
 #[test]
 fn test_flattening() {
-    let (analysis, file_id) = single_file(
+    check_highlighting(
         r##"
 fn fixture(ra_fixture: &str) {}
 
@@ -167,13 +173,9 @@ fn main() {
     );
 }"##
         .trim(),
+        "crates/ra_ide/src/snapshots/highlight_injection.html",
+        false,
     );
-
-    let dst_file = project_dir().join("crates/ra_ide/src/snapshots/highlight_injection.html");
-    let actual_html = &analysis.highlight_as_html(file_id, false).unwrap();
-    let expected_html = &read_text(&dst_file);
-    fs::write(dst_file, &actual_html).unwrap();
-    assert_eq_text!(expected_html, actual_html);
 }
 
 #[test]
@@ -192,7 +194,7 @@ macro_rules! test {}
 fn test_string_highlighting() {
     // The format string detection is based on macro-expansion,
     // thus, we have to copy the macro definition from `std`
-    let (analysis, file_id) = single_file(
+    check_highlighting(
         r#"
 macro_rules! println {
     ($($arg:tt)*) => ({
@@ -250,18 +252,14 @@ fn main() {
     println!("{ничоси}", ничоси = 92);
 }"#
         .trim(),
+        "crates/ra_ide/src/snapshots/highlight_strings.html",
+        false,
     );
-
-    let dst_file = project_dir().join("crates/ra_ide/src/snapshots/highlight_strings.html");
-    let actual_html = &analysis.highlight_as_html(file_id, false).unwrap();
-    let expected_html = &read_text(&dst_file);
-    fs::write(dst_file, &actual_html).unwrap();
-    assert_eq_text!(expected_html, actual_html);
 }
 
 #[test]
 fn test_unsafe_highlighting() {
-    let (analysis, file_id) = single_file(
+    check_highlighting(
         r#"
 unsafe fn unsafe_fn() {}
 
@@ -282,10 +280,7 @@ fn main() {
 }
 "#
         .trim(),
+        "crates/ra_ide/src/snapshots/highlight_unsafe.html",
+        false,
     );
-    let dst_file = project_dir().join("crates/ra_ide/src/snapshots/highlight_unsafe.html");
-    let actual_html = &analysis.highlight_as_html(file_id, false).unwrap();
-    let expected_html = &read_text(&dst_file);
-    fs::write(dst_file, &actual_html).unwrap();
-    assert_eq_text!(expected_html, actual_html);
 }
diff --git a/crates/ra_syntax/src/ast/tokens.rs b/crates/ra_syntax/src/ast/tokens.rs
index 04b0a4480..56378385a 100644
--- a/crates/ra_syntax/src/ast/tokens.rs
+++ b/crates/ra_syntax/src/ast/tokens.rs
@@ -335,16 +335,26 @@ pub trait HasFormatSpecifier: AstToken {
                             }
                             c if c == '_' || c.is_alphabetic() => {
                                 read_identifier(&mut chars, &mut callback);
-                                if chars.peek().and_then(|next| next.1.as_ref().ok()).copied()
-                                    != Some('$')
-                                {
-                                    continue;
-                                }
-                                skip_char_and_emit(
-                                    &mut chars,
-                                    FormatSpecifier::DollarSign,
-                                    &mut callback,
-                                );
+                                // can be either width (indicated by dollar sign, or type in which case
+                                // the next sign has to be `}`)
+                                let next =
+                                    chars.peek().and_then(|next| next.1.as_ref().ok()).copied();
+                                match next {
+                                    Some('$') => skip_char_and_emit(
+                                        &mut chars,
+                                        FormatSpecifier::DollarSign,
+                                        &mut callback,
+                                    ),
+                                    Some('}') => {
+                                        skip_char_and_emit(
+                                            &mut chars,
+                                            FormatSpecifier::Close,
+                                            &mut callback,
+                                        );
+                                        continue;
+                                    }
+                                    _ => continue,
+                                };
                             }
                             _ => {}
                         }
@@ -416,12 +426,11 @@ pub trait HasFormatSpecifier: AstToken {
                         }
                     }
 
-                    let mut cloned = chars.clone().take(2);
-                    let first = cloned.next().and_then(|next| next.1.as_ref().ok()).copied();
-                    if first != Some('}') {
+                    if let Some((_, Ok('}'))) = chars.peek() {
+                        skip_char_and_emit(&mut chars, FormatSpecifier::Close, &mut callback);
+                    } else {
                         continue;
                     }
-                    skip_char_and_emit(&mut chars, FormatSpecifier::Close, &mut callback);
                 }
                 _ => {
                     while let Some((_, Ok(next_char))) = chars.peek() {
diff --git a/docs/dev/README.md b/docs/dev/README.md
index 194a40e15..46ee030fc 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -184,6 +184,27 @@ use crate::{}
 use super::{} // but prefer `use crate::`
 ```
 
+## Import Style
+
+Items from `hir` and `ast` should be used qualified:
+
+```rust
+// Good
+use ra_syntax::ast;
+
+fn frobnicate(func: hir::Function, strukt: ast::StructDef) {}
+
+// Not as good
+use hir::Function;
+use ra_syntax::ast::StructDef;
+
+fn frobnicate(func: Function, strukt: StructDef) {}
+```
+
+Avoid local `use MyEnum::*` imports.
+
+Prefer `use crate::foo::bar` to `use super::bar`.
+
 ## Order of Items
 
 Optimize for the reader who sees the file for the first time, and wants to get the general idea about what's going on.
@@ -220,6 +241,68 @@ struct Foo {
 For `.md` and `.adoc` files, prefer a sentence-per-line format, don't wrap lines.
 If the line is too long, you want to split the sentence in two :-)
 
+## Preconditions
+
+Function preconditions should generally be expressed in types and provided by the caller (rather than checked by callee):
+
+```rust
+// Good
+fn frbonicate(walrus: Walrus) {
+  ...
+}
+
+// Not as good
+fn frobnicate(walrus: Option<Walrus>) {
+  let walrus = match walrus {
+    Some(it) => it,
+    None => return,
+  };
+  ...
+}
+```
+
+## Commit Style
+
+We don't have specific rules around git history hygiene.
+Maintaining clean git history is encouraged, but not enforced.
+We use rebase workflow, it's OK to rewrite history during PR review process.
+
+Avoid @mentioning people in commit messages, as such messages create a lot of duplicate notification traffic during rebases.
+
+# Architecture Invariants
+
+This section tries to document high-level design constraints, which are not
+always obvious from the low-level code.
+
+## Incomplete syntax trees
+
+Syntax trees are by design incomplete and do not enforce well-formedness.
+If ast method returns an `Option`, it *can* be `None` at runtime, even if this is forbidden by the grammar.
+
+## LSP indenpendence
+
+rust-analyzer is independent from LSP.
+It provides features for a hypothetical perfect Rust-specific IDE client.
+Internal representations are lowered to LSP in the `rust-analyzer` crate (the only crate which is allowed to use LSP types).
+
+## IDE/Compiler split
+
+There's a semi-hard split between "compiler" and "IDE", at the `ra_hir` crate.
+Compiler derives new facts about source code.
+It explicitly acknowledges that not all info is available (ie, you can't look at types during name resolution).
+
+IDE assumes that all information is available at all times.
+
+IDE should use only types from `ra_hir`, and should not depend on the underling compiler types.
+`ra_hir` is a facade.
+
+## IDE API
+
+The main IDE crate (`ra_ide`) uses "Plain Old Data" for the API.
+Rather than talking in definitions and references, it talks in Strings and textual offsets.
+In general, API is centered around UI concerns -- the result of the call is what the user sees in the editor, and not what the compiler sees underneath.
+The results are 100% Rust specific though.
+
 # Logging
 
 Logging is done by both rust-analyzer and VS Code, so it might be tricky to
diff --git a/editors/code/package.json b/editors/code/package.json
index 7fdb5c27d..779d7e1b8 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -497,10 +497,7 @@
                     "default": true
                 },
                 "rust-analyzer.linkedProjects": {
-                    "markdownDescription": [
-                        "Disable project auto-discovery in favor of explicitly specified set of projects.",
-                        "Elements must be paths pointing to Cargo.toml, rust-project.json, or JSON objects in rust-project.json format"
-                    ],
+                    "markdownDescription": "Disable project auto-discovery in favor of explicitly specified set of projects.  \nElements must be paths pointing to Cargo.toml, rust-project.json, or JSON objects in rust-project.json format",
                     "type": "array",
                     "items": {
                         "type": [