Attach surrounding static variable names to function entries

Underanalyzer/Compiler/Bytecode/FunctionEntry.cs

@@ -43,6 +43,11 @@ public sealed record FunctionEntry
     /// </summary>
     public bool DeclaredInRootScope { get; }
 
+    /// <summary>
+    /// Static variable name being assigned to around the function entry, if one exists; <see langword="null"/> otherwise.
+    /// </summary>
+    public string? StaticVariableName { get; }
+
     /// <summary>
     /// Kind of function entry. Useful for generating a final code entry name.
     /// </summary>
@@ -63,14 +68,16 @@ public sealed record FunctionEntry
     /// </summary>
     public string? StructName { get; private set; }
 
-    internal FunctionEntry(FunctionEntry? parent, int bytecodeOffset, int localCount, int argumentCount, string? functionName, bool declaredInRootScope, FunctionEntryKind kind)
+    internal FunctionEntry(FunctionEntry? parent, int bytecodeOffset, int localCount, int argumentCount, string? functionName, 
+                           bool declaredInRootScope, string? staticVariableName, FunctionEntryKind kind)
     {
         Parent = parent;
         BytecodeOffset = bytecodeOffset;
         LocalCount = localCount;
         ArgumentCount = argumentCount;
         FunctionName = functionName;
         DeclaredInRootScope = declaredInRootScope;
+        StaticVariableName = staticVariableName;
         Kind = kind;
     }
 
@@ -90,7 +97,8 @@ public void ResolveFunction(IGMFunction function, string childFunctionName)
     }
 
     /// <summary>
-    /// Resolves the struct name for this function entry. <see cref="Kind"/> must be <see cref="FunctionEntryKind.StructInstantiation"/>, and <see cref="StructName"/> must be <see langword="null"/> (as initialized).
+    /// Resolves the struct name for this function entry. <see cref="Kind"/> must be <see cref="FunctionEntryKind.StructInstantiation"/>, 
+    /// and <see cref="StructName"/> must be <see langword="null"/> (as initialized).
     /// </summary>
     public void ResolveStructName(string name)
     {

Underanalyzer/Compiler/FunctionScope.cs

@@ -46,6 +46,12 @@ public sealed class FunctionScope(bool isFunction)
     /// </summary>
     internal bool ProcessingBreakContinueContext { get; set; } = false;
 
+    /// <summary>
+    /// If generating code inside of a static variable assignment, this is the name of the
+    /// static variable being assigned to.
+    /// </summary>
+    internal string? StaticVariableName { get; set; } = null;
+
     /// <summary>
     /// List of nodes to duplicate when exiting early from a finally block.
     /// One node per each try statement.

Underanalyzer/Compiler/Nodes/BlockNode.cs

@@ -143,4 +143,27 @@ public void GenerateCode(BytecodeContext context)
             statement.GenerateCode(context);
         }
     }
+
+    /// <summary>
+    /// Same as <see cref="GenerateCode(BytecodeContext)"/>, but for static initializer blocks.
+    /// </summary>
+    public void GenerateStaticCode(BytecodeContext context)
+    {
+        context.CurrentScope.GeneratingStaticBlock = true;
+        foreach (IASTNode statement in Children)
+        {
+            if (statement is AssignNode { Expression: SimpleVariableNode { VariableName: string staticName } } assign)
+            {
+                // Set new static name, used to assign to function entries
+                context.CurrentScope.StaticVariableName = staticName;
+                assign.GenerateCode(context);
+                context.CurrentScope.StaticVariableName = null;
+            }
+            else
+            {
+                statement.GenerateCode(context);
+            }
+        }
+        context.CurrentScope.GeneratingStaticBlock = false;
+    }
 }

Underanalyzer/Compiler/Nodes/FunctionDeclNode.cs

@@ -422,6 +422,7 @@ public void GenerateCode(BytecodeContext context)
             ArgumentNames.Count,
             FunctionName,
             oldScope == context.RootScope,
+            oldScope.StaticVariableName,
             IsStruct ? FunctionEntryKind.StructInstantiation : FunctionEntryKind.FunctionDeclaration
         );
         context.CurrentFunctionEntry = entry;
@@ -481,10 +482,8 @@ public void GenerateCode(BytecodeContext context)
                 context.Emit(ExtendedOpcode.SetStaticInitialized);
             }
 
-            // Compile block
-            Scope.GeneratingStaticBlock = true;
-            staticBlock.GenerateCode(context);
-            Scope.GeneratingStaticBlock = false;
+            // Compile block (as a static block, specifically)
+            staticBlock.GenerateStaticCode(context);
 
             // If allowing re-entrant static, set the static flag here
             if (allowReentrantStatic)