Don't expose impl details of SyntaxPtr

matklad · matklad · commit 302bf97bbf18 · 2020-04-17T12:25:41.000+02:00
diff --git 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
@@ -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
             }
diff --git a/crates/ra_hir_def/src/diagnostics.rs b/crates/ra_hir_def/src/diagnostics.rs
@@ -4,21 +4,25 @@ use std::any::Any;
 
 use hir_expand::diagnostics::Diagnostic;
 use ra_db::RelativePathBuf;
-use ra_syntax::{ast, AstPtr, SyntaxNodePtr};
+use ra_syntax::{ast, AstPtr, SyntaxNodePtr, TextRange};
 
 use hir_expand::{HirFileId, InFile};
 
 #[derive(Debug)]
 pub struct UnresolvedModule {
     pub file: HirFileId,
     pub decl: AstPtr<ast::Module>,
+    pub highlight_range: TextRange,
     pub candidate: RelativePathBuf,
 }
 
 impl Diagnostic for UnresolvedModule {
     fn message(&self) -> String {
         "unresolved module".to_string()
     }
+    fn highlight_range(&self) -> TextRange {
+        self.highlight_range
+    }
     fn source(&self) -> InFile<SyntaxNodePtr> {
         InFile { file_id: self.file, value: self.decl.clone().into() }
     }
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
@@ -297,7 +297,7 @@ pub enum ModuleSource {
 mod diagnostics {
     use hir_expand::diagnostics::DiagnosticSink;
     use ra_db::RelativePathBuf;
-    use ra_syntax::{ast, AstPtr};
+    use ra_syntax::{ast, AstNode, AstPtr};
 
     use crate::{db::DefDatabase, diagnostics::UnresolvedModule, nameres::LocalModuleId, AstId};
 
@@ -326,6 +326,7 @@ mod diagnostics {
                     sink.push(UnresolvedModule {
                         file: declaration.file_id,
                         decl: AstPtr::new(&decl),
+                        highlight_range: decl.syntax().text_range(),
                         candidate: candidate.clone(),
                     })
                 }
diff --git a/crates/ra_hir_expand/src/diagnostics.rs b/crates/ra_hir_expand/src/diagnostics.rs
@@ -22,10 +22,8 @@ use crate::{db::AstDatabase, InFile};
 
 pub trait Diagnostic: Any + Send + Sync + fmt::Debug + 'static {
     fn message(&self) -> String;
+    fn highlight_range(&self) -> TextRange;
     fn source(&self) -> InFile<SyntaxNodePtr>;
-    fn highlight_range(&self) -> TextRange {
-        self.source().value.range()
-    }
     fn as_any(&self) -> &(dyn Any + Send + 'static);
 }
 
diff --git a/crates/ra_hir_ty/src/diagnostics.rs b/crates/ra_hir_ty/src/diagnostics.rs
@@ -3,7 +3,7 @@
 use std::any::Any;
 
 use hir_expand::{db::AstDatabase, name::Name, HirFileId, InFile};
-use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr};
+use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr, TextRange};
 use stdx::format_to;
 
 pub use hir_def::{diagnostics::UnresolvedModule, expr::MatchArm};
@@ -13,13 +13,18 @@ pub use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};
 pub struct NoSuchField {
     pub file: HirFileId,
     pub field: AstPtr<ast::RecordField>,
+    pub highlight_range: TextRange,
 }
 
 impl Diagnostic for NoSuchField {
     fn message(&self) -> String {
         "no such field".to_string()
     }
 
+    fn highlight_range(&self) -> TextRange {
+        self.highlight_range
+    }
+
     fn source(&self) -> InFile<SyntaxNodePtr> {
         InFile { file_id: self.file, value: self.field.clone().into() }
     }
@@ -33,6 +38,7 @@ impl Diagnostic for NoSuchField {
 pub struct MissingFields {
     pub file: HirFileId,
     pub field_list: AstPtr<ast::RecordFieldList>,
+    pub highlight_range: TextRange,
     pub missed_fields: Vec<Name>,
 }
 
@@ -44,6 +50,10 @@ impl Diagnostic for MissingFields {
         }
         buf
     }
+    fn highlight_range(&self) -> TextRange {
+        self.highlight_range
+    }
+
     fn source(&self) -> InFile<SyntaxNodePtr> {
         InFile { file_id: self.file, value: self.field_list.clone().into() }
     }
@@ -66,6 +76,7 @@ impl AstDiagnostic for MissingFields {
 pub struct MissingPatFields {
     pub file: HirFileId,
     pub field_list: AstPtr<ast::RecordFieldPatList>,
+    pub highlight_range: TextRange,
     pub missed_fields: Vec<Name>,
 }
 
@@ -77,6 +88,9 @@ impl Diagnostic for MissingPatFields {
         }
         buf
     }
+    fn highlight_range(&self) -> TextRange {
+        self.highlight_range
+    }
     fn source(&self) -> InFile<SyntaxNodePtr> {
         InFile { file_id: self.file, value: self.field_list.clone().into() }
     }
@@ -90,12 +104,16 @@ pub struct MissingMatchArms {
     pub file: HirFileId,
     pub match_expr: AstPtr<ast::Expr>,
     pub arms: AstPtr<ast::MatchArmList>,
+    pub highlight_range: TextRange,
 }
 
 impl Diagnostic for MissingMatchArms {
     fn message(&self) -> String {
         String::from("Missing match arm")
     }
+    fn highlight_range(&self) -> TextRange {
+        self.highlight_range
+    }
     fn source(&self) -> InFile<SyntaxNodePtr> {
         InFile { file_id: self.file, value: self.match_expr.clone().into() }
     }
@@ -108,12 +126,16 @@ impl Diagnostic for MissingMatchArms {
 pub struct MissingOkInTailExpr {
     pub file: HirFileId,
     pub expr: AstPtr<ast::Expr>,
+    pub highlight_range: TextRange,
 }
 
 impl Diagnostic for MissingOkInTailExpr {
     fn message(&self) -> String {
         "wrap return expression in Ok".to_string()
     }
+    fn highlight_range(&self) -> TextRange {
+        self.highlight_range
+    }
     fn source(&self) -> InFile<SyntaxNodePtr> {
         InFile { file_id: self.file, value: self.expr.clone().into() }
     }
diff --git a/crates/ra_hir_ty/src/expr.rs b/crates/ra_hir_ty/src/expr.rs
@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use hir_def::{path::path, resolver::HasResolver, AdtId, FunctionId};
 use hir_expand::diagnostics::DiagnosticSink;
-use ra_syntax::{ast, AstPtr};
+use ra_syntax::{ast, AstNode, AstPtr};
 use rustc_hash::FxHashSet;
 
 use crate::{
@@ -100,6 +100,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                     self.sink.push(MissingFields {
                         file: source_ptr.file_id,
                         field_list: AstPtr::new(&field_list),
+                        highlight_range: field_list.syntax().text_range(),
                         missed_fields,
                     })
                 }
@@ -130,6 +131,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                         self.sink.push(MissingPatFields {
                             file: source_ptr.file_id,
                             field_list: AstPtr::new(&field_list),
+                            highlight_range: field_list.syntax().text_range(),
                             missed_fields,
                         })
                     }
@@ -213,6 +215,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                         file: source_ptr.file_id,
                         match_expr: AstPtr::new(&match_expr),
                         arms: AstPtr::new(&arms),
+                        highlight_range: match_expr.syntax().text_range(),
                     })
                 }
             }
@@ -244,8 +247,13 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
             let (_, source_map) = db.body_with_source_map(self.func.into());
 
             if let Ok(source_ptr) = source_map.expr_syntax(id) {
-                self.sink
-                    .push(MissingOkInTailExpr { file: source_ptr.file_id, expr: source_ptr.value });
+                let root = source_ptr.file_syntax(db.upcast());
+                let highlight_range = source_ptr.value.to_node(&root).syntax().text_range();
+                self.sink.push(MissingOkInTailExpr {
+                    file: source_ptr.file_id,
+                    expr: source_ptr.value,
+                    highlight_range,
+                });
             }
         }
     }
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
@@ -665,6 +665,7 @@ impl Expectation {
 mod diagnostics {
     use hir_def::{expr::ExprId, src::HasSource, FunctionId, Lookup};
     use hir_expand::diagnostics::DiagnosticSink;
+    use ra_syntax::AstNode;
 
     use crate::{db::HirDatabase, diagnostics::NoSuchField};
 
@@ -682,10 +683,16 @@ mod diagnostics {
         ) {
             match self {
                 InferenceDiagnostic::NoSuchField { expr, field } => {
-                    let file = owner.lookup(db.upcast()).source(db.upcast()).file_id;
+                    let source = owner.lookup(db.upcast()).source(db.upcast());
                     let (_, source_map) = db.body_with_source_map(owner.into());
                     let field = source_map.field_syntax(*expr, *field);
-                    sink.push(NoSuchField { file, field })
+                    let root = field.file_syntax(db.upcast());
+                    let highlight_range = field.value.to_node(&root).syntax().text_range();
+                    sink.push(NoSuchField {
+                        file: source.file_id,
+                        field: field.value,
+                        highlight_range,
+                    })
                 }
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -210,7 +210,7 @@ pub struct BodySourceMap {`
`210`	`210`	`expr_map_back: ArenaMap<ExprId, Result<ExprSource, SyntheticSyntax>>,`
`211`	`211`	`pat_map: FxHashMap<PatSource, PatId>,`
`212`	`212`	`pat_map_back: ArenaMap<PatId, Result<PatSource, SyntheticSyntax>>,`
`213`		`- field_map: FxHashMap<(ExprId, usize), AstPtr<ast::RecordField>>,`
	`213`	`+ field_map: FxHashMap<(ExprId, usize), InFile<AstPtr<ast::RecordField>>>,`
`214`	`214`	`expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, HirFileId>,`
`215`	`215`	`}`
`216`	`216`
`@@ -303,7 +303,7 @@ impl BodySourceMap {`
`303`	`303`	`self.pat_map.get(&src).cloned()`
`304`	`304`	`}`
`305`	`305`
`306`		`- pub fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr<ast::RecordField> {`
	`306`	`+ pub fn field_syntax(&self, expr: ExprId, field: usize) -> InFile<AstPtr<ast::RecordField>> {`
`307`	`307`	`self.field_map[&(expr, field)].clone()`
`308`	`308`	`}`
`309`	`309`	`}`
Original file line number	Diff line number	Diff line change
`@@ -320,7 +320,8 @@ impl ExprCollector<'_> {`
`320`	`320`
`321`	`321`	`let res = self.alloc_expr(record_lit, syntax_ptr);`
`322`	`322`	`for (i, ptr) in field_ptrs.into_iter().enumerate() {`
`323`		`- self.source_map.field_map.insert((res, i), ptr);`
	`323`	`+ let src = self.expander.to_source(ptr);`
	`324`	`+ self.source_map.field_map.insert((res, i), src);`
`324`	`325`	`}`
`325`	`326`	`res`
`326`	`327`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`use std::any::Any;`
`4`	`4`
`5`	`5`	`use hir_expand::{db::AstDatabase, name::Name, HirFileId, InFile};`
`6`		`-use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr};`
	`6`	`+use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr, TextRange};`
`7`	`7`	`use stdx::format_to;`
`8`	`8`
`9`	`9`	`pub use hir_def::{diagnostics::UnresolvedModule, expr::MatchArm};`
`@@ -13,13 +13,18 @@ pub use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};`
`13`	`13`	`pub struct NoSuchField {`
`14`	`14`	`pub file: HirFileId,`
`15`	`15`	`pub field: AstPtr<ast::RecordField>,`
	`16`	`+ pub highlight_range: TextRange,`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`impl Diagnostic for NoSuchField {`
`19`	`20`	`fn message(&self) -> String {`
`20`	`21`	`"no such field".to_string()`
`21`	`22`	`}`
`22`	`23`
	`24`	`+ fn highlight_range(&self) -> TextRange {`
	`25`	`+ self.highlight_range`
	`26`	`+ }`
	`27`	`+`
`23`	`28`	`fn source(&self) -> InFile<SyntaxNodePtr> {`
`24`	`29`	`InFile { file_id: self.file, value: self.field.clone().into() }`
`25`	`30`	`}`
`@@ -33,6 +38,7 @@ impl Diagnostic for NoSuchField {`
`33`	`38`	`pub struct MissingFields {`
`34`	`39`	`pub file: HirFileId,`
`35`	`40`	`pub field_list: AstPtr<ast::RecordFieldList>,`
	`41`	`+ pub highlight_range: TextRange,`
`36`	`42`	`pub missed_fields: Vec<Name>,`
`37`	`43`	`}`
`38`	`44`
`@@ -44,6 +50,10 @@ impl Diagnostic for MissingFields {`
`44`	`50`	`}`
`45`	`51`	`buf`
`46`	`52`	`}`
	`53`	`+ fn highlight_range(&self) -> TextRange {`
	`54`	`+ self.highlight_range`
	`55`	`+ }`
	`56`	`+`
`47`	`57`	`fn source(&self) -> InFile<SyntaxNodePtr> {`
`48`	`58`	`InFile { file_id: self.file, value: self.field_list.clone().into() }`
`49`	`59`	`}`
`@@ -66,6 +76,7 @@ impl AstDiagnostic for MissingFields {`
`66`	`76`	`pub struct MissingPatFields {`
`67`	`77`	`pub file: HirFileId,`
`68`	`78`	`pub field_list: AstPtr<ast::RecordFieldPatList>,`
	`79`	`+ pub highlight_range: TextRange,`
`69`	`80`	`pub missed_fields: Vec<Name>,`
`70`	`81`	`}`
`71`	`82`
`@@ -77,6 +88,9 @@ impl Diagnostic for MissingPatFields {`
`77`	`88`	`}`
`78`	`89`	`buf`
`79`	`90`	`}`
	`91`	`+ fn highlight_range(&self) -> TextRange {`
	`92`	`+ self.highlight_range`
	`93`	`+ }`
`80`	`94`	`fn source(&self) -> InFile<SyntaxNodePtr> {`
`81`	`95`	`InFile { file_id: self.file, value: self.field_list.clone().into() }`
`82`	`96`	`}`
`@@ -90,12 +104,16 @@ pub struct MissingMatchArms {`
`90`	`104`	`pub file: HirFileId,`
`91`	`105`	`pub match_expr: AstPtr<ast::Expr>,`
`92`	`106`	`pub arms: AstPtr<ast::MatchArmList>,`
	`107`	`+ pub highlight_range: TextRange,`
`93`	`108`	`}`
`94`	`109`
`95`	`110`	`impl Diagnostic for MissingMatchArms {`
`96`	`111`	`fn message(&self) -> String {`
`97`	`112`	`String::from("Missing match arm")`
`98`	`113`	`}`
	`114`	`+ fn highlight_range(&self) -> TextRange {`
	`115`	`+ self.highlight_range`
	`116`	`+ }`
`99`	`117`	`fn source(&self) -> InFile<SyntaxNodePtr> {`
`100`	`118`	`InFile { file_id: self.file, value: self.match_expr.clone().into() }`
`101`	`119`	`}`
`@@ -108,12 +126,16 @@ impl Diagnostic for MissingMatchArms {`
`108`	`126`	`pub struct MissingOkInTailExpr {`
`109`	`127`	`pub file: HirFileId,`
`110`	`128`	`pub expr: AstPtr<ast::Expr>,`
	`129`	`+ pub highlight_range: TextRange,`
`111`	`130`	`}`
`112`	`131`
`113`	`132`	`impl Diagnostic for MissingOkInTailExpr {`
`114`	`133`	`fn message(&self) -> String {`
`115`	`134`	`"wrap return expression in Ok".to_string()`
`116`	`135`	`}`
	`136`	`+ fn highlight_range(&self) -> TextRange {`
	`137`	`+ self.highlight_range`
	`138`	`+ }`
`117`	`139`	`fn source(&self) -> InFile<SyntaxNodePtr> {`
`118`	`140`	`InFile { file_id: self.file, value: self.expr.clone().into() }`
`119`	`141`	`}`