Change wrap validation behavior + mount API

Docs/attributes.md

@@ -152,8 +152,9 @@ The presence of a builder attribute should do two things:
 Wraps allow you to execute before or after the entry point which modifies the input or output, or prevents the entry point
 from running altogether.
 
-> **Warning**: Wraps *do not* support property injection by default. 
->
+> [!IMPORTANT]
+> Wraps *do not* support property injection by default.
+> 
 > You can use `LilikoiInjector.Inject(mount, this)` and `LilikoiInjector.Deject(mount, this)` to emulate standard injection in the before and after methods, respectively.
 > 
 > (If you do this, it is **highly** recommended to call `Deject` at the end of your `After` function as the injections may rely on this to prevent leaks.)

Docs/containers.md

@@ -44,3 +44,4 @@ so that users and libraries have ways to hurl opaque data around the entry point
 4. Entry point
 5. Wrap after execution
 7. Dejection of host
+8. Casting of entry return and wrap return into container result

Docs/mounts.md

@@ -15,3 +15,20 @@ The only requirement is that each entry into the mount have a unique type.
 
 Additionally, several Lilikoi Types expose a mount interface. You can add entries to a `LilikoiMutator`'s
 mount and see those entries in the finalized `LilikoiContainer`'s mount.
+
+For example, a target attribute can place metadata (or even itself!) into the LilikoiMutator
+for the creator of the Container to consume for metadata about the target. This functionality
+is used frequently in [BitMod](https://github.com/Mooshua/BitMod)
+
+## Performance
+
+Mounts are slower than normal dictionaries, but not by much.
+A mount typically takes 30-50ns to look up a single object, regardless of
+how many objects are in the mount. 
+
+Writing and checking for existance is typically
+in the 20ns range as it does not need to unbox anything.
+
+Performance for mounts is not really a big deal, as they are usually read only once
+or twice by a consuming program, compared to normal dictionaries which are constantly
+enumerated and updated.

Docs/overview.md

@@ -3,7 +3,7 @@
 Lilikoi is designed to replace expensive reflection logic and deliver a consistent API surface
 from the perspective of both framework and framework consumer.
 
-Lilikoi provides APIs for frameworks to define declarative helpers, such as parameter injection
+Lilikoi provides APIs for event producers to define declarative helpers, such as parameter injection
 and before/after hooks (called wraps). Additionally, users can specify arbitrary types in the
 parameters of their entry point, and Lilikoi will resolve those parameters to a wildcard injection
 if one is available.
@@ -26,7 +26,7 @@ scaffolded to replace repetitive imperative logic.
 - **Parameter** injection is for values that are *expected* to change both value and behavior between invocations,
   depending on the input value for the container.
 - **Wildcards** are similar to parameter injection, but are detected by the parameter type and not an attribute.
-  They have no explicit usage
+  They have no explicit usage, and can be assigned by the target and mutator attributes.
 
 ## Other Attributes
 
@@ -38,6 +38,10 @@ scaffolded to replace repetitive imperative logic.
   Mutators can be used to add advanced functionality to containers, and even smuggle metadata from the compilation process
   to the final container object using the provided mount interface.
 
+- **Targets** are used by the Scanner APIs to find containers within assemblies and types.
+  Targets are not required to make containers, but make the process of creating them
+  significantly easier and more consistent.
+
 ## Headless
 Lilikoi has some APIs, called "Headless" APIs, which are designed to be used without the full framework.
 These headless APIs can be used to piecemeal implement Lilikoi behavior (or extend lilikoi injection behavior

Lilikoi.Benchmarks/Mahogany/Applications/InjectSimple/Simple.cs

@@ -1,7 +1,7 @@
 //       ========================
 //       Lilikoi.Benchmarks::Simple.cs
 //       (c) 2023. Distributed under the MIT License
-// 
+//
 // ->    Created: 22.12.2022
 // ->    Bumped: 06.02.2023
 //       ========================
@@ -27,8 +27,8 @@ public static Simple Create()
 	}
 
 	[MethodImpl(MethodImplOptions.NoInlining)]
-	public bool Execute()
+	public object Execute()
 	{
-		return 1 == 0; // Random.Shared.Next() == Value;
+		return "Hello, World!";
 	}
-}
+}

Lilikoi.Benchmarks/Mahogany/Applications/InjectSimple/SimpleInjectHost.cs

@@ -8,6 +8,7 @@
 #region
 
 using Lilikoi.Compiler.Public;
+using Lilikoi.Context;
 
 #endregion
 
@@ -17,18 +18,19 @@ public class SimpleInjectHost
 {
 	[SimpleInjector] public Simple Injected;
 
-	public bool Execute()
+	public object Execute()
 	{
 		return Injected.Execute();
 	}
 
-	public static Func<bool, bool> Build()
+	public static Func<object, object> Build()
 	{
 		return LilikoiMethod.FromMethodInfo(typeof(SimpleInjectHost).GetMethod(nameof(Execute)))
-			.Input<bool>()
-			.Output<bool>()
+			.Mount(new Mount())
+			.Input<object>()
+			.Output<object>()
 			.Build()
 			.Finish()
-			.Compile<bool, bool>();
+			.Compile<object, object>();
 	}
 }

Lilikoi.Benchmarks/Mahogany/CompileBenchmarks.cs

@@ -23,7 +23,7 @@ namespace Lilikoi.Benchmarks.Mahogany;
 public class CompileBenchmarks
 {
 	[Benchmark()]
-	public Func<bool, bool> Simple()
+	public Func<object, object> Simple()
 	{
 		return SimpleInjectHost.Build();
 	}

Lilikoi.Benchmarks/Mahogany/RunBenchmarks.cs

@@ -8,14 +8,17 @@
 #region
 
 using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
 
 using Lilikoi.Benchmarks.Mahogany.Applications.InjectSimple;
 
 #endregion
 
 namespace Lilikoi.Benchmarks.Mahogany;
 
-[SimpleJob()]
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net60)]
+[SimpleJob(RuntimeMoniker.Net70)]
 [Q1Column]
 [MeanColumn]
 [MedianColumn]
@@ -25,7 +28,7 @@ namespace Lilikoi.Benchmarks.Mahogany;
 [MemoryDiagnoser(true)]
 public class RunBenchmarks
 {
-	public Func<bool, bool> SimpleContainer;
+	public Func<object, object> SimpleContainer;
 
 	[GlobalSetup]
 	public void Setup()
@@ -34,8 +37,8 @@ public void Setup()
 	}
 
 	[Benchmark()]
-	public bool Simple()
+	public object Simple()
 	{
-		return SimpleContainer(true);
+		return SimpleContainer("Hello?");
 	}
 }

Lilikoi/Attributes/Builders/LkTargetBuilderAttribute.cs

@@ -1,7 +1,7 @@
 //       ========================
 //       Lilikoi::LkTargetBuilderAttribute.cs
 //       (c) 2023. Distributed under the MIT License
-// 
+//
 // ->    Created: 31.01.2023
 // ->    Bumped: 06.02.2023
 //       ========================
@@ -29,5 +29,5 @@ public abstract class LkTargetBuilderAttribute : Attribute
 	/// <typeparam name="TUserContext"></typeparam>
 	/// <returns></returns>
 	public abstract bool IsTargetable<TUserContext>()
-		where TUserContext : Mount;
-}
+		where TUserContext : IMount;
+}

Lilikoi/Attributes/LkTargetAttribute.cs

@@ -1,7 +1,7 @@
 //       ========================
 //       Lilikoi::LkTargetAttribute.cs
 //       (c) 2023. Distributed under the MIT License
-// 
+//
 // ->    Created: 31.01.2023
 // ->    Bumped: 06.02.2023
 //       ========================
@@ -19,7 +19,7 @@
 {
 	public sealed override LkTargetAttribute Build(Mount mount)
 	{
 		return MemberwiseClone() as LkTargetAttribute;
 	}
 
 	/// <summary>
@@ -30,7 +30,7 @@
 	/// <typeparam name="TUserContext"></typeparam>
 	/// <returns></returns>
 	public virtual bool IsTargetedBy<TUserContext>(TUserContext context, LilikoiMutator mutator)
-		where TUserContext : Mount
+		where TUserContext : IMount
 	{
 		return true;
 	}
@@ -43,5 +43,5 @@
 	/// <param name="mutator"></param>
 	/// <typeparam name="TUserContext"></typeparam>
 	public abstract void Target<TUserContext>(TUserContext context, LilikoiMutator mutator)
-		where TUserContext : Mount;
-}
+		where TUserContext : IMount;
+}

Lilikoi/Collection/TypeDictionary.cs

@@ -1,7 +1,7 @@
 //       ========================
 //       Lilikoi::TypeDictionary.cs
 //       (c) 2023. Distributed under the MIT License
-// 
+//
 // ->    Created: 22.12.2022
 // ->    Bumped: 06.02.2023
 //       ========================
@@ -39,18 +39,32 @@
 	}
 
 	public bool Has<TValue>()
-	{
-		return _underlying.ContainsKey(typeof(TValue));
-	}
+		=> Has(typeof(TValue));
+
+	public bool Has(Type t)
+		=> _underlying.ContainsKey(t);
 
 	public void Set<TValue>(TValue obj)
 	{
 		if (mutable.IsLocked())
 			throw new Exception("Locked.");
 
 		_underlying[typeof(TValue)] = obj;
 	}
 
+	public TBase? Super<TBase>(Type super)
+		where TBase: class
+	{
+		if (!typeof(TBase).IsAssignableFrom(super))
+			return null;
+
+		if (!_underlying.ContainsKey(super))
+			return null;
+
+		return _underlying[super] as TBase;
+	}
+
+
 	public void Lock(out Padlock.Key key)
 	{
 		mutable.Lock(out key);
@@ -60,4 +74,4 @@
 	{
 		mutable.Unlock(key);
 	}
-}
+}

Lilikoi/Compiler/Mahogany/MahoganyValidator.cs

@@ -1,7 +1,7 @@
 //       ========================
 //       Lilikoi::MahoganyValidator.cs
 //       (c) 2023. Distributed under the MIT License
-// 
+//
 // ->    Created: 23.12.2022
 // ->    Bumped: 06.02.2023
 //       ========================
@@ -62,7 +62,10 @@ internal static bool ValidWrap(LkWrapBuilderAttribute attribute, Type input, Typ
 
 	internal static void ValidateWrap(LkWrapBuilderAttribute attribute, MahoganyMethod method)
 	{
-		if (!ValidWrap(attribute, method.Input, method.Result, method.Mount))
-			throw new InvalidCastException($"Wrap '{attribute.GetType().FullName}'" + $"rejected input-output pair on method '{method.Entry.Name}'");
+		if (!ValidWrap(attribute, method.Input, method.Return, method.Mount))
+			throw new InvalidCastException($"Wrap '{attribute.GetType().FullName}' " +
+			                               $"rejected input-output pair on method '{method.Entry.Name}' " +
+			                               $"with input of {method.Input.FullName} " +
+			                               $"and inner container output of {method.Return.FullName} ");
 	}
-}
+}

Lilikoi/Compiler/Public/LilikoiCompiler.cs

@@ -45,12 +45,12 @@ public LilikoiContainer Finish()
 		Internal.HostFor();
 		Internal.ParameterSafety();
 
-		Internal.InjectionsFor(Internal.Method.Host);
-
 		foreach (var implicitWrap in ImplicitWraps)
 			Internal.ImplicitWrap(implicitWrap);
 		Internal.WrapsFor();
 
+		Internal.InjectionsFor(Internal.Method.Host);
+
 		foreach (var (implicitWildcard, type) in ImplicitWildcards)
 			Internal.ImplicitWildcard(implicitWildcard, type);
 

Lilikoi/Compiler/Public/LilikoiMutator.cs

@@ -7,6 +7,8 @@
 //       ========================
 #region
 
+using System.Reflection;
+
 using Lilikoi.Attributes.Builders;
 using Lilikoi.Context;
 
@@ -41,7 +43,7 @@
 	/// <param name="value"></param>
 	/// <typeparam name="TWrap"></typeparam>
 	/// <returns></returns>
 	public LilikoiMutator Implicit<TWrap>(TWrap value = null)
 		where TWrap : LkWrapBuilderAttribute, new()
 	{
 		value ??= new TWrap();
@@ -81,7 +83,7 @@
 	/// <typeparam name="TParameter"></typeparam>
 	/// <typeparam name="TType"></typeparam>
 	/// <returns></returns>
 	public LilikoiMutator Wildcard<TType, TParameter>(TParameter value = null)
 		where TParameter : LkParameterBuilderAttribute, new()
 	{
 		value ??= new TParameter();
@@ -98,7 +100,7 @@
 	/// <typeparam name="TParameter"></typeparam>
 	/// <typeparam name="TType"></typeparam>
 	/// <returns></returns>
 	public LilikoiMutator Wildcard<TParameter>(Type type, TParameter value = null)
 		where TParameter : LkParameterBuilderAttribute, new()
 	{
 		value ??= new TParameter();
@@ -132,4 +134,15 @@
 	/// The return type of the underlying function
 	/// </summary>
 	public Type Result => Compiler.Internal.Method.Return;
+
+	/// <summary>
+	/// The entry point that the mutator is applying to
+	/// </summary>
+	public MethodInfo Method => Compiler.Internal.Method.Entry;
+
+	/// <summary>
+	/// The host that the entry point belongs to.
+	/// Note that this is the same as Method.DeclaringType
+	/// </summary>
+	public Type Host => Compiler.Internal.Method.Host;
 }

Lilikoi/Context/IMount.cs

@@ -0,0 +1,54 @@
+//       ========================
+//       Lilikoi::IMount.cs
+//       (c) 2023. Distributed under the MIT License
+//
+// ->    Created: 13.08.2023
+// ->    Bumped: 13.08.2023
+//       ========================
+namespace Lilikoi.Context;
+
+public interface IMount
+{
+	/// <summary>
+	/// Store a single object in this mount.
+	/// The location where it is stored depends on the
+	/// generic parameter passed
+	/// </summary>
+	/// <param name="value"></param>
+	/// <typeparam name="T"></typeparam>
+	void Store<T>(T value)
+		where T : class;
+
+	/// <summary>
+	/// Get a single object, based on the generic parameter
+	/// provided.
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	/// <returns></returns>
+	T? Get<T>()
+		where T : class;
+
+	/// <summary>
+	/// Get a subclass of a generic specified
+	/// by the passed type.
+	/// </summary>
+	/// <param name="super"></param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns></returns>
+	T? Super<T>(Type super)
+		where T : class;
+
+	/// <summary>
+	/// Check if an object exists in the mount
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	/// <returns></returns>
+	bool Has<T>();
+
+	/// <summary>
+	/// Check if an object exists in the mount
+	/// </summary>
+	/// <param name="t"></param>
+	/// <returns></returns>
+	bool Has(Type t);
+}