703 lines
32 KiB
C#
703 lines
32 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using UnityPipeline.Microsoft.CodeAnalysis;
|
|
using UnityPipeline.Microsoft.CodeAnalysis.CSharp;
|
|
using UnityPipeline.Microsoft.CodeAnalysis.CSharp.Syntax;
|
|
using Unity.Pipeline.Compilation;
|
|
using UnityEngine;
|
|
|
|
namespace Unity.Pipeline.CodeReload
|
|
{
|
|
/// <summary>
|
|
/// Main orchestrator for in-place code reload processing.
|
|
/// Handles the complete pipeline: source parsing -> transformation -> compilation.
|
|
/// </summary>
|
|
static class InPlaceReloadProcessor
|
|
{
|
|
/// <summary>
|
|
/// Process a source file for in-place code reload.
|
|
/// Extracts [CodeReload] methods, transforms to static overrides, and compiles.
|
|
/// DEADLOCK FIX: Detects main thread and uses synchronous processing when needed.
|
|
/// </summary>
|
|
/// <param name="sourceFilePath">Path to source file containing [CodeReload] methods</param>
|
|
/// <param name="assemblyDir">Optional directory to save compiled assembly</param>
|
|
/// <param name="pdb">Emit debug symbols mapped to the original source so breakpoints bind.</param>
|
|
/// <returns>Compilation result with success/failure and diagnostic information</returns>
|
|
public static Task<InPlaceReloadResult> ProcessSourceFileAsync(string sourceFilePath, string assemblyDir = null, bool pdb = false, bool useInterpreter = false)
|
|
{
|
|
// Runs synchronously on the calling (main) thread; returns a completed Task.
|
|
return Task.FromResult(ProcessSourceFileOnMainThread(sourceFilePath, assemblyDir, pdb, useInterpreter));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Process source file on main thread synchronously to avoid deadlocks.
|
|
/// </summary>
|
|
/// <param name="sourceFilePath">Path to source file containing [CodeReload] methods.</param>
|
|
/// <param name="assemblyDir">Optional directory to save compiled assembly.</param>
|
|
/// <param name="pdb">Emit debug symbols mapped to the original source so breakpoints bind.</param>
|
|
/// <param name="useInterpreter">Route the override through the interpreter backend instead of Assembly.Load.</param>
|
|
/// <returns>Compilation result with success/failure and diagnostic information.</returns>
|
|
public static InPlaceReloadResult ProcessSourceFileOnMainThread(string sourceFilePath, string assemblyDir = null, bool pdb = false, bool useInterpreter = false)
|
|
{
|
|
var result = new InPlaceReloadResult
|
|
{
|
|
SourceFilePath = sourceFilePath,
|
|
Success = false
|
|
};
|
|
|
|
try
|
|
{
|
|
Debug.Log($"CodeReload: Processing source file synchronously on main thread: {sourceFilePath}");
|
|
|
|
// The interpreter backend needs #line directives when source-line errors are
|
|
// enabled: its runtime errors resolve locations from the embedded PDB, which are
|
|
// only meaningful mapped to the user's file.
|
|
var lineInfo = useInterpreter && CodeReloadCompiler.EmitSourceLineInfo;
|
|
var prep = PrepareOverride(sourceFilePath, pdb || lineInfo, enforcePublicAccess: !useInterpreter);
|
|
if (!prep.Success)
|
|
{
|
|
result.ErrorMessage = prep.Error;
|
|
result.CompilationDiagnostics = prep.Diagnostics;
|
|
return result;
|
|
}
|
|
|
|
result.OriginalTypeName = prep.TypeName;
|
|
result.ExtractedMethods = prep.MethodNames;
|
|
result.UpToDateMethods = prep.UpToDateMethods;
|
|
result.TransformedCode = prep.TransformedCode;
|
|
|
|
// A method that matches the baseline again (the edit was undone) may still carry an
|
|
// override from an earlier reload — drop it so the compiled body runs at full speed.
|
|
foreach (var name in prep.UpToDateMethods)
|
|
{
|
|
var id = $"{prep.TypeName}.{name}";
|
|
if (CodeReloadRegistry.UnregisterMethodOverride(id))
|
|
result.RevertedMethods.Add(id);
|
|
}
|
|
|
|
if (prep.MethodNames.Count == 0)
|
|
{
|
|
result.Success = true;
|
|
result.CompilationDiagnostics = prep.Diagnostics;
|
|
Debug.Log($"CodeReload: {sourceFilePath} is up to date — all " +
|
|
$"{prep.UpToDateMethods.Count} [CodeReload] method(s) match the compiled baseline" +
|
|
(result.RevertedMethods.Count > 0
|
|
? $"; removed {result.RevertedMethods.Count} stale override(s)" : "") + ".");
|
|
return result;
|
|
}
|
|
|
|
var compilationResult = CompileTransformedCode(prep, assemblyDir, pdb, sourceFilePath, useInterpreter);
|
|
|
|
result.Success = compilationResult.IsSuccess;
|
|
result.AssemblyName = compilationResult.AssemblyName;
|
|
result.RegisteredMethods = compilationResult.RegisteredMethods;
|
|
result.CompilationDiagnostics = prep.Diagnostics.Concat(compilationResult.Diagnostics).ToList();
|
|
|
|
if (result.Success)
|
|
{
|
|
Debug.Log($"CodeReload: In-place reload successful for {sourceFilePath} - {result.RegisteredMethods.Count} methods registered" +
|
|
(result.UpToDateMethods.Count > 0 ? $" ({result.UpToDateMethods.Count} up to date, left compiled)" : ""));
|
|
}
|
|
else
|
|
{
|
|
result.ErrorMessage = compilationResult.ErrorDetails ?? "Compilation failed";
|
|
Debug.LogError($"CodeReload: In-place reload compilation failed: {result.ErrorMessage}");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError($"CodeReload: Error processing source file {sourceFilePath}: {ex.Message}\n{ex.StackTrace}");
|
|
|
|
result.ErrorMessage = $"Processing error: {ex.Message}";
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// What <see cref="PrepareOverride"/> hands back: the extracted type and surviving methods,
|
|
/// the transformed source (null when everything was up to date), and the diagnostics
|
|
/// gathered on the way. <see cref="Success"/> false means a hard failure with
|
|
/// <see cref="Error"/> set.
|
|
/// </summary>
|
|
private sealed class OverridePreparation
|
|
{
|
|
public bool Success;
|
|
public string Error;
|
|
public string TypeName;
|
|
public List<string> MethodNames;
|
|
public List<string> UpToDateMethods = new List<string>();
|
|
public string TransformedCode;
|
|
public List<string> Diagnostics = new List<string>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Shared prefix for in-place reload and push-to-player: read the file, extract [CodeReload]
|
|
/// methods, drop the ones still matching the captured <see cref="CodeReloadBaseline"/> (they
|
|
/// run correct AND faster compiled — <see cref="OverridePreparation.UpToDateMethods"/>
|
|
/// reports them, and <paramref name="forceInclude"/> keeps named ones in anyway), reject
|
|
/// non-public member access when the compiled backend will run the override
|
|
/// (<paramref name="enforcePublicAccess"/>), and transform bodies into a static override
|
|
/// class. When every method is up to date, succeeds with an empty
|
|
/// <see cref="OverridePreparation.MethodNames"/> and a null
|
|
/// <see cref="OverridePreparation.TransformedCode"/> — nothing to compile.
|
|
/// </summary>
|
|
private static OverridePreparation PrepareOverride(
|
|
string sourceFilePath, bool pdb, bool enforcePublicAccess,
|
|
string[] preprocessorSymbols = null, ICollection<string> forceInclude = null,
|
|
bool useBaseline = true)
|
|
{
|
|
var prep = new OverridePreparation();
|
|
|
|
var sourceCode = ReadSourceFile(sourceFilePath);
|
|
if (string.IsNullOrEmpty(sourceCode))
|
|
{
|
|
prep.Error = $"Could not read source file: {sourceFilePath}";
|
|
return prep;
|
|
}
|
|
|
|
var extraction = ExtractCodeReloadableMethods(sourceCode, preprocessorSymbols);
|
|
// Each skip entry carries its own reason (return-type gate, nested type, …).
|
|
foreach (var skipped in extraction.SkippedMethods)
|
|
prep.Diagnostics.Add($"[CodeReload] {skipped} was skipped.");
|
|
|
|
if (!extraction.HasMethods)
|
|
{
|
|
prep.Error = extraction.SkippedMethods.Count > 0
|
|
? $"No reloadable [CodeReload] methods in {sourceFilePath}. Skipped: " +
|
|
$"{string.Join(", ", extraction.SkippedMethods)}."
|
|
: $"No [CodeReload] methods found in {sourceFilePath}";
|
|
return prep;
|
|
}
|
|
|
|
// Skip methods whose declarations still match the captured baseline: their compiled
|
|
// bodies are already what the source says, and the compiled body is strictly faster
|
|
// than any override (the interpreter backend pays per call). No baseline captured
|
|
// (returns null) = no filtering, the pre-baseline behavior.
|
|
var unchanged = useBaseline
|
|
? CodeReloadBaseline.GetUnchangedMethods(sourceFilePath, sourceCode, preprocessorSymbols)
|
|
: null;
|
|
if (unchanged != null && unchanged.Count > 0)
|
|
{
|
|
foreach (var name in extraction.Methods.Keys.ToList())
|
|
{
|
|
if (!unchanged.Contains(name)) continue;
|
|
if (forceInclude != null && forceInclude.Contains(name)) continue;
|
|
extraction.Methods.Remove(name);
|
|
extraction.MethodSignatures.Remove(name);
|
|
prep.UpToDateMethods.Add(name);
|
|
}
|
|
|
|
if (extraction.Methods.Count == 0)
|
|
{
|
|
prep.TypeName = extraction.TypeName;
|
|
prep.MethodNames = new List<string>();
|
|
prep.Success = true;
|
|
return prep;
|
|
}
|
|
}
|
|
|
|
// Build one compilation + semantic model for the transform, so Roslyn's metadata bind
|
|
// is paid once per reload (shared with the string TransformMethodBodies overload).
|
|
var model = SourceCodeTransformer.BuildSemanticModel(
|
|
sourceCode, extraction.TypeName, out var classDecl, preprocessorSymbols);
|
|
if (classDecl == null)
|
|
{
|
|
prep.Error = $"Could not find class '{extraction.TypeName}' in source.";
|
|
return prep;
|
|
}
|
|
|
|
// Only the interpreter backend compiles with relaxed accessibility (see
|
|
// RoslynCompilationService.AllowNonPublicMemberAccess) and reaches non-public members at
|
|
// runtime, via reflection. The Assembly.Load backend keeps standard access checks — a
|
|
// non-public access would only surface later as a raw CS0122 — so reject it up front
|
|
// with an actionable message.
|
|
if (enforcePublicAccess)
|
|
{
|
|
var validation = AccessibilityValidator.ValidatePublicAccess(
|
|
model, classDecl, extraction.Methods, extraction.TypeName);
|
|
if (!validation.IsValid)
|
|
{
|
|
prep.Error = validation.GetFormattedErrorMessage();
|
|
return prep;
|
|
}
|
|
}
|
|
|
|
// enforcePublicAccess doubles as the backend discriminator (true == Assembly.Load, see
|
|
// the callers): only the interpreter needs interpolation lowered to string.Format —
|
|
// the compiled backend keeps interpolations native.
|
|
prep.TransformedCode = SourceCodeTransformer.TransformMethodBodies(
|
|
model, classDecl, extraction.Methods, extraction.TypeName, extraction.MethodSignatures,
|
|
emitLineDirectives: pdb, originalFilePath: sourceFilePath,
|
|
rewriteInterpolations: !enforcePublicAccess);
|
|
|
|
prep.TypeName = extraction.TypeName;
|
|
prep.MethodNames = extraction.Methods.Keys.ToList();
|
|
prep.Success = true;
|
|
return prep;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compile a source file's [CodeReload] override(s) to raw assembly IL bytes without
|
|
/// registering them locally — for pushing to a player that runs them through the
|
|
/// interpreter. Editor-side only (needs Roslyn). <paramref name="useBaseline"/> false
|
|
/// bypasses the <see cref="CodeReloadBaseline"/> filter — the caller can't vouch that the
|
|
/// target player was built from the baselined sources.
|
|
/// </summary>
|
|
internal static PushCompileResult CompileOverrideForPush(string sourceFilePath, string[] preprocessorSymbols = null,
|
|
ICollection<string> forceInclude = null, bool useBaseline = true)
|
|
{
|
|
var r = new PushCompileResult();
|
|
try
|
|
{
|
|
// When source-line errors are enabled, #line directives map each body to the
|
|
// original file so the embedded PDB's sequence points — used by the player-side
|
|
// interpreter for runtime error messages — carry the user's real line numbers.
|
|
// enforcePublicAccess: false — pushed overrides run through the on-device
|
|
// interpreter, which reaches non-public members by reflection.
|
|
var prep = PrepareOverride(sourceFilePath, pdb: CodeReloadCompiler.EmitSourceLineInfo,
|
|
enforcePublicAccess: false, preprocessorSymbols, forceInclude, useBaseline);
|
|
if (!prep.Success)
|
|
{
|
|
r.Error = prep.Error;
|
|
r.Diagnostics = prep.Diagnostics;
|
|
return r;
|
|
}
|
|
|
|
r.UpToDateMethods = prep.UpToDateMethods;
|
|
if (prep.MethodNames.Count == 0)
|
|
{
|
|
// Everything matches the baseline — a push would only replace compiled bodies
|
|
// with slower interpreted ones on the device.
|
|
r.Success = true;
|
|
r.TypeName = prep.TypeName;
|
|
r.Diagnostics = prep.Diagnostics;
|
|
return r;
|
|
}
|
|
|
|
var tempName = $"PushReload_{prep.TypeName}_{DateTime.Now:yyyyMMdd_HHmmss}";
|
|
if (!CodeReloadCompiler.TryCompileOverrideBytes(prep.TransformedCode, tempName, out var il, out var compileDiagnostics, documentPath: sourceFilePath, preprocessorSymbols: preprocessorSymbols))
|
|
{
|
|
r.Error = "Compilation failed";
|
|
r.Diagnostics = prep.Diagnostics.Concat(compileDiagnostics).ToList();
|
|
return r;
|
|
}
|
|
|
|
r.Success = true;
|
|
r.TypeName = prep.TypeName;
|
|
r.MethodNames = prep.MethodNames;
|
|
r.IlBytes = il;
|
|
r.Diagnostics = prep.Diagnostics.Concat(compileDiagnostics).ToList();
|
|
return r;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
r.Error = $"Push compile error: {ex.Message}";
|
|
return r;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if a source file contains [CodeReload] methods.
|
|
/// Simple synchronous check to avoid async deadlocks in tests.
|
|
/// </summary>
|
|
/// <param name="sourceFilePath">Path to source file to check</param>
|
|
/// <returns>True if file contains [CodeReload] methods</returns>
|
|
public static Task<bool> ContainsCodeReloadableMethodsAsync(string sourceFilePath)
|
|
{
|
|
try
|
|
{
|
|
if (!File.Exists(sourceFilePath))
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
|
|
// Use synchronous read for simple attribute check to avoid deadlocks
|
|
var sourceCode = File.ReadAllText(sourceFilePath);
|
|
if (string.IsNullOrEmpty(sourceCode))
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
|
|
// Quick check for the [CodeReload] attribute. Prefix match (no closing bracket) so
|
|
// combined attribute lists like [CodeReload, DebugPanel("x")] still pass.
|
|
var result = sourceCode.Contains("[CodeReload");
|
|
return Task.FromResult(result);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError($"CodeReload: Error checking for [CodeReload] methods in {sourceFilePath}: {ex.Message}");
|
|
return Task.FromResult(false);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read source file content synchronously (for main thread).
|
|
/// </summary>
|
|
private static string ReadSourceFile(string filePath)
|
|
{
|
|
try
|
|
{
|
|
if (!File.Exists(filePath))
|
|
{
|
|
Debug.LogError($"CodeReload: Source file not found: {filePath}");
|
|
return null;
|
|
}
|
|
|
|
return File.ReadAllText(filePath);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError($"CodeReload: Error reading source file {filePath}: {ex.Message}");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract [CodeReload] methods from source code.
|
|
/// </summary>
|
|
private static CodeReloadableExtractionResult ExtractCodeReloadableMethods(
|
|
string sourceCode, string[] preprocessorSymbols = null)
|
|
{
|
|
var result = new CodeReloadableExtractionResult();
|
|
|
|
try
|
|
{
|
|
var syntaxTree = CSharpSyntaxTree.ParseText(sourceCode,
|
|
RoslynCompilationService.ProjectParseOptions(preprocessorSymbols));
|
|
var root = syntaxTree.GetRoot();
|
|
|
|
// Find the class containing [CodeReload] methods.
|
|
var classDeclaration = root.DescendantNodes()
|
|
.OfType<ClassDeclarationSyntax>()
|
|
.FirstOrDefault(c => c.DescendantNodes().OfType<MethodDeclarationSyntax>().Any(HasCodeReloadAttribute));
|
|
|
|
if (classDeclaration == null)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
result.TypeName = classDeclaration.Identifier.ValueText;
|
|
|
|
// The transform lifts bodies into ONE override class for the top-level type chosen
|
|
// above. Tagged methods anywhere else in the file — in a NESTED type (which the
|
|
// weaver still weaves: Cecil's GetTypes() is recursive) or in a sibling top-level
|
|
// type — would otherwise be dropped without a word, leaving a woven prologue that
|
|
// never finds an override. Surface each one loudly; when nothing else is
|
|
// reloadable, these become the reload's error.
|
|
foreach (var method in root.DescendantNodes()
|
|
.OfType<MethodDeclarationSyntax>().Where(HasCodeReloadAttribute))
|
|
{
|
|
var owner = method.Ancestors().OfType<TypeDeclarationSyntax>().FirstOrDefault();
|
|
if (owner == null || owner == classDeclaration)
|
|
continue;
|
|
var ownerChain = string.Join(".", method.Ancestors()
|
|
.OfType<TypeDeclarationSyntax>().Reverse().Select(t => t.Identifier.ValueText));
|
|
result.SkippedMethods.Add(owner.Parent is TypeDeclarationSyntax
|
|
? $"'{method.Identifier.ValueText}' (declared in nested type '{ownerChain}' — " +
|
|
"code reload only supports methods declared directly in a top-level class)"
|
|
: $"'{method.Identifier.ValueText}' (declared in '{ownerChain}' — only the first " +
|
|
$"type with [CodeReload] methods, '{result.TypeName}', is reloaded per file; split the file)");
|
|
}
|
|
|
|
var codeReloadableMethods = classDeclaration.Members
|
|
.OfType<MethodDeclarationSyntax>()
|
|
.Where(HasCodeReloadAttribute);
|
|
|
|
foreach (var method in codeReloadableMethods)
|
|
{
|
|
var methodName = method.Identifier.ValueText;
|
|
|
|
// Tagged methods must pass the same gate the weaver applies (void or
|
|
// IEnumerator returns; instance or static). The weaver never weaves a
|
|
// dispatch prologue into the others, so their override would register and
|
|
// then never run — reload would report success while silently no-opping.
|
|
if (!IsMethodLevelSupported(method, out var skipReason))
|
|
{
|
|
result.SkippedMethods.Add($"'{methodName}' ({skipReason})");
|
|
continue;
|
|
}
|
|
var methodBody = ExtractMethodBody(method);
|
|
var signature = ExtractMethodSignature(method);
|
|
|
|
if (methodBody != null)
|
|
{
|
|
result.Methods[methodName] = methodBody;
|
|
result.MethodSignatures[methodName] = signature;
|
|
}
|
|
}
|
|
|
|
Debug.Log($"CodeReload: Extracted {result.Methods.Count} [CodeReload] methods from class {result.TypeName}");
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError($"CodeReload: Error extracting [CodeReload] methods: {ex.Message}");
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if method has [CodeReload] attribute. The unqualified name must match exactly: a
|
|
/// suffix match also catches [OnCodeReload] — the post-reload callback, not a reload target —
|
|
/// and pushing that name makes the player-side registry lookup fail for the whole file.
|
|
/// Internal so <see cref="CodeReloadBaseline"/> hashes exactly the methods extraction picks.
|
|
/// </summary>
|
|
internal static bool HasCodeReloadAttribute(MethodDeclarationSyntax method)
|
|
{
|
|
return method.AttributeLists
|
|
.SelectMany(al => al.Attributes)
|
|
.Any(a => UnqualifiedAttributeName(a) == "CodeReload");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Attribute name as the source wrote it, minus any namespace qualifier and the optional
|
|
/// "Attribute" suffix — [Foo.BarAttribute] and [Bar] both yield "Bar".
|
|
/// </summary>
|
|
private static string UnqualifiedAttributeName(AttributeSyntax attr)
|
|
{
|
|
var name = attr.Name.ToString();
|
|
var lastDot = name.LastIndexOf('.');
|
|
if (lastDot >= 0)
|
|
name = name.Substring(lastDot + 1);
|
|
if (name.EndsWith("Attribute"))
|
|
name = name.Substring(0, name.Length - "Attribute".Length);
|
|
return name;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gate for explicitly-tagged [CodeReload] methods, mirroring the skips the weaver applies
|
|
/// (CodeReloadInPlaceILPostProcessor.Process): unsupported return types get no dispatch
|
|
/// prologue, so extracting them would produce an override that never runs. Instance and
|
|
/// STATIC methods both weave (a static dispatches with a null instance). Coroutines
|
|
/// (System.Collections.IEnumerator) are supported: the weaver routes them through the
|
|
/// result dispatch, and the override's iterator — compiled or interpreted — is what
|
|
/// StartCoroutine drives.
|
|
/// </summary>
|
|
private static bool IsMethodLevelSupported(MethodDeclarationSyntax method, out string reason)
|
|
{
|
|
var returnType = method.ReturnType.ToString();
|
|
if (returnType != "void" &&
|
|
returnType is not ("IEnumerator" or "System.Collections.IEnumerator"))
|
|
{
|
|
reason = $"returns {returnType} — void methods and IEnumerator coroutines only";
|
|
return false;
|
|
}
|
|
|
|
reason = null;
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract method body content (excluding braces).
|
|
/// null when the method has no block body at all (expression-bodied, abstract).
|
|
/// </summary>
|
|
private static string ExtractMethodBody(MethodDeclarationSyntax method)
|
|
{
|
|
if (method.Body == null)
|
|
return null;
|
|
|
|
var bodyText = method.Body.ToString().Trim();
|
|
// Remove outer braces
|
|
if (bodyText.StartsWith("{") && bodyText.EndsWith("}"))
|
|
{
|
|
bodyText = bodyText.Substring(1, bodyText.Length - 2).Trim();
|
|
}
|
|
return bodyText;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract method signature information.
|
|
/// </summary>
|
|
private static MethodSignatureInfo ExtractMethodSignature(MethodDeclarationSyntax method)
|
|
{
|
|
var signature = new MethodSignatureInfo
|
|
{
|
|
ReturnType = method.ReturnType.ToString()
|
|
};
|
|
|
|
foreach (var parameter in method.ParameterList.Parameters)
|
|
{
|
|
var paramInfo = new ParameterInfo
|
|
{
|
|
Type = parameter.Type?.ToString() ?? "object",
|
|
Name = parameter.Identifier.ValueText,
|
|
HasDefaultValue = parameter.Default != null,
|
|
DefaultValue = parameter.Default?.Value?.ToString()
|
|
};
|
|
|
|
signature.Parameters.Add(paramInfo);
|
|
}
|
|
|
|
return signature;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compile transformed code synchronously (for main thread).
|
|
/// </summary>
|
|
private static CodeReloadCompileResult CompileTransformedCode(
|
|
OverridePreparation prep,
|
|
string assemblyDir,
|
|
bool emitPdb,
|
|
string documentPath,
|
|
bool useInterpreter)
|
|
{
|
|
try
|
|
{
|
|
// Generate a temporary file name for the transformed code
|
|
var tempFileName = $"InPlace_{prep.TypeName}_{DateTime.Now:yyyyMMdd_HHmmss}";
|
|
|
|
return CodeReloadCompiler.CompileSourceCodeOnMainThread(
|
|
prep.TransformedCode,
|
|
tempFileName,
|
|
assemblyDir,
|
|
emitPdb,
|
|
documentPath,
|
|
useInterpreter
|
|
? new InterpreterOverrideSet
|
|
{
|
|
TypeName = prep.TypeName,
|
|
MethodNames = prep.MethodNames
|
|
}
|
|
: null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError($"CodeReload: Error compiling transformed code for {prep.TypeName}: {ex.Message}");
|
|
|
|
return CodeReloadCompileResult.Failure(
|
|
"Compilation Error",
|
|
ex.Message,
|
|
0,
|
|
new List<string> { ex.ToString() });
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Result of extracting [CodeReload] methods from source code.
|
|
/// </summary>
|
|
private class CodeReloadableExtractionResult
|
|
{
|
|
/// <summary>
|
|
/// Name of the class containing [CodeReload] methods.
|
|
/// </summary>
|
|
public string TypeName { get; set; }
|
|
|
|
/// <summary>
|
|
/// Dictionary of method names to their extracted body code.
|
|
/// </summary>
|
|
public Dictionary<string, string> Methods { get; set; } = new Dictionary<string, string>();
|
|
|
|
/// <summary>
|
|
/// Dictionary of method names to their signature information.
|
|
/// </summary>
|
|
public Dictionary<string, MethodSignatureInfo> MethodSignatures { get; set; } = new Dictionary<string, MethodSignatureInfo>();
|
|
|
|
/// <summary>
|
|
/// Whether any [CodeReload] methods were found.
|
|
/// </summary>
|
|
public bool HasMethods => Methods.Count > 0;
|
|
|
|
/// <summary>
|
|
/// Explicitly-tagged methods that were rejected with the reason ("'Total' (returns
|
|
/// int — void methods and IEnumerator coroutines only)"), so the caller can report
|
|
/// them instead of failing opaquely.
|
|
/// </summary>
|
|
public List<string> SkippedMethods { get; } = new List<string>();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Result of in-place code reload processing.
|
|
/// </summary>
|
|
class InPlaceReloadResult
|
|
{
|
|
/// <summary>
|
|
/// Path to the source file that was processed.
|
|
/// </summary>
|
|
public string SourceFilePath { get; set; }
|
|
|
|
/// <summary>
|
|
/// Whether the processing was successful.
|
|
/// </summary>
|
|
public bool Success { get; set; }
|
|
|
|
/// <summary>
|
|
/// Name of the original type containing [CodeReload] methods.
|
|
/// </summary>
|
|
public string OriginalTypeName { get; set; }
|
|
|
|
/// <summary>
|
|
/// List of method names that were extracted and processed.
|
|
/// </summary>
|
|
public List<string> ExtractedMethods { get; set; } = new List<string>();
|
|
|
|
/// <summary>
|
|
/// Generated transformed code for code reload assembly.
|
|
/// </summary>
|
|
public string TransformedCode { get; set; }
|
|
|
|
/// <summary>
|
|
/// Name of the compiled assembly (if successful).
|
|
/// </summary>
|
|
public string AssemblyName { get; set; }
|
|
|
|
/// <summary>
|
|
/// List of registered method IDs (if successful).
|
|
/// </summary>
|
|
public List<string> RegisteredMethods { get; set; } = new List<string>();
|
|
|
|
/// <summary>
|
|
/// [CodeReload] method names skipped because they still match the compiled baseline —
|
|
/// their compiled bodies keep running (no interpreter cost).
|
|
/// </summary>
|
|
internal List<string> UpToDateMethods { get; set; } = new List<string>();
|
|
|
|
/// <summary>
|
|
/// Method ids whose stale override was removed because the source matches the compiled
|
|
/// baseline again (the edit was reverted).
|
|
/// </summary>
|
|
internal List<string> RevertedMethods { get; set; } = new List<string>();
|
|
|
|
/// <summary>Every extracted method matched the baseline; nothing was compiled or registered.</summary>
|
|
internal bool AllUpToDate => Success && ExtractedMethods.Count == 0 && UpToDateMethods.Count > 0;
|
|
|
|
/// <summary>
|
|
/// Error message if processing failed.
|
|
/// </summary>
|
|
public string ErrorMessage { get; set; }
|
|
|
|
/// <summary>
|
|
/// Compilation diagnostics (warnings, errors).
|
|
/// </summary>
|
|
public List<string> CompilationDiagnostics { get; set; } = new List<string>();
|
|
|
|
/// <summary>
|
|
/// Execution time in milliseconds.
|
|
/// </summary>
|
|
public long ExecutionTimeMs { get; set; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Result of compiling an override for pushing to a player (no local registration).
|
|
/// </summary>
|
|
internal class PushCompileResult
|
|
{
|
|
public bool Success { get; set; }
|
|
public string TypeName { get; set; }
|
|
public List<string> MethodNames { get; set; } = new List<string>();
|
|
public byte[] IlBytes { get; set; }
|
|
public string Error { get; set; }
|
|
public List<string> Diagnostics { get; set; } = new List<string>();
|
|
|
|
/// <summary>[CodeReload] method names skipped because they still match the compiled baseline.</summary>
|
|
public List<string> UpToDateMethods { get; set; } = new List<string>();
|
|
|
|
/// <summary>Every extracted method matched the baseline; there is nothing to push.</summary>
|
|
public bool AllUpToDate => Success && MethodNames.Count == 0 && UpToDateMethods.Count > 0;
|
|
}
|
|
} |