508 lines
27 KiB
C#
508 lines
27 KiB
C#
#nullable enable
|
|
#if !SHRINK_EVENTBUS_HAS_SHARED_CODEGEN
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Mono.Cecil;
|
|
using Mono.Cecil.Cil;
|
|
|
|
namespace ShrinkEventBus.CodeGen
|
|
{
|
|
internal static class EventBusAssemblyWeaver
|
|
{
|
|
private const string EventRuntime = "ShrinkEventBus.Runtime";
|
|
private const string Marker = "ShrinkEventBus.Generated.StandaloneWeaveMarker";
|
|
|
|
public static bool Weave(ModuleDefinition module)
|
|
{
|
|
if (!References(module, EventRuntime) || module.GetType(Marker) != null)
|
|
return false;
|
|
var instances = 0;
|
|
var statics = 0;
|
|
WeaveEventBus(module, ref instances, ref statics);
|
|
if (instances == 0 && statics == 0)
|
|
return false;
|
|
module.Types.Add(new TypeDefinition("ShrinkEventBus.Generated", "StandaloneWeaveMarker",
|
|
TypeAttributes.NotPublic | TypeAttributes.Abstract | TypeAttributes.Sealed, module.TypeSystem.Object));
|
|
return true;
|
|
}
|
|
|
|
private static void WeaveEventBus(ModuleDefinition module,
|
|
ref int instanceCount, ref int staticCount)
|
|
{
|
|
var subscriberAttribute = RequireType(module, "ShrinkEventBus.ShrinkEventSubscriberAttribute", EventRuntime);
|
|
var subscribeAttribute = RequireType(module, "ShrinkEventBus.ShrinkSubscribeAttribute", EventRuntime);
|
|
var allTypes = AllTypes(module.Types).Where(type => !type.IsInterface).ToArray();
|
|
foreach (var type in allTypes.Where(type => HasAttribute(type, subscriberAttribute)))
|
|
{
|
|
var instanceHandlers = type.Methods.Where(method => !method.IsStatic && HasAttribute(method, subscribeAttribute)).ToArray();
|
|
if (instanceHandlers.Length > 0)
|
|
{
|
|
var lifetime = ReadInt(type.CustomAttributes.First(a => a.AttributeType.FullName == subscriberAttribute.FullName), "Lifetime", 0);
|
|
if (InjectInstanceBinding(module, type, instanceHandlers, subscribeAttribute))
|
|
instanceCount++;
|
|
if (lifetime == 1)
|
|
InjectAwakeToDestroyLifetime(type, module);
|
|
else if (lifetime != 0)
|
|
throw new InvalidOperationException($"{type.FullName}: unsupported subscriber lifetime.");
|
|
}
|
|
}
|
|
|
|
var staticTypes = allTypes.Where(type => HasAttribute(type, subscriberAttribute))
|
|
.Where(type => type.Methods.Any(method => method.IsStatic && HasAttribute(method, subscribeAttribute)))
|
|
.ToArray();
|
|
if (staticTypes.Length > 0)
|
|
{
|
|
staticCount = staticTypes.Sum(type => type.Methods.Count(method => method.IsStatic && HasAttribute(method, subscribeAttribute)));
|
|
InjectStaticBootstrap(module, staticTypes, subscriberAttribute, subscribeAttribute);
|
|
}
|
|
}
|
|
|
|
private static void InjectAwakeToDestroyLifetime(TypeDefinition type, ModuleDefinition module)
|
|
{
|
|
if (!InheritsFrom(type, "UnityEngine.MonoBehaviour"))
|
|
throw new InvalidOperationException($"[ShrinkEventSubscriber(Lifetime = AwakeToDestroy)] requires MonoBehaviour: {type.FullName}.");
|
|
|
|
const string bindingFieldName = "__shrinkEventBusAwakeToDestroyBinding";
|
|
if (type.Fields.Any(field => field.Name == bindingFieldName))
|
|
throw new InvalidOperationException($"Reserved generated field already exists on {type.FullName}: {bindingFieldName}.");
|
|
|
|
var disposableType = new TypeReference("System", "IDisposable", module, module.TypeSystem.CoreLibrary);
|
|
var bindingField = new FieldDefinition(bindingFieldName, FieldAttributes.Private, disposableType);
|
|
type.Fields.Add(bindingField);
|
|
var eventBusType = RequireType(module, "ShrinkEventBus.EventBus", EventRuntime);
|
|
var attachMethod = ImportMethod(module, eventBusType,
|
|
method => method.Name == "Attach" && method.IsStatic && method.Parameters.Count == 2);
|
|
var disposeMethod = new MethodReference("Dispose", module.TypeSystem.Void, disposableType) { HasThis = true };
|
|
InjectAwake(type, module, bindingField, attachMethod);
|
|
InjectOnDestroy(type, module, bindingField, disposeMethod);
|
|
}
|
|
|
|
private static void InjectAwake(TypeDefinition type, ModuleDefinition module,
|
|
FieldDefinition bindingField, MethodReference attachMethod)
|
|
{
|
|
var awake = type.Methods.FirstOrDefault(method =>
|
|
method.Name == "Awake" && !method.IsStatic && method.Parameters.Count == 0);
|
|
if (awake != null)
|
|
{
|
|
InsertAttachAtStart(awake, module, bindingField, attachMethod);
|
|
return;
|
|
}
|
|
|
|
var baseAwake = FindBaseMethodReference(type, "Awake", module);
|
|
awake = new MethodDefinition("Awake",
|
|
baseAwake != null
|
|
? MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Virtual
|
|
: MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.NewSlot,
|
|
module.TypeSystem.Void);
|
|
awake.Body.InitLocals = true;
|
|
var il = awake.Body.GetILProcessor();
|
|
if (baseAwake != null)
|
|
{
|
|
il.Emit(OpCodes.Ldarg_0);
|
|
il.Emit(OpCodes.Call, baseAwake);
|
|
}
|
|
EmitAttach(il, awake, module, bindingField, attachMethod);
|
|
il.Emit(OpCodes.Ret);
|
|
type.Methods.Add(awake);
|
|
}
|
|
|
|
private static void InjectOnDestroy(TypeDefinition type, ModuleDefinition module,
|
|
FieldDefinition bindingField, MethodReference disposeMethod)
|
|
{
|
|
var onDestroy = type.Methods.FirstOrDefault(method =>
|
|
method.Name == "OnDestroy" && !method.IsStatic && method.Parameters.Count == 0);
|
|
if (onDestroy != null)
|
|
{
|
|
InsertDisposeAtStart(onDestroy, bindingField, disposeMethod);
|
|
return;
|
|
}
|
|
|
|
var baseOnDestroy = FindBaseMethodReference(type, "OnDestroy", module);
|
|
onDestroy = new MethodDefinition("OnDestroy",
|
|
baseOnDestroy != null
|
|
? MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Virtual
|
|
: MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.NewSlot,
|
|
module.TypeSystem.Void);
|
|
var il = onDestroy.Body.GetILProcessor();
|
|
EmitDispose(il, bindingField, disposeMethod);
|
|
if (baseOnDestroy != null)
|
|
{
|
|
il.Emit(OpCodes.Ldarg_0);
|
|
il.Emit(OpCodes.Call, baseOnDestroy);
|
|
}
|
|
il.Emit(OpCodes.Ret);
|
|
type.Methods.Add(onDestroy);
|
|
}
|
|
|
|
private static void InsertAttachAtStart(MethodDefinition method, ModuleDefinition module,
|
|
FieldDefinition bindingField, MethodReference attachMethod)
|
|
{
|
|
if (!method.HasBody || method.Body.Instructions.Count == 0)
|
|
throw new InvalidOperationException($"Awake has no body: {method.FullName}.");
|
|
method.Body.InitLocals = true;
|
|
var processor = method.Body.GetILProcessor();
|
|
var instructions = BuildAttachInstructions(processor, method, module, bindingField, attachMethod);
|
|
var first = method.Body.Instructions[0];
|
|
foreach (var instruction in instructions)
|
|
processor.InsertBefore(first, instruction);
|
|
}
|
|
|
|
private static void EmitAttach(ILProcessor il, MethodDefinition method, ModuleDefinition module,
|
|
FieldDefinition bindingField, MethodReference attachMethod)
|
|
{
|
|
foreach (var instruction in BuildAttachInstructions(il, method, module, bindingField, attachMethod))
|
|
il.Append(instruction);
|
|
}
|
|
|
|
private static IReadOnlyList<Instruction> BuildAttachInstructions(ILProcessor il,
|
|
MethodDefinition method, ModuleDefinition module, FieldDefinition bindingField,
|
|
MethodReference attachMethod)
|
|
{
|
|
var defaultBusType = module.ImportReference(attachMethod.Parameters[1].ParameterType);
|
|
var defaultBus = new VariableDefinition(defaultBusType);
|
|
method.Body.Variables.Add(defaultBus);
|
|
var attached = il.Create(OpCodes.Nop);
|
|
return new[]
|
|
{
|
|
il.Create(OpCodes.Ldarg_0),
|
|
il.Create(OpCodes.Ldfld, bindingField),
|
|
il.Create(OpCodes.Brtrue_S, attached),
|
|
il.Create(OpCodes.Ldarg_0),
|
|
il.Create(OpCodes.Ldarg_0),
|
|
il.Create(OpCodes.Ldloca_S, defaultBus),
|
|
il.Create(OpCodes.Initobj, defaultBusType),
|
|
il.Create(OpCodes.Ldloc, defaultBus),
|
|
il.Create(OpCodes.Call, attachMethod),
|
|
il.Create(OpCodes.Stfld, bindingField),
|
|
attached
|
|
};
|
|
}
|
|
|
|
private static void InsertDisposeAtStart(MethodDefinition method,
|
|
FieldDefinition bindingField, MethodReference disposeMethod)
|
|
{
|
|
if (!method.HasBody || method.Body.Instructions.Count == 0)
|
|
throw new InvalidOperationException($"OnDestroy has no body: {method.FullName}.");
|
|
var processor = method.Body.GetILProcessor();
|
|
var instructions = BuildDisposeInstructions(processor, bindingField, disposeMethod);
|
|
var first = method.Body.Instructions[0];
|
|
foreach (var instruction in instructions)
|
|
processor.InsertBefore(first, instruction);
|
|
}
|
|
|
|
private static void EmitDispose(ILProcessor il, FieldDefinition bindingField,
|
|
MethodReference disposeMethod)
|
|
{
|
|
foreach (var instruction in BuildDisposeInstructions(il, bindingField, disposeMethod))
|
|
il.Append(instruction);
|
|
}
|
|
|
|
private static IReadOnlyList<Instruction> BuildDisposeInstructions(ILProcessor il,
|
|
FieldDefinition bindingField, MethodReference disposeMethod)
|
|
{
|
|
var disposed = il.Create(OpCodes.Nop);
|
|
return new[]
|
|
{
|
|
il.Create(OpCodes.Ldarg_0),
|
|
il.Create(OpCodes.Ldfld, bindingField),
|
|
il.Create(OpCodes.Brfalse_S, disposed),
|
|
il.Create(OpCodes.Ldarg_0),
|
|
il.Create(OpCodes.Ldfld, bindingField),
|
|
il.Create(OpCodes.Callvirt, disposeMethod),
|
|
il.Create(OpCodes.Ldarg_0),
|
|
il.Create(OpCodes.Ldnull),
|
|
il.Create(OpCodes.Stfld, bindingField),
|
|
disposed
|
|
};
|
|
}
|
|
|
|
private static MethodReference? FindBaseMethodReference(TypeDefinition type,
|
|
string methodName, ModuleDefinition module)
|
|
{
|
|
try
|
|
{
|
|
var baseTypeReference = type.BaseType;
|
|
while (baseTypeReference != null)
|
|
{
|
|
var baseType = baseTypeReference.Resolve();
|
|
if (baseType == null) break;
|
|
var method = baseType.Methods.FirstOrDefault(candidate =>
|
|
candidate.Name == methodName && !candidate.IsStatic && candidate.IsVirtual &&
|
|
candidate.Parameters.Count == 0);
|
|
if (method != null)
|
|
{
|
|
if (baseTypeReference is GenericInstanceType genericBase)
|
|
{
|
|
return new MethodReference(method.Name, module.ImportReference(method.ReturnType),
|
|
module.ImportReference(genericBase))
|
|
{
|
|
HasThis = method.HasThis,
|
|
ExplicitThis = method.ExplicitThis,
|
|
CallingConvention = method.CallingConvention
|
|
};
|
|
}
|
|
return module.ImportReference(method);
|
|
}
|
|
baseTypeReference = baseType.BaseType;
|
|
}
|
|
}
|
|
catch { }
|
|
return null;
|
|
}
|
|
|
|
private static bool InheritsFrom(TypeDefinition type, string expectedFullName)
|
|
{
|
|
var current = type.BaseType;
|
|
while (current != null)
|
|
{
|
|
if (current.FullName == expectedFullName) return true;
|
|
try { current = current.Resolve()?.BaseType; }
|
|
catch { return false; }
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private static bool InjectInstanceBinding(ModuleDefinition module, TypeDefinition owner,
|
|
IReadOnlyList<MethodDefinition> handlers, TypeReference subscribeAttribute)
|
|
{
|
|
var generatedInterface = RequireType(module, "ShrinkEventBus.IShrinkGeneratedSubscriber", EventRuntime);
|
|
if (owner.Interfaces.Any(item => item.InterfaceType.FullName == generatedInterface.FullName))
|
|
return false;
|
|
var resolverType = RequireType(module, "ShrinkEventBus.IShrinkBusResolver", EventRuntime);
|
|
var busKeyType = RequireType(module, "ShrinkEventBus.ShrinkBusKey", EventRuntime);
|
|
var bindingType = RequireType(module, "ShrinkEventBus.ShrinkEventBinding", EventRuntime);
|
|
var helperType = RequireType(module, "ShrinkEventBus.ShrinkGeneratedBinding", EventRuntime);
|
|
var disposableType = RequireType(module, "System.IDisposable", module.TypeSystem.CoreLibrary.Name);
|
|
var nullableBusKey = GenericType(module, "System.Nullable`1", true, busKeyType);
|
|
var bindingCtor = ImportMethod(module, bindingType, method => method.IsConstructor && method.Parameters.Count == 0);
|
|
var bindingAdd = ImportMethod(module, bindingType, method => method.Name == "Add" && method.Parameters.Count == 1);
|
|
var interfaceMethod = ImportMethod(module, generatedInterface, method => method.Name == "AttachGenerated");
|
|
var syncSubscribe = ImportMethod(module, helperType, method => method.Name == "Subscribe" && method.HasGenericParameters);
|
|
var asyncSubscribe = ImportMethod(module, helperType, method => method.Name == "SubscribeAsync" && method.HasGenericParameters);
|
|
var legacySubscribe = ImportMethod(module, helperType, method => method.Name == "SubscribeAsyncLegacy" && method.HasGenericParameters);
|
|
var asyncHandlerType = RequireType(module, "ShrinkEventBus.ShrinkAsyncEventHandler`1", EventRuntime);
|
|
|
|
var generated = new MethodDefinition("ShrinkEventBus.IShrinkGeneratedSubscriber.AttachGenerated",
|
|
MethodAttributes.Private | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual,
|
|
disposableType);
|
|
generated.Parameters.Add(new ParameterDefinition("resolver", ParameterAttributes.None, resolverType));
|
|
generated.Parameters.Add(new ParameterDefinition("defaultBus", ParameterAttributes.Optional, nullableBusKey));
|
|
generated.Overrides.Add(interfaceMethod);
|
|
generated.Body.InitLocals = true;
|
|
var bindingLocal = new VariableDefinition(bindingType);
|
|
generated.Body.Variables.Add(bindingLocal);
|
|
var il = generated.Body.GetILProcessor();
|
|
il.Emit(OpCodes.Newobj, bindingCtor);
|
|
il.Emit(OpCodes.Stloc, bindingLocal);
|
|
var classDefaultBus = ReadString(owner.CustomAttributes.First(a => a.AttributeType.FullName == "ShrinkEventBus.ShrinkEventSubscriberAttribute"), "DefaultBus");
|
|
foreach (var handler in handlers)
|
|
EmitInstanceSubscription(module, il, handler, handler.CustomAttributes.First(a => a.AttributeType.FullName == subscribeAttribute.FullName), classDefaultBus,
|
|
bindingLocal, bindingAdd, syncSubscribe, asyncSubscribe, legacySubscribe, asyncHandlerType);
|
|
il.Emit(OpCodes.Ldloc, bindingLocal);
|
|
il.Emit(OpCodes.Ret);
|
|
owner.Interfaces.Add(new InterfaceImplementation(generatedInterface));
|
|
owner.Methods.Add(generated);
|
|
return true;
|
|
}
|
|
|
|
private static void EmitInstanceSubscription(ModuleDefinition module, ILProcessor il, MethodDefinition handler,
|
|
CustomAttribute attribute, string classDefaultBus, VariableDefinition bindingLocal, MethodReference bindingAdd,
|
|
MethodReference syncSubscribe, MethodReference asyncSubscribe, MethodReference legacySubscribe, TypeReference asyncHandlerType)
|
|
{
|
|
var signature = ResolveEventHandler(module, handler, syncSubscribe, asyncSubscribe, legacySubscribe, asyncHandlerType);
|
|
var bus = ReadString(attribute, "Bus");
|
|
if (string.IsNullOrWhiteSpace(bus)) bus = classDefaultBus;
|
|
il.Emit(OpCodes.Ldloc, bindingLocal);
|
|
il.Emit(OpCodes.Ldarg_1);
|
|
il.Emit(OpCodes.Ldarg_2);
|
|
il.Emit(OpCodes.Ldstr, bus ?? string.Empty);
|
|
il.Emit(OpCodes.Ldarg_0);
|
|
il.Emit(OpCodes.Ldarg_0);
|
|
il.Emit(OpCodes.Ldftn, module.ImportReference(handler));
|
|
il.Emit(OpCodes.Newobj, DelegateConstructor(module, signature.DelegateType));
|
|
EmitOptions(il, attribute);
|
|
il.Emit(OpCodes.Call, signature.Method);
|
|
il.Emit(OpCodes.Callvirt, bindingAdd);
|
|
}
|
|
|
|
private static void InjectStaticBootstrap(ModuleDefinition module, IReadOnlyList<TypeDefinition> types,
|
|
TypeReference subscriberAttribute, TypeReference subscribeAttribute)
|
|
{
|
|
if (module.Types.Any(type => type.FullName == "ShrinkEventBus.Generated.ShrinkGeneratedStaticBindings"))
|
|
return;
|
|
var registry = RequireType(module, "ShrinkEventBus.ShrinkStaticBindingRegistry", EventRuntime);
|
|
var syncRegister = ImportMethod(module, registry, method => method.Name == "Register" && method.HasGenericParameters);
|
|
var asyncRegister = ImportMethod(module, registry, method => method.Name == "RegisterAsync" && method.HasGenericParameters);
|
|
var legacyRegister = ImportMethod(module, registry, method => method.Name == "RegisterAsyncLegacy" && method.HasGenericParameters);
|
|
var asyncHandlerType = RequireType(module, "ShrinkEventBus.ShrinkAsyncEventHandler`1", EventRuntime);
|
|
var bootstrap = new TypeDefinition("ShrinkEventBus.Generated", "ShrinkGeneratedStaticBindings",
|
|
TypeAttributes.Abstract | TypeAttributes.Sealed | TypeAttributes.NotPublic, module.TypeSystem.Object);
|
|
module.Types.Add(bootstrap);
|
|
var register = new MethodDefinition("Register", MethodAttributes.Assembly | MethodAttributes.Static | MethodAttributes.HideBySig, module.TypeSystem.Void);
|
|
bootstrap.Methods.Add(register);
|
|
var il = register.Body.GetILProcessor();
|
|
foreach (var type in types)
|
|
{
|
|
var classBus = ReadString(type.CustomAttributes.First(a => a.AttributeType.FullName == subscriberAttribute.FullName), "DefaultBus");
|
|
foreach (var handler in type.Methods.Where(method => method.IsStatic && HasAttribute(method, subscribeAttribute)).ToArray())
|
|
{
|
|
var attribute = handler.CustomAttributes.First(a => a.AttributeType.FullName == subscribeAttribute.FullName);
|
|
var signature = ResolveEventHandler(module, handler, syncRegister, asyncRegister, legacyRegister, asyncHandlerType);
|
|
var bus = ReadString(attribute, "Bus");
|
|
if (string.IsNullOrWhiteSpace(bus)) bus = classBus;
|
|
var bridge = CreateStaticBridge(module, handler);
|
|
il.Emit(OpCodes.Ldstr, bus ?? string.Empty);
|
|
il.Emit(OpCodes.Ldnull);
|
|
il.Emit(OpCodes.Ldftn, bridge);
|
|
il.Emit(OpCodes.Newobj, DelegateConstructor(module, signature.DelegateType));
|
|
EmitOptions(il, attribute);
|
|
il.Emit(OpCodes.Call, signature.Method);
|
|
}
|
|
}
|
|
il.Emit(OpCodes.Ret);
|
|
var moduleType = module.Types.First(type => type.Name == "<Module>");
|
|
var initializer = moduleType.Methods.FirstOrDefault(method => method.Name == ".cctor");
|
|
if (initializer == null)
|
|
{
|
|
initializer = new MethodDefinition(".cctor", MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.HideBySig |
|
|
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, module.TypeSystem.Void);
|
|
initializer.Body.GetILProcessor().Emit(OpCodes.Ret);
|
|
moduleType.Methods.Add(initializer);
|
|
}
|
|
initializer.Body.GetILProcessor().InsertBefore(initializer.Body.Instructions[0], Instruction.Create(OpCodes.Call, register));
|
|
}
|
|
|
|
private static (MethodReference Method, TypeReference DelegateType) ResolveEventHandler(ModuleDefinition module,
|
|
MethodDefinition handler, MethodReference sync, MethodReference async, MethodReference legacy, TypeReference asyncHandlerType)
|
|
{
|
|
if (handler.Parameters.Count is < 1 or > 2)
|
|
throw new InvalidOperationException($"{handler.FullName}: [ShrinkSubscribe] requires one event parameter and an optional CancellationToken.");
|
|
var eventType = module.ImportReference(handler.Parameters[0].ParameterType);
|
|
var eventInterface = RequireType(module, "ShrinkEventBus.IShrinkEvent", EventRuntime);
|
|
if (!Implements(eventType, eventInterface.FullName))
|
|
throw new InvalidOperationException($"{handler.FullName}: event parameter must implement IShrinkEvent.");
|
|
|
|
MethodReference open;
|
|
TypeReference delegateType;
|
|
if (handler.ReturnType.MetadataType == MetadataType.Void && handler.Parameters.Count == 1)
|
|
{
|
|
open = sync;
|
|
delegateType = GenericType(module, "System.Action`1", false, eventType);
|
|
}
|
|
else if (handler.ReturnType.FullName == "Cysharp.Threading.Tasks.UniTask" && handler.Parameters.Count == 1)
|
|
{
|
|
open = legacy;
|
|
delegateType = GenericType(module, "System.Func`2", false, eventType, module.ImportReference(handler.ReturnType));
|
|
}
|
|
else if (handler.ReturnType.FullName == "Cysharp.Threading.Tasks.UniTask" && handler.Parameters.Count == 2 &&
|
|
handler.Parameters[1].ParameterType.FullName == "System.Threading.CancellationToken")
|
|
{
|
|
open = async;
|
|
delegateType = new GenericInstanceType(asyncHandlerType) { GenericArguments = { eventType } };
|
|
}
|
|
else
|
|
throw new InvalidOperationException($"Unsupported [ShrinkSubscribe] signature: {handler.FullName}.");
|
|
var closed = new GenericInstanceMethod(open);
|
|
closed.GenericArguments.Add(eventType);
|
|
return (closed, delegateType);
|
|
}
|
|
|
|
private static MethodReference CreateStaticBridge(ModuleDefinition module, MethodDefinition handler)
|
|
{
|
|
var bridge = new MethodDefinition($"ShrinkEventBus.GeneratedStaticHandler_{handler.MetadataToken.ToInt32():X8}",
|
|
MethodAttributes.Assembly | MethodAttributes.Static | MethodAttributes.HideBySig, module.ImportReference(handler.ReturnType));
|
|
foreach (var parameter in handler.Parameters)
|
|
bridge.Parameters.Add(new ParameterDefinition(parameter.Name, parameter.Attributes, module.ImportReference(parameter.ParameterType)));
|
|
var il = bridge.Body.GetILProcessor();
|
|
foreach (var parameter in bridge.Parameters) il.Emit(OpCodes.Ldarg, parameter);
|
|
il.Emit(OpCodes.Call, module.ImportReference(handler));
|
|
il.Emit(OpCodes.Ret);
|
|
handler.DeclaringType.Methods.Add(bridge);
|
|
return bridge;
|
|
}
|
|
|
|
private static void EmitOptions(ILProcessor il, CustomAttribute attribute)
|
|
{
|
|
il.Emit(OpCodes.Ldc_I4, ReadInt(attribute, "Priority", 2));
|
|
il.Emit(OpCodes.Ldc_I4, ReadInt(attribute, "NumericPriority", 0));
|
|
il.Emit(ReadBool(attribute, "ReceiveCanceled", false) ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
|
|
}
|
|
|
|
private static bool References(ModuleDefinition module, string assemblyName) =>
|
|
module.AssemblyReferences.Any(reference => string.Equals(reference.Name, assemblyName, StringComparison.Ordinal));
|
|
|
|
private static TypeReference RequireType(ModuleDefinition module, string fullName, string assemblyName) =>
|
|
FindType(module, fullName, assemblyName) ?? throw new InvalidOperationException($"Required type {fullName} was not found in {assemblyName}.");
|
|
|
|
private static TypeReference? FindType(ModuleDefinition module, string fullName, string assemblyName)
|
|
{
|
|
if (string.Equals(module.Assembly.Name.Name, assemblyName, StringComparison.Ordinal))
|
|
return module.GetType(fullName);
|
|
var reference = module.AssemblyReferences.FirstOrDefault(item => string.Equals(item.Name, assemblyName, StringComparison.Ordinal));
|
|
if (reference == null) return null;
|
|
var assembly = module.AssemblyResolver.Resolve(reference);
|
|
return assembly?.MainModule.GetType(fullName) is { } definition ? module.ImportReference(definition) : null;
|
|
}
|
|
|
|
private static MethodReference ImportMethod(ModuleDefinition module, TypeReference type, Func<MethodDefinition, bool> predicate)
|
|
{
|
|
var definition = type.Resolve() ?? throw new InvalidOperationException($"Unable to resolve {type.FullName}.");
|
|
var method = definition.Methods.SingleOrDefault(predicate) ?? throw new InvalidOperationException($"Required method was not found on {type.FullName}.");
|
|
return module.ImportReference(method);
|
|
}
|
|
|
|
private static IEnumerable<TypeDefinition> AllTypes(IEnumerable<TypeDefinition> roots)
|
|
{
|
|
foreach (var type in roots)
|
|
{
|
|
yield return type;
|
|
foreach (var nested in AllTypes(type.NestedTypes)) yield return nested;
|
|
}
|
|
}
|
|
|
|
private static bool HasAttribute(ICustomAttributeProvider provider, TypeReference attribute) => HasAttribute(provider, attribute.FullName);
|
|
private static bool HasAttribute(ICustomAttributeProvider provider, string fullName) => provider.CustomAttributes.Any(a => a.AttributeType.FullName == fullName);
|
|
|
|
private static bool Implements(TypeReference type, string interfaceFullName)
|
|
{
|
|
try
|
|
{
|
|
TypeDefinition? current = type.Resolve();
|
|
while (current != null)
|
|
{
|
|
if (current.Interfaces.Any(item => item.InterfaceType.FullName == interfaceFullName)) return true;
|
|
current = current.BaseType?.Resolve();
|
|
}
|
|
}
|
|
catch { }
|
|
return false;
|
|
}
|
|
|
|
private static TypeReference GenericType(ModuleDefinition module, string name, bool valueType, params TypeReference[] arguments)
|
|
{
|
|
var open = new TypeReference("System", name.Substring(name.LastIndexOf('.') + 1), module, module.TypeSystem.CoreLibrary, valueType);
|
|
var result = new GenericInstanceType(open);
|
|
foreach (var argument in arguments) result.GenericArguments.Add(argument);
|
|
return result;
|
|
}
|
|
|
|
private static MethodReference DelegateConstructor(ModuleDefinition module, TypeReference delegateType)
|
|
{
|
|
var ctor = new MethodReference(".ctor", module.TypeSystem.Void, delegateType) { HasThis = true };
|
|
ctor.Parameters.Add(new ParameterDefinition(module.TypeSystem.Object));
|
|
ctor.Parameters.Add(new ParameterDefinition(module.TypeSystem.IntPtr));
|
|
return ctor;
|
|
}
|
|
|
|
private static string ReadString(CustomAttribute attribute, string name) =>
|
|
attribute.Properties.FirstOrDefault(item => item.Name == name).Argument.Value as string ?? string.Empty;
|
|
private static int ReadInt(CustomAttribute attribute, string name, int fallback) =>
|
|
attribute.Properties.FirstOrDefault(item => item.Name == name) is { Name: not null } item ? Convert.ToInt32(item.Argument.Value) : fallback;
|
|
private static bool ReadBool(CustomAttribute attribute, string name, bool fallback) =>
|
|
attribute.Properties.FirstOrDefault(item => item.Name == name) is { Name: not null } item ? Convert.ToBoolean(item.Argument.Value) : fallback;
|
|
}
|
|
}
|
|
|
|
#endif
|