WIP,UNTIDY: debugging x test -v tests/incremental/static_stable_hash/issue-49301.rs

Author: futile

compiler/rustc_ast/src/tokenstream.rs

@@ -139,13 +139,19 @@ impl fmt::Debug for LazyAttrTokenStream {
 
 impl<S: SpanEncoder> Encodable<S> for LazyAttrTokenStream {
     fn encode(&self, _s: &mut S) {
-        panic!("Attempted to encode LazyAttrTokenStream");
+        eprintln!("ENCODING {self:?}");
+        self.to_attr_token_stream().encode(_s);
+        // panic!("Attempted to encode {self:?}");
     }
 }
 
 impl<D: SpanDecoder> Decodable<D> for LazyAttrTokenStream {
     fn decode(_d: &mut D) -> Self {
-        panic!("Attempted to decode LazyAttrTokenStream");
+        let ats = AttrTokenStream::decode(_d);
+        let res = LazyAttrTokenStream::new(ats);
+        eprintln!("DECODED {res:?}");
+        res
+        // panic!("Attempted to decode LazyAttrTokenStream");
     }
 }
 

compiler/rustc_expand/src/expand.rs

@@ -400,7 +400,8 @@ pub fn expand_legacy_bang<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: (LocalExpnId, LocalExpnId),
 ) -> Result<(&'tcx TokenStream, usize), (Span, ErrorGuaranteed)> {
-    let (invoc_id, current_expansion) = key;
+    let (invoc_id, current_expansion) = dbg!(key);
+    dbg!(invoc_id.to_expn_id().expn_hash(), current_expansion.to_expn_id().expn_hash());
     let map = tcx.macro_map.borrow();
     let (arg, span, expander) = map.get(&invoc_id).as_ref().unwrap();
     expander

compiler/rustc_middle/src/arena.rs

@@ -119,7 +119,7 @@ macro_rules! arena_types {
             [decode] specialization_graph: rustc_middle::traits::specialization_graph::Graph,
             [] crate_inherent_impls: rustc_middle::ty::CrateInherentImpls,
             [] hir_owner_nodes: rustc_hir::OwnerNodes<'tcx>,
-            [] expand_legacy_bang: rustc_ast::tokenstream::TokenStream,
+            [decode] expand_legacy_bang: rustc_ast::tokenstream::TokenStream,
         ]);
     )
 }

compiler/rustc_middle/src/ty/codec.rs

@@ -335,13 +335,15 @@ impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> RefDecodable<'tcx, D> for ty::List<Ty
     }
 }
 
-impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> RefDecodable<'tcx, D>
-    for rustc_ast::tokenstream::TokenStream
-{
-    fn decode(_decoder: &mut D) -> &'tcx Self {
-        todo!("felix foobar next")
-    }
-}
+// impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> RefDecodable<'tcx, D>
+//     for rustc_ast::tokenstream::TokenStream
+// {
+//     fn decode(_decoder: &mut D) -> &'tcx Self {
+//         // use rustc_ast::HasTokens;
+//         // _decoder.interner().tokens_mut().unwrap().as_ref();
+//         todo!("felix foobar next")
+//     }
+// }
 
 impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> RefDecodable<'tcx, D>
     for ty::List<ty::PolyExistentialPredicate<'tcx>>

compiler/rustc_resolve/src/macros.rs

@@ -539,6 +539,11 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
         invoc_id: LocalExpnId,
         current_expansion: LocalExpnId,
     ) -> Result<(TokenStream, usize), (Span, ErrorGuaranteed)> {
+        dbg!((
+            "resolver",
+            invoc_id.to_expn_id().expn_hash(),
+            current_expansion.to_expn_id().expn_hash()
+        ));
         self.tcx()
             .expand_legacy_bang((invoc_id, current_expansion))
             .map(|(tts, i)| (tts.clone(), i))