Who's afraid of the big bad wolf? (v2.28)

.github/workflows/cecilifier-ci.yml

@@ -8,8 +8,8 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: '9.0.x'
-      - run: dotnet tool install --global dotnet-ilverify --version 9.0.0
+          dotnet-version: '10.0.x'
+      - run: dotnet tool install --global dotnet-ilverify --version 10.0.12
       - run: dotnet restore
       - run: dotnet test --filter 'TestCategory !~ Issues' --collect:"XPlat Code Coverage"
       - run: dotnet format style --verify-no-changes

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

@@ -1,7 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
+    <Import Project="../Cecilifier.Common.props" />
+    <Import Project="../Cecilifier.CommonPackages.props" />
 
     <PropertyGroup>
-        <TargetFramework>net9.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
     </PropertyGroup>

Cecilifier.ApiDriver.MonoCecil/MonoCecilContext.cs

@@ -24,7 +24,8 @@ public MonoCecilContext(CecilifierOptions options, SemanticModel semanticModel,
     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);
+        var data = AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES");
+        return data != null ? ((string) data).Split(Path.PathSeparator) : Array.Empty<string>();
     }
 
     public static string[] GetPreprocessorSymbols() => ["API_DRIVER_MONO_CECIL"];

Cecilifier.ApiDriver.MonoCecil/MonoCecilDeferredIlContext.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using Cecilifier.Core.AST;
 
 namespace Cecilifier.ApiDriver.MonoCecil;
@@ -6,25 +7,42 @@ public class MonoCecilDeferredIlContext : IlContext
 {
     private readonly IVisitorContext _context;
     private bool _emitted;
+#if DEBUG_MATERIALIZATION_CHECK
+    private string _debugInfo;        
+#endif
 
     protected internal MonoCecilDeferredIlContext(IVisitorContext context, string ilVarName, string relatedMethodVar) : base(ilVarName, relatedMethodVar)
     {
         _context = context;
         _emitted = false;
+
+#if DEBUG_MATERIALIZATION_CHECK
+        _debugInfo = new StackTrace(true).ToString();
+#endif
     }
 
     public override string VariableName
     {
         get
         {
+#if DEBUG_MATERIALIZATION_CHECK
             if (!_emitted)
-            {
-                _emitted = true;
-                _context.Generate($"var {base.VariableName} = {AssociatedMethodVariable}.Body.GetILProcessor();");
-                _context.WriteNewLine();
-            }
+                throw new InvalidOperationException($"IL context is not materialized yet\nIlContext instantiated at:\n{_debugInfo}\n----------------------------");
+#else
+            Materialize();
+#endif
 
             return base.VariableName;
         }
     }
+
+    public override void Materialize()
+    {
+        if (!_emitted)
+        {
+            _emitted = true;
+            _context.Generate($"var {base.VariableName} = {AssociatedMethodVariable}.Body.GetILProcessor();");
+            _context.WriteNewLine();
+        }
+    }
 }

Cecilifier.ApiDriver.MonoCecil/MonoCecilGeneratorDriver.cs

@@ -6,6 +6,7 @@
 using Cecilifier.Core.AST;
 using Cecilifier.Core.Extensions;
 using Cecilifier.Core.TypeSystem;
+using Cecilifier.Core.Variables;
 using Microsoft.CodeAnalysis;
 
 namespace Cecilifier.ApiDriver.MonoCecil;
@@ -54,6 +55,8 @@ public static void Main(string[] args)
 }}";
     }
 
+    public ApiDriverCapabilities DriverCapabilities => ApiDriverCapabilities.RequiresForwardReferences | ApiDriverCapabilities.RequiresExplicitParameterSyntaxHandling;
+
     public int PreambleLineCount => 25; // The # of lines before the 1st cecilified line of code (see `cecilifiedCode` parameter from AsCecilApplication())
 
     public IReadOnlyCollection<string> AssemblyReferences { get; } = 
@@ -91,21 +94,31 @@ public void WriteCilInstruction(IVisitorContext context, IlContext il, OpCode op
 
     public void WriteCilBranch(IVisitorContext context, IlContext il, OpCode branchOpCode, string targetLabel, string? comment = null)
     {
-        WriteCilInstruction(context, il, branchOpCode, targetLabel, comment);
+        context.Generate(EmitCilInstruction(context, il, branchOpCode, targetLabel, comment));
+        context.WriteNewLine();
+    }
+
+    public string EmitCilBranchInstruction(IVisitorContext context, IlContext il, OpCode branchOpCode, string targetLabel, string? comment = null)
+    {
+        return EmitCilInstruction(context, il, branchOpCode, targetLabel, comment);
     }
 
     public void DefineLabel(IVisitorContext context, IlContext il, string labelVariable)
     {
         context.Generate($"var {labelVariable} = {il.VariableName}.Create(OpCodes.Nop);");
         context.WriteNewLine();
     }
-
+
+    public string EmitDefineLabel(IVisitorContext context, IlContext il, string labelVariable) => $"var {labelVariable} = {il.VariableName}.Create(OpCodes.Nop);";
+
     public void MarkLabel(IVisitorContext context, IlContext il, string labelVariable)
     {
         context.Generate($"{il.VariableName}.Append({labelVariable});");
         context.WriteNewLine();
     }
 
+    public string EmitMarkLabel(IVisitorContext context, IlContext il, string labelVariable) => $"{il.VariableName}.Append({labelVariable});";
+
     public IlContext NewIlContext(IVisitorContext context, string memberName, string relatedMethodVar)
     {
         var ilVarName = context.Naming.ILProcessor(memberName);
@@ -128,4 +141,32 @@ public void AddMethodSemantics(IVisitorContext context, string targetVariable, s
                 $"{methodVariable}.Body = new MethodBody({methodVariable});",
                 $"{targetVariable}.{accessor} = {methodVariable};" ]);
     }
+
+    public void WriteExceptionHandlers(IVisitorContext context, IlContext ilVar, IEnumerable<ExceptionHandlerEntry> exceptionHandlerTable)
+    {
+        string methodVar = context.DefinitionVariables.GetLastOf(VariableMemberKind.Method);
+        foreach (var handlerEntry in exceptionHandlerTable)
+        {
+            context.Generate($"{methodVar}.Body.ExceptionHandlers.Add(new ExceptionHandler(ExceptionHandlerType.{handlerEntry.Kind})");
+            context.WriteNewLine();
+            context.Generate("{");
+            context.WriteNewLine();
+            if (handlerEntry.Kind == ExceptionHandlerKind.Catch)
+            {
+                context.Generate($"    CatchType = {handlerEntry.CatchType},");
+                context.WriteNewLine();
+            }
+
+            context.Generate($"    TryStart = {handlerEntry.TryStart},");
+            context.WriteNewLine();
+            context.Generate($"    TryEnd = {handlerEntry.TryEnd},");
+            context.WriteNewLine();
+            context.Generate($"    HandlerStart = {handlerEntry.HandlerStart},");
+            context.WriteNewLine();
+            context.Generate($"    HandlerEnd = {handlerEntry.HandlerEnd}");
+            context.WriteNewLine();
+            context.Generate("});");
+            context.WriteNewLine();
+        }
+    }
 }