Merge pull request #355 from adrianoc/vnext

October 2025 Update

Author: adrianoc

Cecilifier.ApiDriver.MonoCecil/Cecilifier.ApiDriver.MonoCecil.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net9.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Cecilifier.Core\Cecilifier.Core.csproj" />
+    </ItemGroup>
+
+</Project>

Cecilifier.ApiDriver.MonoCecil/Extensions/MonoCecilStringExtensions.cs

@@ -0,0 +1,62 @@
+using System.Text;
+using Cecilifier.Core.AST;
+using Cecilifier.Core.Extensions;
+using Cecilifier.Core.Naming;
+using Microsoft.CodeAnalysis;
+
+namespace Cecilifier.ApiDriver.MonoCecil.Extensions;
+
+public static class MonoCecilStringExtensions
+{
+    public static string[] CloneMethodReferenceOverriding(this string methodRef, IVisitorContext context, Dictionary<string, string> overridenProperties, IMethodSymbol method, out string resolvedVariable)
+    {
+        var cloned = new StringBuilder($"new MethodReference({methodRef}.Name, {methodRef}.ReturnType) {{ ");
+        foreach (var propName in MethodReferencePropertiesToClone)
+        {
+            if (!overridenProperties.TryGetValue(propName, out var propValue))
+            {
+                propValue = $"{methodRef}.{propName}";
+            }
+
+            cloned.Append($" {propName} = {propValue},");
+        }
+
+        cloned.Append("}");
+
+        if (method.Parameters.Length == 0 && !method.IsGenericMethod)
+        {
+            resolvedVariable = cloned.ToString();
+            return Array.Empty<string>();
+        }
+
+        var exps = new List<string>();
+        resolvedVariable = context.Naming.SyntheticVariable(method.SafeIdentifier(), ElementKind.MemberReference);
+
+        exps.Add($"var {resolvedVariable} = {cloned};");
+        if (method.Parameters.Length > 0)
+        {
+            exps.Add($"foreach(var p in {methodRef}.Parameters)");
+            exps.Add("{");
+            exps.Add($"\t{resolvedVariable}.Parameters.Add(new ParameterDefinition(p.Name, p.Attributes, p.ParameterType));");
+            exps.Add("}");
+        }
+
+        if (method.IsGenericMethod)
+        {
+            exps.Add($"foreach(var gp in {methodRef}.GenericParameters)");
+            exps.Add("{");
+            exps.Add($"\t{resolvedVariable}.GenericParameters.Add(new Mono.Cecil.GenericParameter(gp.Name, {resolvedVariable}));");
+            exps.Add("}");
+        }
+
+        return exps.ToArray();
+    }
+    
+    private static readonly List<string> MethodReferencePropertiesToClone =
+    [
+        "HasThis",
+        "ExplicitThis",
+        "DeclaringType",
+        "CallingConvention"
+    ];
+}

Cecilifier.ApiDriver.MonoCecil/MonoCecilContext.cs

@@ -0,0 +1,30 @@
+using Cecilifier.ApiDriver.MonoCecil.TypeSystem;
+using Cecilifier.Core;
+using Cecilifier.Core.AST;
+using Cecilifier.Core.Misc;
+using Cecilifier.Core.TypeSystem;
+using Microsoft.CodeAnalysis;
+
+namespace Cecilifier.ApiDriver.MonoCecil;
+
+public class MonoCecilContext : CecilifierContextBase, IVisitorContext
+{
+    public MonoCecilContext(CecilifierOptions options, SemanticModel semanticModel, byte indentation = 3) : base(options, semanticModel, indentation)
+    {
+        MemberResolver = new MonoCecilMemberResolver(this);
+        TypeResolver = new MonoCecilTypeResolver(this);
+        ApiDriver = new MonoCecilGeneratorDriver();
+        
+        CecilifiedLineNumber = ApiDriver.PreambleLineCount;
+        StartLineNumber = ApiDriver.PreambleLineCount;
+        ApiDefinitionsFactory = ApiDriver.CreateDefinitionsFactory();
+    }
+
+    public static IVisitorContext CreateContext(CecilifierOptions options, SemanticModel semanticModel) => new MonoCecilContext(options, semanticModel);
+    public static string[] BclAssembliesForCompilation()
+    {
+        return ((string) AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")).Split(Path.PathSeparator);
+    }
+
+    public override void OnFinishedTypeDeclaration() { }
+}

Cecilifier.ApiDriver.MonoCecil/MonoCecilDeferredIlContext.cs

@@ -0,0 +1,30 @@
+using Cecilifier.Core.AST;
+
+namespace Cecilifier.ApiDriver.MonoCecil;
+
+public class MonoCecilDeferredIlContext : IlContext
+{
+    private readonly IVisitorContext _context;
+    private bool _emitted;
+
+    protected internal MonoCecilDeferredIlContext(IVisitorContext context, string ilVarName, string relatedMethodVar) : base(ilVarName, relatedMethodVar)
+    {
+        _context = context;
+        _emitted = false;
+    }
+
+    public override string VariableName
+    {
+        get
+        {
+            if (!_emitted)
+            {
+                _emitted = true;
+                _context.Generate($"var {base.VariableName} = {AssociatedMethodVariable}.Body.GetILProcessor();");
+                _context.WriteNewLine();
+            }
+            
+            return base.VariableName;
+        }
+    }
+}