5 files changed, 65 insertions, 32 deletions

diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index eafaf48c1..3b169440a 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -210,7 +210,7 @@ pub struct BodySourceMap {
     expr_map_back: ArenaMap<ExprId, Result<ExprSource, SyntheticSyntax>>,
     pat_map: FxHashMap<PatSource, PatId>,
     pat_map_back: ArenaMap<PatId, Result<PatSource, SyntheticSyntax>>,
-    field_map: FxHashMap<(ExprId, usize), AstPtr<ast::RecordField>>,
+    field_map: FxHashMap<(ExprId, usize), InFile<AstPtr<ast::RecordField>>>,
     expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, HirFileId>,
 }
 
@@ -303,7 +303,7 @@ impl BodySourceMap {
         self.pat_map.get(&src).cloned()
     }
 
-    pub fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr<ast::RecordField> {
+    pub fn field_syntax(&self, expr: ExprId, field: usize) -> InFile<AstPtr<ast::RecordField>> {
         self.field_map[&(expr, field)].clone()
     }
 }
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 79abe55ce..82a52804d 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -320,7 +320,8 @@ impl ExprCollector<'_> {
 
                 let res = self.alloc_expr(record_lit, syntax_ptr);
                 for (i, ptr) in field_ptrs.into_iter().enumerate() {
-                    self.source_map.field_map.insert((res, i), ptr);
+                    let src = self.expander.to_source(ptr);
+                    self.source_map.field_map.insert((res, i), src);
                 }
                 res
             }
@@ -650,6 +651,7 @@ impl ExprCollector<'_> {
             ast::Pat::SlicePat(p) => {
                 let SlicePatComponents { prefix, slice, suffix } = p.components();
 
+                // FIXME properly handle `DotDotPat`
                 Pat::Slice {
                     prefix: prefix.into_iter().map(|p| self.collect_pat(p)).collect(),
                     slice: slice.map(|p| self.collect_pat(p)),
@@ -666,9 +668,15 @@ impl ExprCollector<'_> {
                     Pat::Missing
                 }
             }
-            ast::Pat::DotDotPat(_) => unreachable!(
-                "`DotDotPat` requires special handling and should not be mapped to a Pat."
-            ),
+            ast::Pat::DotDotPat(_) => {
+                // `DotDotPat` requires special handling and should not be mapped
+                // to a Pat. Here we are using `Pat::Missing` as a fallback for
+                // when `DotDotPat` is mapped to `Pat`, which can easily happen
+                // when the source code being analyzed has a malformed pattern
+                // which includes `..` in a place where it isn't valid.
+
+                Pat::Missing
+            }
             // FIXME: implement
             ast::Pat::BoxPat(_) | ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
         };
diff --git a/crates/ra_hir_def/src/builtin_type.rs b/crates/ra_hir_def/src/builtin_type.rs
index d14901a9b..0f872b5c0 100644
--- a/crates/ra_hir_def/src/builtin_type.rs
+++ b/crates/ra_hir_def/src/builtin_type.rs
@@ -5,7 +5,7 @@
 
 use std::fmt;
 
-use hir_expand::name::{name, Name};
+use hir_expand::name::{name, AsName, Name};
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub enum Signedness {
@@ -75,33 +75,39 @@ impl BuiltinType {
     ];
 }
 
-impl fmt::Display for BuiltinType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let type_name = match self {
-            BuiltinType::Char => "char",
-            BuiltinType::Bool => "bool",
-            BuiltinType::Str => "str",
+impl AsName for BuiltinType {
+    fn as_name(&self) -> Name {
+        match self {
+            BuiltinType::Char => name![char],
+            BuiltinType::Bool => name![bool],
+            BuiltinType::Str => name![str],
             BuiltinType::Int(BuiltinInt { signedness, bitness }) => match (signedness, bitness) {
-                (Signedness::Signed, IntBitness::Xsize) => "isize",
-                (Signedness::Signed, IntBitness::X8) => "i8",
-                (Signedness::Signed, IntBitness::X16) => "i16",
-                (Signedness::Signed, IntBitness::X32) => "i32",
-                (Signedness::Signed, IntBitness::X64) => "i64",
-                (Signedness::Signed, IntBitness::X128) => "i128",
-
-                (Signedness::Unsigned, IntBitness::Xsize) => "usize",
-                (Signedness::Unsigned, IntBitness::X8) => "u8",
-                (Signedness::Unsigned, IntBitness::X16) => "u16",
-                (Signedness::Unsigned, IntBitness::X32) => "u32",
-                (Signedness::Unsigned, IntBitness::X64) => "u64",
-                (Signedness::Unsigned, IntBitness::X128) => "u128",
+                (Signedness::Signed, IntBitness::Xsize) => name![isize],
+                (Signedness::Signed, IntBitness::X8) => name![i8],
+                (Signedness::Signed, IntBitness::X16) => name![i16],
+                (Signedness::Signed, IntBitness::X32) => name![i32],
+                (Signedness::Signed, IntBitness::X64) => name![i64],
+                (Signedness::Signed, IntBitness::X128) => name![i128],
+
+                (Signedness::Unsigned, IntBitness::Xsize) => name![usize],
+                (Signedness::Unsigned, IntBitness::X8) => name![u8],
+                (Signedness::Unsigned, IntBitness::X16) => name![u16],
+                (Signedness::Unsigned, IntBitness::X32) => name![u32],
+                (Signedness::Unsigned, IntBitness::X64) => name![u64],
+                (Signedness::Unsigned, IntBitness::X128) => name![u128],
             },
             BuiltinType::Float(BuiltinFloat { bitness }) => match bitness {
-                FloatBitness::X32 => "f32",
-                FloatBitness::X64 => "f64",
+                FloatBitness::X32 => name![f32],
+                FloatBitness::X64 => name![f64],
             },
-        };
-        f.write_str(type_name)
+        }
+    }
+}
+
+impl fmt::Display for BuiltinType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let type_name = self.as_name();
+        type_name.fmt(f)
     }
 }
 
diff --git a/crates/ra_hir_def/src/diagnostics.rs b/crates/ra_hir_def/src/diagnostics.rs
index cfa0f2f76..510c5e064 100644
--- a/crates/ra_hir_def/src/diagnostics.rs
+++ b/crates/ra_hir_def/src/diagnostics.rs
@@ -20,7 +20,7 @@ impl Diagnostic for UnresolvedModule {
         "unresolved module".to_string()
     }
     fn source(&self) -> InFile<SyntaxNodePtr> {
-        InFile { file_id: self.file, value: self.decl.clone().into() }
+        InFile::new(self.file, self.decl.clone().into())
     }
     fn as_any(&self) -> &(dyn Any + Send + 'static) {
         self
diff --git a/crates/ra_hir_def/src/find_path.rs b/crates/ra_hir_def/src/find_path.rs
index d58ac6ba5..81eff5bfe 100644
--- a/crates/ra_hir_def/src/find_path.rs
+++ b/crates/ra_hir_def/src/find_path.rs
@@ -7,7 +7,7 @@ use crate::{
     visibility::Visibility,
     CrateId, ModuleDefId, ModuleId,
 };
-use hir_expand::name::{known, Name};
+use hir_expand::name::{known, AsName, Name};
 use test_utils::tested_by;
 
 const MAX_PATH_LEN: usize = 15;
@@ -113,6 +113,11 @@ fn find_path_inner(
         }
     }
 
+    // - if the item is a builtin, it's in scope
+    if let ItemInNs::Types(ModuleDefId::BuiltinType(builtin)) = item {
+        return Some(ModPath::from_segments(PathKind::Plain, vec![builtin.as_name()]));
+    }
+
     // Recursive case:
     // - if the item is an enum variant, refer to it via the enum
     if let Some(ModuleDefId::EnumVariantId(variant)) = item.as_module_def_id() {
@@ -523,4 +528,18 @@ mod tests {
         "#;
         check_found_path(code, "megaalloc::Arc");
     }
+
+    #[test]
+    fn builtins_are_in_scope() {
+        let code = r#"
+        //- /main.rs
+        <|>
+
+        pub mod primitive {
+            pub use u8;
+        }
+        "#;
+        check_found_path(code, "u8");
+        check_found_path(code, "u16");
+    }
 }