Add Unity Pipeline package support

2026-07-31 17:34:04 +08:00
parent d1a526094e
commit 786b7ffff9
590 changed files with 51995 additions and 2 deletions
@@ -0,0 +1,198 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Unity.Pipeline.Compilation;
+using UnityEngine;
+
+namespace Unity.Pipeline.HotReload
+{
+    /// <summary>
+    /// Validates that [HotReload] method bodies only access PUBLIC instance members of the
+    /// declaring type. In-place overrides are compiled into a separate assembly, so they can only
+    /// reach public members of the original type; private/internal/protected access would fail to
+    /// compile. This check runs up front (via a Roslyn semantic model) to produce a clear message
+    /// instead of a raw compiler error.
+    /// </summary>
+    public static class AccessibilityValidator
+    {
+        public static AccessibilityValidationResult ValidatePublicAccess(
+            string sourceCode,
+            Dictionary<string, string> methodBodies,
+            string originalTypeName)
+        {
+            var result = new AccessibilityValidationResult
+            {
+                IsValid = true,
+                Violations = new List<AccessibilityViolation>()
+            };
+
+            try
+            {
+                var tree = CSharpSyntaxTree.ParseText(sourceCode);
+                var root = tree.GetRoot();
+
+                var compilation = CSharpCompilation.Create(
+                    "HotReloadInPlaceValidation",
+                    new[] { tree },
+                    RoslynCompilationService.GetMetadataReferences(),
+                    new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+                var model = compilation.GetSemanticModel(tree);
+
+                var classDecl = root.DescendantNodes()
+                    .OfType<ClassDeclarationSyntax>()
+                    .FirstOrDefault(c => c.Identifier.ValueText == originalTypeName);
+                if (classDecl == null)
+                {
+                    result.IsValid = false;
+                    result.ValidationError = $"Could not find class '{originalTypeName}' in source.";
+                    return result;
+                }
+
+                var classSymbol = model.GetDeclaredSymbol(classDecl);
+
+                foreach (var method in classDecl.Members.OfType<MethodDeclarationSyntax>())
+                {
+                    var methodName = method.Identifier.ValueText;
+                    if (!methodBodies.ContainsKey(methodName) || method.Body == null)
+                        continue;
+
+                    var seen = new HashSet<string>();
+                    foreach (var name in method.Body.DescendantNodes().OfType<SimpleNameSyntax>())
+                    {
+                        if (IsMemberName(name))
+                            continue;
+
+                        var symbol = model.GetSymbolInfo(name).Symbol;
+                        if (!IsInstanceMemberOf(symbol, classSymbol))
+                            continue;
+
+                        if (symbol.DeclaredAccessibility != Accessibility.Public && seen.Add(symbol.Name))
+                        {
+                            result.Violations.Add(new AccessibilityViolation
+                            {
+                                MemberName = symbol.Name,
+                                MethodName = methodName,
+                                AccessLevel = symbol.DeclaredAccessibility,
+                                ViolationType = AccessibilityViolationType.PrivateAccess,
+                                ErrorMessage = $"Cannot access non-public member '{symbol.Name}' " +
+                                    $"({symbol.DeclaredAccessibility}) in [HotReload] method '{methodName}'",
+                                Suggestion = $"Make '{symbol.Name}' public in {originalTypeName}, or use a " +
+                                    "public property/method. In-place overrides compile in a separate assembly " +
+                                    "and can only access public members."
+                            });
+                        }
+                    }
+                }
+
+                result.IsValid = result.Violations.Count == 0;
+                return result;
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"HotReload: Accessibility validation error: {ex.Message}");
+                return new AccessibilityValidationResult
+                {
+                    IsValid = false,
+                    ValidationError = ex.Message,
+                    Violations = new List<AccessibilityViolation>()
+                };
+            }
+        }
+
+        /// <summary>True if the name is the right-hand member name of an access (foo.Bar -> Bar).</summary>
+        private static bool IsMemberName(SimpleNameSyntax node)
+        {
+            if (node.Parent is MemberAccessExpressionSyntax ma && ma.Name == node)
+                return true;
+            if (node.Parent is QualifiedNameSyntax)
+                return true;
+            if (node.Parent is MemberBindingExpressionSyntax)
+                return true;
+            return false;
+        }
+
+        /// <summary>True if the symbol is an instance field/property/method/event of the type or a base.</summary>
+        private static bool IsInstanceMemberOf(ISymbol symbol, INamedTypeSymbol type)
+        {
+            if (symbol == null || symbol.IsStatic)
+                return false;
+
+            switch (symbol.Kind)
+            {
+                case SymbolKind.Field:
+                case SymbolKind.Property:
+                case SymbolKind.Method:
+                case SymbolKind.Event:
+                    break;
+                default:
+                    return false;
+            }
+
+            for (var t = type; t != null; t = t.BaseType)
+            {
+                if (SymbolEqualityComparer.Default.Equals(t, symbol.ContainingType))
+                    return true;
+            }
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Result of accessibility validation for hot reload methods.
+    /// </summary>
+    public class AccessibilityValidationResult
+    {
+        public bool IsValid { get; set; }
+        public List<AccessibilityViolation> Violations { get; set; } = new List<AccessibilityViolation>();
+        public string ValidationError { get; set; }
+
+        public string GetFormattedErrorMessage()
+        {
+            if (!string.IsNullOrEmpty(ValidationError))
+                return $"HotReload Validation Error: {ValidationError}";
+
+            if (Violations.Count == 0)
+                return "All member access is valid for hot reload.";
+
+            var errorMessage = $"HotReload Validation Failed: {Violations.Count} accessibility violation(s) found\n\n";
+            for (int i = 0; i < Violations.Count; i++)
+            {
+                var violation = Violations[i];
+                errorMessage += $"{i + 1}. Method '{violation.MethodName}': {violation.ErrorMessage}\n";
+                errorMessage += $"   → Suggestion: {violation.Suggestion}\n";
+                if (i < Violations.Count - 1)
+                    errorMessage += "\n";
+            }
+
+            errorMessage += "\nFix these accessibility issues and run reload_file again.";
+            return errorMessage;
+        }
+    }
+
+    /// <summary>
+    /// Information about a specific accessibility violation in hot reload code.
+    /// </summary>
+    public class AccessibilityViolation
+    {
+        public string MemberName { get; set; }
+        public string MethodName { get; set; }
+        public Accessibility AccessLevel { get; set; }
+        public AccessibilityViolationType ViolationType { get; set; }
+        public string ErrorMessage { get; set; }
+        public string Suggestion { get; set; }
+    }
+
+    /// <summary>
+    /// Types of accessibility violations that can occur in hot reload methods.
+    /// </summary>
+    public enum AccessibilityViolationType
+    {
+        PrivateAccess,
+        InternalAccess,
+        ProtectedAccess,
+        ParseError
+    }
+}