save_analysis: better handle paths

marmeladema · marmeladema · commit 7b94fdb95cc3 · 2020-06-09T00:11:32.000+01:00
diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs
@@ -199,23 +199,23 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
         self.dumper.compilation_opts(data);
     }
 
-    fn write_sub_paths(&mut self, path: &'tcx hir::Path<'tcx>) {
-        for seg in path.segments {
+    fn write_segments(&mut self, segments: impl IntoIterator<Item = &'tcx hir::PathSegment<'tcx>>) {
+        for seg in segments {
             if let Some(data) = self.save_ctxt.get_path_segment_data(seg) {
                 self.dumper.dump_ref(data);
             }
         }
     }
 
+    fn write_sub_paths(&mut self, path: &'tcx hir::Path<'tcx>) {
+        self.write_segments(path.segments)
+    }
+
     // As write_sub_paths, but does not process the last ident in the path (assuming it
     // will be processed elsewhere). See note on write_sub_paths about global.
     fn write_sub_paths_truncated(&mut self, path: &'tcx hir::Path<'tcx>) {
         if let [segments @ .., _] = path.segments {
-            for seg in segments {
-                if let Some(data) = self.save_ctxt.get_path_segment_data(seg) {
-                    self.dumper.dump_ref(data);
-                }
-            }
+            self.write_segments(segments)
         }
     }
 
@@ -643,7 +643,7 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
         self.nest_tables(map.local_def_id(item.hir_id), |v| {
             v.visit_ty(&typ);
             if let &Some(ref trait_ref) = trait_ref {
-                v.process_path(trait_ref.hir_ref_id, &trait_ref.path);
+                v.process_path(trait_ref.hir_ref_id, &hir::QPath::Resolved(None, &trait_ref.path));
             }
             v.process_generic_params(generics, "", item.hir_id);
             for impl_item in impl_items {
@@ -746,7 +746,7 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
         }
     }
 
-    fn dump_path_ref(&mut self, id: hir::HirId, path: &hir::Path<'tcx>) {
+    fn dump_path_ref(&mut self, id: hir::HirId, path: &hir::QPath<'tcx>) {
         let path_data = self.save_ctxt.get_path_data(id, path);
         if let Some(path_data) = path_data {
             self.dumper.dump_ref(path_data);
@@ -760,14 +760,30 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
         }
     }
 
-    fn process_path(&mut self, id: hir::HirId, path: &'tcx hir::Path<'tcx>) {
-        if self.span.filter_generated(path.span) {
+    fn process_path(&mut self, id: hir::HirId, path: &hir::QPath<'tcx>) {
+        let span = match path {
+            hir::QPath::Resolved(_, path) => path.span,
+            hir::QPath::TypeRelative(_, segment) => segment.ident.span,
+        };
+        if self.span.filter_generated(span) {
             return;
         }
         self.dump_path_ref(id, path);
 
         // Type arguments
-        for seg in path.segments {
+        let segments = match path {
+            hir::QPath::Resolved(ty, path) => {
+                if let Some(ty) = ty {
+                    self.visit_ty(ty);
+                }
+                path.segments
+            }
+            hir::QPath::TypeRelative(ty, segment) => {
+                self.visit_ty(ty);
+                std::slice::from_ref(*segment)
+            }
+        };
+        for seg in segments {
             if let Some(ref generic_args) = seg.args {
                 for arg in generic_args.args {
                     if let hir::GenericArg::Type(ref ty) = arg {
@@ -777,7 +793,9 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
             }
         }
 
-        self.write_sub_paths_truncated(path);
+        if let hir::QPath::Resolved(_, path) = path {
+            self.write_sub_paths_truncated(path);
+        }
     }
 
     fn process_struct_lit(
@@ -931,9 +949,7 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
         }
 
         for (id, ref path) in collector.collected_paths {
-            if let hir::QPath::Resolved(_, path) = path {
-                self.process_path(id, path);
-            }
+            self.process_path(id, path);
         }
     }
 
@@ -1135,7 +1151,10 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
     fn process_bounds(&mut self, bounds: hir::GenericBounds<'tcx>) {
         for bound in bounds {
             if let hir::GenericBound::Trait(ref trait_ref, _) = *bound {
-                self.process_path(trait_ref.trait_ref.hir_ref_id, &trait_ref.trait_ref.path)
+                self.process_path(
+                    trait_ref.trait_ref.hir_ref_id,
+                    &hir::QPath::Resolved(None, &trait_ref.trait_ref.path),
+                )
             }
         }
     }
@@ -1330,13 +1349,16 @@ impl<'l, 'tcx> Visitor<'tcx> for DumpVisitor<'l, 'tcx> {
     fn visit_ty(&mut self, t: &'tcx hir::Ty<'tcx>) {
         self.process_macro_use(t.span);
         match t.kind {
-            hir::TyKind::Path(hir::QPath::Resolved(_, path)) => {
+            hir::TyKind::Path(ref path) => {
                 if generated_code(t.span) {
                     return;
                 }
 
                 if let Some(id) = self.lookup_def_id(t.hir_id) {
-                    let sub_span = path.segments.last().unwrap().ident.span;
+                    let sub_span = match path {
+                        hir::QPath::Resolved(_, path) => path.segments.last().unwrap().ident.span,
+                        hir::QPath::TypeRelative(_, segment) => segment.ident.span,
+                    };
                     let span = self.span_from_span(sub_span);
                     self.dumper.dump_ref(Ref {
                         kind: RefKind::Type,
@@ -1345,8 +1367,10 @@ impl<'l, 'tcx> Visitor<'tcx> for DumpVisitor<'l, 'tcx> {
                     });
                 }
 
-                self.write_sub_paths_truncated(path);
-                intravisit::walk_path(self, path);
+                if let hir::QPath::Resolved(_, path) = path {
+                    self.write_sub_paths_truncated(path);
+                }
+                intravisit::walk_qpath(self, path, t.hir_id, t.span);
             }
             hir::TyKind::Array(ref ty, ref anon_const) => {
                 self.visit_ty(ty);
@@ -1355,6 +1379,10 @@ impl<'l, 'tcx> Visitor<'tcx> for DumpVisitor<'l, 'tcx> {
                     v.visit_expr(&map.body(anon_const.body).value)
                 });
             }
+            hir::TyKind::Def(item_id, _) => {
+                let item = self.tcx.hir().item(item_id.id);
+                self.nest_tables(self.tcx.hir().local_def_id(item_id.id), |v| v.visit_item(item));
+            }
             _ => intravisit::walk_ty(self, t),
         }
     }
@@ -1432,8 +1460,8 @@ impl<'l, 'tcx> Visitor<'tcx> for DumpVisitor<'l, 'tcx> {
         self.visit_expr(&arm.body);
     }
 
-    fn visit_path(&mut self, p: &'tcx hir::Path<'tcx>, id: hir::HirId) {
-        self.process_path(id, p);
+    fn visit_qpath(&mut self, path: &'tcx hir::QPath<'tcx>, id: hir::HirId, _: Span) {
+        self.process_path(id, path);
     }
 
     fn visit_stmt(&mut self, s: &'tcx hir::Stmt<'tcx>) {
diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs
@@ -579,7 +579,7 @@ impl<'l, 'tcx> SaveContext<'l, 'tcx> {
                     ref_id: def_id.or(decl_id).map(id_from_def_id).unwrap_or_else(null_id),
                 }))
             }
-            hir::ExprKind::Path(hir::QPath::Resolved(_, path)) => {
+            hir::ExprKind::Path(ref path) => {
                 self.get_path_data(expr.hir_id, path).map(Data::RefData)
             }
             _ => {
@@ -631,8 +631,12 @@ impl<'l, 'tcx> SaveContext<'l, 'tcx> {
         }
     }
 
-    pub fn get_path_data(&self, id: hir::HirId, path: &hir::Path<'_>) -> Option<Ref> {
-        path.segments.last().and_then(|seg| {
+    pub fn get_path_data(&self, id: hir::HirId, path: &hir::QPath<'_>) -> Option<Ref> {
+        let segment = match path {
+            hir::QPath::Resolved(_, path) => path.segments.last(),
+            hir::QPath::TypeRelative(_, segment) => Some(*segment),
+        };
+        segment.and_then(|seg| {
             self.get_path_segment_data(seg).or_else(|| self.get_path_segment_data_with_id(seg, id))
         })
     }
diff --git a/src/librustc_save_analysis/sig.rs b/src/librustc_save_analysis/sig.rs
@@ -281,6 +281,22 @@ impl<'hir> Sig for hir::Ty<'hir> {
                     })
                 }
             }
+            hir::TyKind::Path(hir::QPath::TypeRelative(ty, segment)) => {
+                let nested_ty = ty.make(offset + 1, id, scx)?;
+                let prefix = format!("<{}>::", nested_ty.text,);
+
+                let name = path_segment_to_string(segment);
+                let res = scx.get_path_res(id.ok_or("Missing id for Path")?);
+                let id = id_from_def_id(res.def_id());
+
+                let start = offset + prefix.len();
+                let end = start + name.len();
+                Ok(Signature {
+                    text: prefix + &name,
+                    defs: vec![],
+                    refs: vec![SigElement { id, start, end }],
+                })
+            }
             hir::TyKind::TraitObject(bounds, ..) => {
                 // FIXME recurse into bounds
                 let bounds: Vec<hir::GenericBound<'_>> = bounds
@@ -311,7 +327,6 @@ impl<'hir> Sig for hir::Ty<'hir> {
             hir::TyKind::Typeof(_)
             | hir::TyKind::Infer
             | hir::TyKind::Def(..)
-            | hir::TyKind::Path(..)
             | hir::TyKind::Err => Err("Ty"),
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -199,23 +199,23 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {`
`199`	`199`	`self.dumper.compilation_opts(data);`
`200`	`200`	`}`
`201`	`201`
`202`		`- fn write_sub_paths(&mut self, path: &'tcx hir::Path<'tcx>) {`
`203`		`- for seg in path.segments {`
	`202`	`+ fn write_segments(&mut self, segments: impl IntoIterator<Item = &'tcx hir::PathSegment<'tcx>>) {`
	`203`	`+ for seg in segments {`
`204`	`204`	`if let Some(data) = self.save_ctxt.get_path_segment_data(seg) {`
`205`	`205`	`self.dumper.dump_ref(data);`
`206`	`206`	`}`
`207`	`207`	`}`
`208`	`208`	`}`
`209`	`209`
	`210`	`+ fn write_sub_paths(&mut self, path: &'tcx hir::Path<'tcx>) {`
	`211`	`+ self.write_segments(path.segments)`
	`212`	`+ }`
	`213`	`+`
`210`	`214`	`// As write_sub_paths, but does not process the last ident in the path (assuming it`
`211`	`215`	`// will be processed elsewhere). See note on write_sub_paths about global.`
`212`	`216`	`fn write_sub_paths_truncated(&mut self, path: &'tcx hir::Path<'tcx>) {`
`213`	`217`	`if let [segments @ .., _] = path.segments {`
`214`		`- for seg in segments {`
`215`		`- if let Some(data) = self.save_ctxt.get_path_segment_data(seg) {`
`216`		`- self.dumper.dump_ref(data);`
`217`		`- }`
`218`		`- }`
	`218`	`+ self.write_segments(segments)`
`219`	`219`	`}`
`220`	`220`	`}`
`221`	`221`
`@@ -643,7 +643,7 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {`
`643`	`643`	`self.nest_tables(map.local_def_id(item.hir_id), \|v\| {`
`644`	`644`	`v.visit_ty(&typ);`
`645`	`645`	`if let &Some(ref trait_ref) = trait_ref {`
`646`		`- v.process_path(trait_ref.hir_ref_id, &trait_ref.path);`
	`646`	`+ v.process_path(trait_ref.hir_ref_id, &hir::QPath::Resolved(None, &trait_ref.path));`
`647`	`647`	`}`
`648`	`648`	`v.process_generic_params(generics, "", item.hir_id);`
`649`	`649`	`for impl_item in impl_items {`
`@@ -746,7 +746,7 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {`
`746`	`746`	`}`
`747`	`747`	`}`
`748`	`748`
`749`		`- fn dump_path_ref(&mut self, id: hir::HirId, path: &hir::Path<'tcx>) {`
	`749`	`+ fn dump_path_ref(&mut self, id: hir::HirId, path: &hir::QPath<'tcx>) {`
`750`	`750`	`let path_data = self.save_ctxt.get_path_data(id, path);`
`751`	`751`	`if let Some(path_data) = path_data {`
`752`	`752`	`self.dumper.dump_ref(path_data);`
`@@ -760,14 +760,30 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {`
`760`	`760`	`}`
`761`	`761`	`}`
`762`	`762`
`763`		`- fn process_path(&mut self, id: hir::HirId, path: &'tcx hir::Path<'tcx>) {`
`764`		`- if self.span.filter_generated(path.span) {`
	`763`	`+ fn process_path(&mut self, id: hir::HirId, path: &hir::QPath<'tcx>) {`
	`764`	`+ let span = match path {`
	`765`	`+ hir::QPath::Resolved(_, path) => path.span,`
	`766`	`+ hir::QPath::TypeRelative(_, segment) => segment.ident.span,`
	`767`	`+ };`
	`768`	`+ if self.span.filter_generated(span) {`
`765`	`769`	`return;`
`766`	`770`	`}`
`767`	`771`	`self.dump_path_ref(id, path);`
`768`	`772`
`769`	`773`	`// Type arguments`
`770`		`- for seg in path.segments {`
	`774`	`+ let segments = match path {`
	`775`	`+ hir::QPath::Resolved(ty, path) => {`
	`776`	`+ if let Some(ty) = ty {`
	`777`	`+ self.visit_ty(ty);`
	`778`	`+ }`
	`779`	`+ path.segments`
	`780`	`+ }`
	`781`	`+ hir::QPath::TypeRelative(ty, segment) => {`
	`782`	`+ self.visit_ty(ty);`
	`783`	`+ std::slice::from_ref(*segment)`
	`784`	`+ }`
	`785`	`+ };`
	`786`	`+ for seg in segments {`
`771`	`787`	`if let Some(ref generic_args) = seg.args {`
`772`	`788`	`for arg in generic_args.args {`
`773`	`789`	`if let hir::GenericArg::Type(ref ty) = arg {`
`@@ -777,7 +793,9 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {`
`777`	`793`	`}`
`778`	`794`	`}`
`779`	`795`
`780`		`- self.write_sub_paths_truncated(path);`
	`796`	`+ if let hir::QPath::Resolved(_, path) = path {`
	`797`	`+ self.write_sub_paths_truncated(path);`
	`798`	`+ }`
`781`	`799`	`}`
`782`	`800`
`783`	`801`	`fn process_struct_lit(`
`@@ -931,9 +949,7 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {`
`931`	`949`	`}`
`932`	`950`
`933`	`951`	`for (id, ref path) in collector.collected_paths {`
`934`		`- if let hir::QPath::Resolved(_, path) = path {`
`935`		`- self.process_path(id, path);`
`936`		`- }`
	`952`	`+ self.process_path(id, path);`
`937`	`953`	`}`
`938`	`954`	`}`
`939`	`955`
`@@ -1135,7 +1151,10 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {`
`1135`	`1151`	`fn process_bounds(&mut self, bounds: hir::GenericBounds<'tcx>) {`
`1136`	`1152`	`for bound in bounds {`
`1137`	`1153`	`if let hir::GenericBound::Trait(ref trait_ref, _) = *bound {`
`1138`		`- self.process_path(trait_ref.trait_ref.hir_ref_id, &trait_ref.trait_ref.path)`
	`1154`	`+ self.process_path(`
	`1155`	`+ trait_ref.trait_ref.hir_ref_id,`
	`1156`	`+ &hir::QPath::Resolved(None, &trait_ref.trait_ref.path),`
	`1157`	`+ )`
`1139`	`1158`	`}`
`1140`	`1159`	`}`
`1141`	`1160`	`}`
`@@ -1330,13 +1349,16 @@ impl<'l, 'tcx> Visitor<'tcx> for DumpVisitor<'l, 'tcx> {`
`1330`	`1349`	`fn visit_ty(&mut self, t: &'tcx hir::Ty<'tcx>) {`
`1331`	`1350`	`self.process_macro_use(t.span);`
`1332`	`1351`	`match t.kind {`
`1333`		`- hir::TyKind::Path(hir::QPath::Resolved(_, path)) => {`
	`1352`	`+ hir::TyKind::Path(ref path) => {`
`1334`	`1353`	`if generated_code(t.span) {`
`1335`	`1354`	`return;`
`1336`	`1355`	`}`
`1337`	`1356`
`1338`	`1357`	`if let Some(id) = self.lookup_def_id(t.hir_id) {`
`1339`		`- let sub_span = path.segments.last().unwrap().ident.span;`
	`1358`	`+ let sub_span = match path {`
	`1359`	`+ hir::QPath::Resolved(_, path) => path.segments.last().unwrap().ident.span,`
	`1360`	`+ hir::QPath::TypeRelative(_, segment) => segment.ident.span,`
	`1361`	`+ };`
`1340`	`1362`	`let span = self.span_from_span(sub_span);`
`1341`	`1363`	`self.dumper.dump_ref(Ref {`
`1342`	`1364`	`kind: RefKind::Type,`
`@@ -1345,8 +1367,10 @@ impl<'l, 'tcx> Visitor<'tcx> for DumpVisitor<'l, 'tcx> {`
`1345`	`1367`	`});`
`1346`	`1368`	`}`
`1347`	`1369`
`1348`		`- self.write_sub_paths_truncated(path);`
`1349`		`- intravisit::walk_path(self, path);`
	`1370`	`+ if let hir::QPath::Resolved(_, path) = path {`
	`1371`	`+ self.write_sub_paths_truncated(path);`
	`1372`	`+ }`
	`1373`	`+ intravisit::walk_qpath(self, path, t.hir_id, t.span);`
`1350`	`1374`	`}`
`1351`	`1375`	`hir::TyKind::Array(ref ty, ref anon_const) => {`
`1352`	`1376`	`self.visit_ty(ty);`
`@@ -1355,6 +1379,10 @@ impl<'l, 'tcx> Visitor<'tcx> for DumpVisitor<'l, 'tcx> {`
`1355`	`1379`	`v.visit_expr(&map.body(anon_const.body).value)`
`1356`	`1380`	`});`
`1357`	`1381`	`}`
	`1382`	`+ hir::TyKind::Def(item_id, _) => {`
	`1383`	`+ let item = self.tcx.hir().item(item_id.id);`
	`1384`	`+ self.nest_tables(self.tcx.hir().local_def_id(item_id.id), \|v\| v.visit_item(item));`
	`1385`	`+ }`
`1358`	`1386`	`_ => intravisit::walk_ty(self, t),`
`1359`	`1387`	`}`
`1360`	`1388`	`}`
`@@ -1432,8 +1460,8 @@ impl<'l, 'tcx> Visitor<'tcx> for DumpVisitor<'l, 'tcx> {`
`1432`	`1460`	`self.visit_expr(&arm.body);`
`1433`	`1461`	`}`
`1434`	`1462`
`1435`		`- fn visit_path(&mut self, p: &'tcx hir::Path<'tcx>, id: hir::HirId) {`
`1436`		`- self.process_path(id, p);`
	`1463`	`+ fn visit_qpath(&mut self, path: &'tcx hir::QPath<'tcx>, id: hir::HirId, _: Span) {`
	`1464`	`+ self.process_path(id, path);`
`1437`	`1465`	`}`
`1438`	`1466`
`1439`	`1467`	`fn visit_stmt(&mut self, s: &'tcx hir::Stmt<'tcx>) {`
Original file line number	Diff line number	Diff line change
`@@ -579,7 +579,7 @@ impl<'l, 'tcx> SaveContext<'l, 'tcx> {`
`579`	`579`	`ref_id: def_id.or(decl_id).map(id_from_def_id).unwrap_or_else(null_id),`
`580`	`580`	`}))`
`581`	`581`	`}`
`582`		`- hir::ExprKind::Path(hir::QPath::Resolved(_, path)) => {`
	`582`	`+ hir::ExprKind::Path(ref path) => {`
`583`	`583`	`self.get_path_data(expr.hir_id, path).map(Data::RefData)`
`584`	`584`	`}`
`585`	`585`	`_ => {`
`@@ -631,8 +631,12 @@ impl<'l, 'tcx> SaveContext<'l, 'tcx> {`
`631`	`631`	`}`
`632`	`632`	`}`
`633`	`633`
`634`		`- pub fn get_path_data(&self, id: hir::HirId, path: &hir::Path<'_>) -> Option<Ref> {`
`635`		`- path.segments.last().and_then(\|seg\| {`
	`634`	`+ pub fn get_path_data(&self, id: hir::HirId, path: &hir::QPath<'_>) -> Option<Ref> {`
	`635`	`+ let segment = match path {`
	`636`	`+ hir::QPath::Resolved(_, path) => path.segments.last(),`
	`637`	`+ hir::QPath::TypeRelative(_, segment) => Some(*segment),`
	`638`	`+ };`
	`639`	`+ segment.and_then(\|seg\| {`
`636`	`640`	`self.get_path_segment_data(seg).or_else(\|\| self.get_path_segment_data_with_id(seg, id))`
`637`	`641`	`})`
`638`	`642`	`}`