feat: make Unity integration optional
This commit is contained in:
27 files changed
+916
-69
No files matched your search
@@ -0,0 +1,507 @@
|
||||
#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
|
||||
@@ -0,0 +1,2 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 578fc703a63d4b8e9a414eb8c19a472a
|
||||
@@ -1,7 +1,10 @@
|
||||
#nullable enable
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using ShrinkShared.CodeGen;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using Mono.Cecil;
|
||||
using Mono.Cecil.Cil;
|
||||
using Unity.CompilationPipeline.Common.Diagnostics;
|
||||
using Unity.CompilationPipeline.Common.ILPostProcessing;
|
||||
|
||||
@@ -11,12 +14,66 @@ namespace ShrinkEventBus.CodeGen
|
||||
{
|
||||
public override ILPostProcessor GetInstance() => this;
|
||||
|
||||
// ShrinkRegistryILPostProcessor owns the complete pass, including event bindings.
|
||||
public override bool WillProcess(ICompiledAssembly compiledAssembly) => false;
|
||||
public override bool WillProcess(ICompiledAssembly compiledAssembly)
|
||||
{
|
||||
#if SHRINK_EVENTBUS_HAS_SHARED_CODEGEN
|
||||
// The shared processor owns event weaving when its package is installed.
|
||||
return false;
|
||||
#else
|
||||
return compiledAssembly.Name != "ShrinkEventBus.Runtime" &&
|
||||
compiledAssembly.References.Any(path =>
|
||||
Path.GetFileNameWithoutExtension(path) == "ShrinkEventBus.Runtime");
|
||||
#endif
|
||||
}
|
||||
|
||||
public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly) =>
|
||||
WillProcess(compiledAssembly)
|
||||
? UnityShrinkCodeGenAdapter.Process(compiledAssembly, "ShrinkEventBus.CodeGen")
|
||||
: new ILPostProcessResult(compiledAssembly.InMemoryAssembly, new List<DiagnosticMessage>());
|
||||
public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly)
|
||||
{
|
||||
var diagnostics = new List<DiagnosticMessage>();
|
||||
#if !SHRINK_EVENTBUS_HAS_SHARED_CODEGEN
|
||||
if (!WillProcess(compiledAssembly))
|
||||
return new ILPostProcessResult(compiledAssembly.InMemoryAssembly, diagnostics);
|
||||
try
|
||||
{
|
||||
using var resolver = new PostProcessorAssemblyResolver(compiledAssembly);
|
||||
using var pe = new MemoryStream(compiledAssembly.InMemoryAssembly.PeData);
|
||||
var pdbData = compiledAssembly.InMemoryAssembly.PdbData;
|
||||
var hasSymbols = pdbData != null && pdbData.Length > 0;
|
||||
using var pdb = hasSymbols ? new MemoryStream(pdbData!) : null;
|
||||
using var assembly = AssemblyDefinition.ReadAssembly(pe, new ReaderParameters
|
||||
{
|
||||
AssemblyResolver = resolver,
|
||||
ReadingMode = ReadingMode.Immediate,
|
||||
ReflectionImporterProvider = new PostProcessorReflectionImporterProvider(),
|
||||
ReadSymbols = hasSymbols,
|
||||
SymbolStream = pdb,
|
||||
SymbolReaderProvider = hasSymbols ? new PortablePdbReaderProvider() : null
|
||||
});
|
||||
resolver.AddAssemblyDefinitionBeingOperatedOn(assembly);
|
||||
if (assembly.Name.HasPublicKey)
|
||||
throw new InvalidOperationException("Signed assemblies cannot be woven by the standalone EventBus processor.");
|
||||
if (!EventBusAssemblyWeaver.Weave(assembly.MainModule))
|
||||
return new ILPostProcessResult(compiledAssembly.InMemoryAssembly, diagnostics);
|
||||
using var outputPe = new MemoryStream();
|
||||
using var outputPdb = new MemoryStream();
|
||||
assembly.Write(outputPe, new WriterParameters
|
||||
{
|
||||
WriteSymbols = hasSymbols,
|
||||
SymbolStream = hasSymbols ? outputPdb : null,
|
||||
SymbolWriterProvider = hasSymbols ? new PortablePdbWriterProvider() : null
|
||||
});
|
||||
return new ILPostProcessResult(new InMemoryAssembly(outputPe.ToArray(),
|
||||
hasSymbols ? outputPdb.ToArray() : Array.Empty<byte>()), diagnostics);
|
||||
}
|
||||
catch (Exception exception)
|
||||
{
|
||||
diagnostics.Add(new DiagnosticMessage
|
||||
{
|
||||
DiagnosticType = DiagnosticType.Error,
|
||||
MessageData = $"[ShrinkEventBus.CodeGen] {exception.Message}"
|
||||
});
|
||||
}
|
||||
#endif
|
||||
return new ILPostProcessResult(compiledAssembly.InMemoryAssembly, diagnostics);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -102,6 +102,9 @@ namespace ShrinkEventBus.CodeGen
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
foreach (var assembly in _cache.Values)
|
||||
assembly.Dispose();
|
||||
_cache.Clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,24 +1,29 @@
|
||||
{
|
||||
"name": "Unity.ShrinkEventBus.CodeGen",
|
||||
"rootNamespace": "ShrinkEventBus.CodeGen",
|
||||
"references": [
|
||||
"ShrinkEventBus.Runtime",
|
||||
"Unity.ShrinkShared.CodeGen"
|
||||
],
|
||||
"includePlatforms": [
|
||||
"Editor"
|
||||
],
|
||||
"excludePlatforms": [],
|
||||
"allowUnsafeCode": true,
|
||||
"overrideReferences": true,
|
||||
"precompiledReferences": [
|
||||
"Mono.Cecil.dll",
|
||||
"Mono.Cecil.Mdb.dll",
|
||||
"Mono.Cecil.Pdb.dll",
|
||||
"Mono.Cecil.Rocks.dll"
|
||||
],
|
||||
"autoReferenced": false,
|
||||
"defineConstraints": [],
|
||||
"versionDefines": [],
|
||||
"noEngineReferences": false
|
||||
"name": "Unity.ShrinkEventBus.CodeGen",
|
||||
"rootNamespace": "ShrinkEventBus.CodeGen",
|
||||
"references": [
|
||||
"ShrinkEventBus.Runtime"
|
||||
],
|
||||
"includePlatforms": [
|
||||
"Editor"
|
||||
],
|
||||
"excludePlatforms": [],
|
||||
"allowUnsafeCode": true,
|
||||
"overrideReferences": true,
|
||||
"precompiledReferences": [
|
||||
"Mono.Cecil.dll",
|
||||
"Mono.Cecil.Mdb.dll",
|
||||
"Mono.Cecil.Pdb.dll",
|
||||
"Mono.Cecil.Rocks.dll"
|
||||
],
|
||||
"autoReferenced": false,
|
||||
"defineConstraints": [],
|
||||
"versionDefines": [
|
||||
{
|
||||
"name": "com.cneicy.shrink-shared-codegen",
|
||||
"expression": "0.2.1",
|
||||
"define": "SHRINK_EVENTBUS_HAS_SHARED_CODEGEN"
|
||||
}
|
||||
],
|
||||
"noEngineReferences": false
|
||||
}
|
||||
Reference in new issue
Block a user