Inject::inject_mentionable

src/testing/inject.rs

@@ -1,9 +1,22 @@
 use std::rc::Rc;
 
 use crate::rcore::*;
+use crate::rstd::{singular::*, *};
 
-trait Inject<'a, Ctx: Context<'a>>: 'a {
+trait Inject<'a, Ctx: Context<'a>>: 'a + Sized {
     fn inject<A: 'a>(&self, fa: Wrapped<'a, Ctx, A>) -> Wrapped<'a, Ctx, A>;
+
+    fn inject_mentionable<A: Mentionable<'a, Ctx>>(
+        self: Rc<Self>,
+        a: &A,
+    ) -> ParseResultA<'a, Ctx, A> {
+        let factory = a.factory();
+        let inject = self;
+        let resolver = SingularResolver::from_mentionable(a).into_rc();
+        let resolver = InjectedResolver { resolver, inject }.into_rc();
+        let bytes = a.bytes();
+        factory.parse_slice(&bytes, &resolver)
+    }
 }
 
 struct InjectedResolver<'a, Ctx: Context<'a>, F: Inject<'a, Ctx>> {
@@ -12,16 +25,15 @@ struct InjectedResolver<'a, Ctx: Context<'a>, F: Inject<'a, Ctx>> {
 }
 
 impl<'a, Ctx: Context<'a>, F: Inject<'a, Ctx>> Resolver<'a, Ctx> for InjectedResolver<'a, Ctx, F> {
-    fn resolve(self: Rc<Self>, address: crate::rcore::Address) -> HashResolution<'a, Ctx> {
+    fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, Ctx> {
         let inject = self.inject.clone();
         self.inject.inject(
             self.resolver
                 .clone()
                 .resolve_map(address, |resolved| match resolved {
-                    Ok((source, resolver)) => Ok((
+                    Ok((source, resolver)) => {
-                        source,
+                        Ok((source, InjectedResolver { resolver, inject }.into_rc()))
-                        Rc::new(InjectedResolver { resolver, inject }) as Rc<dyn Resolver<'a, Ctx>>,
+                    }
-                    )),
                     Err(e) => Err(e),
                 }),
         )