From a10447457a7bd2d02862e1b6f1ba097d2231ed98 Mon Sep 17 00:00:00 2001
From: timofey <tim@ongoteam.yaconnect.com>
Date: Fri, 30 Jun 2023 21:00:32 +0000
Subject: [PATCH] `TracedInject`

---
 src/rstd/tracing/traceable.rs | 39 ++++++++---------------------------
 1 file changed, 9 insertions(+), 30 deletions(-)

diff --git a/src/rstd/tracing/traceable.rs b/src/rstd/tracing/traceable.rs
index 7d0d762..f73ef24 100644
--- a/src/rstd/tracing/traceable.rs
+++ b/src/rstd/tracing/traceable.rs
@@ -1,27 +1,12 @@
-use crate::rstd::{cast::*, typeless::*};
+use crate::rstd::inject::*;
 
 use super::*;
 
-struct TracedResolver<'a, Ctx: Context<'a>> {
-    resolver: Rc<dyn Resolver<'a, Ctx>>,
-}
+struct TracedInject;
 
-impl<'a, Ctx: Context<'a, _Tm = TracedInstance>> TracedResolver<'a, Ctx> {
-    fn wrap(resolver: Rc<dyn Resolver<'a, Ctx>>) -> Rc<dyn Resolver<'a, Ctx>> {
-        Rc::new(Self { resolver })
-    }
-}
-
-impl<'a, Ctx: Context<'a, _Tm = TracedInstance>> Resolver<'a, Ctx> for TracedResolver<'a, Ctx> {
-    fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, Ctx> {
-        self.resolver
-            .clone()
-            .resolve_map(address, |resolved| {
-                let (src, resolver) = resolved?;
-                let delayed: Rc<dyn Resolver<'a, Ctx>> = Rc::new(TracedResolver { resolver });
-                Ok((src, delayed))
-            })
-            .after_resolution()
+impl<'a, Ctx: Context<'a, _Tm = TracedInstance>> Inject<'a, Ctx> for TracedInject {
+    fn inject<A: 'a>(&self, fa: Wrapped<'a, Ctx, A>) -> Wrapped<'a, Ctx, A> {
+        fa.after_resolution()
     }
 }
 
@@ -34,15 +19,9 @@ pub trait Traceable<'a, Ctx: Context<'a, _Tm = TracedInstance>>:
     ///
     /// [^extra]: applying [`Traceable::trace`] multiple times
     /// might affect the trace in undesireable ways
-    fn trace(self: Rc<Self>) -> ParseResultA<'a, Ctx, Self>;
-}
-
-impl<'a, Ctx: Context<'a, _Tm = TracedInstance>, A: Mentionable<'a, Ctx>> Traceable<'a, Ctx> for A
-where
-    Ctx::LookupError: From<CastError<'a>>,
-{
-    fn trace(self: Rc<Self>) -> ParseResultA<'a, Ctx, Self> {
-        let factory = self.factory();
-        TypelessMentionable::from_typed(self).cast_full(factory, TracedResolver::wrap)
+    fn trace(&self) -> ParseResultA<'a, Ctx, Self> {
+        Rc::new(TracedInject).inject_mentionable(self)
     }
 }
+
+impl<'a, Ctx: Context<'a, _Tm = TracedInstance>, A: Mentionable<'a, Ctx>> Traceable<'a, Ctx> for A {}