wehub-resource-sync
822 lines
31 KiB
C#
822 lines
31 KiB
C#
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text.RegularExpressions;
|
|
using MCPForUnity.Editor.Helpers;
|
|
using MCPForUnity.Runtime.Helpers;
|
|
using Newtonsoft.Json.Linq;
|
|
using UnityEditor;
|
|
|
|
namespace MCPForUnity.Editor.Tools
|
|
{
|
|
[McpForUnityTool("unity_reflect", AutoRegister = false, Group = "docs")]
|
|
public static class UnityReflect
|
|
{
|
|
private static Dictionary<string, Type[]> _assemblyTypeCache;
|
|
private static readonly object CacheLock = new();
|
|
private static readonly ConcurrentDictionary<Type, string[]> ExtensionMethodCache = new();
|
|
|
|
private static readonly string[] NamespacePrefixes =
|
|
{
|
|
"UnityEngine.",
|
|
"UnityEditor.",
|
|
"UnityEngine.UI.",
|
|
"Unity.Cinemachine.",
|
|
"UnityEngine.AI.",
|
|
"UnityEngine.Rendering.Universal.",
|
|
"UnityEngine.Rendering.HighDefinition.",
|
|
"UnityEngine.InputSystem.",
|
|
"UnityEngine.ProBuilder.",
|
|
"UnityEngine.Tilemaps.",
|
|
"UnityEngine.EventSystems.",
|
|
"UnityEngine.Rendering.",
|
|
"UnityEngine.SceneManagement.",
|
|
"UnityEngine.Animations.",
|
|
"UnityEngine.Playables.",
|
|
"UnityEngine.UIElements."
|
|
};
|
|
|
|
private static readonly Dictionary<Type, string> FriendlyTypeNames = new()
|
|
{
|
|
{ typeof(void), "void" },
|
|
{ typeof(int), "int" },
|
|
{ typeof(float), "float" },
|
|
{ typeof(bool), "bool" },
|
|
{ typeof(string), "string" },
|
|
{ typeof(double), "double" },
|
|
{ typeof(long), "long" },
|
|
{ typeof(object), "object" },
|
|
{ typeof(byte), "byte" },
|
|
{ typeof(short), "short" },
|
|
{ typeof(char), "char" },
|
|
{ typeof(decimal), "decimal" },
|
|
{ typeof(uint), "uint" },
|
|
{ typeof(ulong), "ulong" },
|
|
{ typeof(ushort), "ushort" },
|
|
{ typeof(sbyte), "sbyte" }
|
|
};
|
|
|
|
[InitializeOnLoadMethod]
|
|
private static void OnLoad()
|
|
{
|
|
AssemblyReloadEvents.afterAssemblyReload += InvalidateCache;
|
|
}
|
|
|
|
private static void InvalidateCache()
|
|
{
|
|
lock (CacheLock)
|
|
{
|
|
_assemblyTypeCache = null;
|
|
}
|
|
ExtensionMethodCache.Clear();
|
|
}
|
|
|
|
private static Dictionary<string, Type[]> GetAssemblyTypeCache()
|
|
{
|
|
lock (CacheLock)
|
|
{
|
|
if (_assemblyTypeCache != null)
|
|
return _assemblyTypeCache;
|
|
|
|
_assemblyTypeCache = new Dictionary<string, Type[]>();
|
|
foreach (var asm in UnityAssembliesCompat.GetLoadedAssemblies())
|
|
{
|
|
try
|
|
{
|
|
_assemblyTypeCache[asm.FullName] = asm.GetExportedTypes();
|
|
}
|
|
catch
|
|
{
|
|
// Some assemblies throw on GetExportedTypes
|
|
}
|
|
}
|
|
return _assemblyTypeCache;
|
|
}
|
|
}
|
|
|
|
public static object HandleCommand(JObject @params)
|
|
{
|
|
if (EditorApplication.isCompiling)
|
|
return new ErrorResponse("Cannot reflect while Unity is compiling. Wait for domain reload to complete.");
|
|
|
|
if (@params == null)
|
|
return new ErrorResponse("Parameters cannot be null.");
|
|
|
|
var p = new ToolParams(@params);
|
|
|
|
var actionResult = p.GetRequired("action");
|
|
if (!actionResult.IsSuccess)
|
|
return new ErrorResponse(actionResult.ErrorMessage);
|
|
|
|
string action = actionResult.Value.ToLowerInvariant();
|
|
|
|
try
|
|
{
|
|
switch (action)
|
|
{
|
|
case "get_type":
|
|
return GetTypeInfo(p);
|
|
case "get_member":
|
|
return GetMemberInfo(p);
|
|
case "search":
|
|
return SearchTypes(p);
|
|
default:
|
|
return new ErrorResponse(
|
|
$"Unknown action: '{action}'. Supported actions: get_type, get_member, search.");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new ErrorResponse(ex.Message, new { stackTrace = ex.StackTrace });
|
|
}
|
|
}
|
|
|
|
// === get_type ===
|
|
private static object GetTypeInfo(ToolParams p)
|
|
{
|
|
var classResult = p.GetRequired("class_name", "'class_name' parameter is required for get_type.");
|
|
if (!classResult.IsSuccess)
|
|
return new ErrorResponse(classResult.ErrorMessage);
|
|
|
|
string className = classResult.Value;
|
|
string normalizedName = NormalizeGenericName(className);
|
|
|
|
// Check for ambiguity first (only for short names without namespace)
|
|
if (!normalizedName.Contains('.') && !normalizedName.Contains('`'))
|
|
{
|
|
var matches = FindAllTypesByShortName(normalizedName);
|
|
if (matches.Count > 1)
|
|
{
|
|
return new SuccessResponse($"Ambiguous type name '{className}'.", new
|
|
{
|
|
found = true,
|
|
ambiguous = true,
|
|
query = className,
|
|
matches = matches.Select(t => t.FullName).OrderBy(n => n).ToArray(),
|
|
hint = "Use the fully qualified name (e.g., 'UnityEngine.UI.Button') to disambiguate."
|
|
});
|
|
}
|
|
}
|
|
|
|
var type = ResolveType(normalizedName);
|
|
if (type == null)
|
|
{
|
|
return new SuccessResponse($"Type '{className}' not found.", new
|
|
{
|
|
found = false,
|
|
query = className
|
|
});
|
|
}
|
|
|
|
// Open generic type definitions (e.g. List<T>) segfault Mono on Unity 2021.3
|
|
// in mono_metadata_generic_param_equal_internal when any member reflection is
|
|
// performed. Return minimal info using only safe property accesses.
|
|
if (type.IsGenericTypeDefinition)
|
|
{
|
|
return new SuccessResponse($"Type info for '{type.Name}'.", new
|
|
{
|
|
found = true,
|
|
name = type.Name,
|
|
full_name = type.FullName,
|
|
@namespace = type.Namespace,
|
|
assembly = type.Assembly.GetName().Name,
|
|
is_generic_type_definition = true,
|
|
hint = "Open generic type — consult docs for member details."
|
|
});
|
|
}
|
|
|
|
var flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
|
|
|
|
var methods = type.GetMethods(flags)
|
|
.Where(m => !m.IsSpecialName)
|
|
.Select(m => m.Name)
|
|
.Distinct()
|
|
.OrderBy(n => n)
|
|
.ToArray();
|
|
|
|
var properties = type.GetProperties(flags)
|
|
.Select(pr => pr.Name)
|
|
.Distinct()
|
|
.OrderBy(n => n)
|
|
.ToArray();
|
|
|
|
var fields = type.GetFields(flags)
|
|
.Select(f => f.Name)
|
|
.Distinct()
|
|
.OrderBy(n => n)
|
|
.ToArray();
|
|
|
|
var events = type.GetEvents(flags)
|
|
.Select(e => e.Name)
|
|
.Distinct()
|
|
.OrderBy(n => n)
|
|
.ToArray();
|
|
|
|
var obsoleteMembers = GetObsoleteMembers(type, flags);
|
|
var extensionMethods = FindExtensionMethods(type);
|
|
|
|
var interfaces = type.GetInterfaces()
|
|
.Select(i => FormatTypeName(i))
|
|
.OrderBy(n => n)
|
|
.ToArray();
|
|
|
|
return new SuccessResponse($"Type info for '{FormatTypeName(type)}'.", new
|
|
{
|
|
found = true,
|
|
name = FormatTypeName(type),
|
|
full_name = type.FullName,
|
|
@namespace = type.Namespace,
|
|
assembly = type.Assembly.GetName().Name,
|
|
base_class = type.BaseType != null ? FormatTypeName(type.BaseType) : null,
|
|
interfaces,
|
|
is_abstract = type.IsAbstract,
|
|
is_sealed = type.IsSealed,
|
|
is_static = type.IsAbstract && type.IsSealed,
|
|
is_enum = type.IsEnum,
|
|
is_interface = type.IsInterface,
|
|
members = new
|
|
{
|
|
methods,
|
|
properties,
|
|
fields,
|
|
events
|
|
},
|
|
extension_methods = extensionMethods,
|
|
obsolete_members = obsoleteMembers
|
|
});
|
|
}
|
|
|
|
// === get_member ===
|
|
private static object GetMemberInfo(ToolParams p)
|
|
{
|
|
var classResult = p.GetRequired("class_name", "'class_name' parameter is required for get_member.");
|
|
if (!classResult.IsSuccess)
|
|
return new ErrorResponse(classResult.ErrorMessage);
|
|
|
|
var memberResult = p.GetRequired("member_name", "'member_name' parameter is required for get_member.");
|
|
if (!memberResult.IsSuccess)
|
|
return new ErrorResponse(memberResult.ErrorMessage);
|
|
|
|
string className = classResult.Value;
|
|
string memberName = memberResult.Value;
|
|
string normalizedName = NormalizeGenericName(className);
|
|
|
|
if (!normalizedName.Contains('.') && !normalizedName.Contains('`'))
|
|
{
|
|
var matches = FindAllTypesByShortName(normalizedName);
|
|
if (matches.Count > 1)
|
|
{
|
|
return new SuccessResponse($"Ambiguous type name '{className}'.", new
|
|
{
|
|
found = true,
|
|
ambiguous = true,
|
|
query = className,
|
|
matches = matches.Select(t => t.FullName).OrderBy(n => n).ToArray(),
|
|
hint = "Use the fully qualified name to disambiguate before requesting member details."
|
|
});
|
|
}
|
|
}
|
|
|
|
var type = ResolveType(normalizedName);
|
|
if (type == null)
|
|
{
|
|
return new SuccessResponse($"Type '{className}' not found.", new
|
|
{
|
|
found = false,
|
|
query = className
|
|
});
|
|
}
|
|
|
|
if (type.IsGenericTypeDefinition)
|
|
{
|
|
return new SuccessResponse(
|
|
$"Open generic type '{type.Name}' — consult docs for member details.", new
|
|
{
|
|
found = false,
|
|
type_name = type.FullName,
|
|
member_name = memberName,
|
|
is_generic_type_definition = true,
|
|
hint = "Open generic type — consult docs for member details."
|
|
});
|
|
}
|
|
|
|
// Use flags without DeclaredOnly to find inherited members
|
|
var flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;
|
|
|
|
// Try methods first
|
|
var methods = type.GetMethods(flags)
|
|
.Where(m => !m.IsSpecialName && m.Name == memberName)
|
|
.ToArray();
|
|
|
|
if (methods.Length > 0)
|
|
{
|
|
var overloads = methods.Select(m => FormatMethodDetail(m)).ToArray();
|
|
return new SuccessResponse($"Member '{memberName}' on '{FormatTypeName(type)}'.", new
|
|
{
|
|
found = true,
|
|
type_name = FormatTypeName(type),
|
|
member_name = memberName,
|
|
member_type = "method",
|
|
overload_count = overloads.Length,
|
|
overloads
|
|
});
|
|
}
|
|
|
|
// Try properties
|
|
var prop = type.GetProperty(memberName, flags);
|
|
if (prop != null)
|
|
{
|
|
return new SuccessResponse($"Member '{memberName}' on '{FormatTypeName(type)}'.", new
|
|
{
|
|
found = true,
|
|
type_name = FormatTypeName(type),
|
|
member_name = memberName,
|
|
member_type = "property",
|
|
property_type = FormatTypeName(prop.PropertyType),
|
|
can_read = prop.CanRead,
|
|
can_write = prop.CanWrite,
|
|
is_static = (prop.GetMethod ?? prop.SetMethod)?.IsStatic ?? false,
|
|
is_obsolete = prop.GetCustomAttribute<ObsoleteAttribute>() != null,
|
|
declaring_type = prop.DeclaringType != type ? FormatTypeName(prop.DeclaringType) : null
|
|
});
|
|
}
|
|
|
|
// Try fields
|
|
var field = type.GetField(memberName, flags);
|
|
if (field != null)
|
|
{
|
|
return new SuccessResponse($"Member '{memberName}' on '{FormatTypeName(type)}'.", new
|
|
{
|
|
found = true,
|
|
type_name = FormatTypeName(type),
|
|
member_name = memberName,
|
|
member_type = "field",
|
|
field_type = FormatTypeName(field.FieldType),
|
|
is_static = field.IsStatic,
|
|
is_readonly = field.IsInitOnly,
|
|
is_constant = field.IsLiteral,
|
|
constant_value = field.IsLiteral ? field.GetRawConstantValue() : null,
|
|
is_obsolete = field.GetCustomAttribute<ObsoleteAttribute>() != null,
|
|
declaring_type = field.DeclaringType != type ? FormatTypeName(field.DeclaringType) : null
|
|
});
|
|
}
|
|
|
|
// Try events
|
|
var evt = type.GetEvent(memberName, flags);
|
|
if (evt != null)
|
|
{
|
|
return new SuccessResponse($"Member '{memberName}' on '{FormatTypeName(type)}'.", new
|
|
{
|
|
found = true,
|
|
type_name = FormatTypeName(type),
|
|
member_name = memberName,
|
|
member_type = "event",
|
|
event_handler_type = FormatTypeName(evt.EventHandlerType),
|
|
is_obsolete = evt.GetCustomAttribute<ObsoleteAttribute>() != null,
|
|
declaring_type = evt.DeclaringType != type ? FormatTypeName(evt.DeclaringType) : null
|
|
});
|
|
}
|
|
|
|
// Try extension methods as a last resort
|
|
var extMethods = FindExtensionMethodInfos(type, memberName);
|
|
if (extMethods.Length > 0)
|
|
{
|
|
var overloads = extMethods.Select(m => FormatMethodDetail(m)).ToArray();
|
|
return new SuccessResponse($"Extension method '{memberName}' on '{FormatTypeName(type)}'.", new
|
|
{
|
|
found = true,
|
|
type_name = FormatTypeName(type),
|
|
member_name = memberName,
|
|
member_type = "extension_method",
|
|
overload_count = overloads.Length,
|
|
overloads,
|
|
declaring_type = FormatTypeName(extMethods[0].DeclaringType)
|
|
});
|
|
}
|
|
|
|
return new SuccessResponse($"Member '{memberName}' not found on '{FormatTypeName(type)}'.", new
|
|
{
|
|
found = false,
|
|
type_name = FormatTypeName(type),
|
|
member_name = memberName
|
|
});
|
|
}
|
|
|
|
// === search ===
|
|
private static object SearchTypes(ToolParams p)
|
|
{
|
|
var queryResult = p.GetRequired("query", "'query' parameter is required for search.");
|
|
if (!queryResult.IsSuccess)
|
|
return new ErrorResponse(queryResult.ErrorMessage);
|
|
|
|
string query = queryResult.Value;
|
|
string scope = p.Get("scope", "unity").ToLowerInvariant();
|
|
|
|
if (scope != "unity" && scope != "packages" && scope != "project" && scope != "all")
|
|
{
|
|
return new ErrorResponse(
|
|
$"Invalid scope: '{scope}'. Supported: unity, packages, project, all.");
|
|
}
|
|
|
|
var cache = GetAssemblyTypeCache();
|
|
string queryLower = query.ToLowerInvariant();
|
|
|
|
var candidates = new List<(Type type, int rank)>();
|
|
|
|
foreach (var kvp in cache)
|
|
{
|
|
var asm = kvp.Value.Length > 0 ? kvp.Value[0].Assembly : null;
|
|
if (asm == null) continue;
|
|
|
|
string asmName = asm.GetName().Name;
|
|
if (!MatchesScope(asmName, scope))
|
|
continue;
|
|
|
|
foreach (var t in kvp.Value)
|
|
{
|
|
if (t.Name == null) continue;
|
|
|
|
string nameLower = t.Name.ToLowerInvariant();
|
|
string fullNameLower = t.FullName?.ToLowerInvariant() ?? nameLower;
|
|
|
|
if (nameLower == queryLower || fullNameLower == queryLower)
|
|
candidates.Add((t, 0)); // Exact match
|
|
else if (nameLower.StartsWith(queryLower))
|
|
candidates.Add((t, 1)); // Starts with
|
|
else if (nameLower.Contains(queryLower) || fullNameLower.Contains(queryLower))
|
|
candidates.Add((t, 2)); // Contains
|
|
}
|
|
}
|
|
|
|
var results = candidates
|
|
.OrderBy(c => c.rank)
|
|
.ThenBy(c => c.type.FullName)
|
|
.Take(25)
|
|
.Select(c => new
|
|
{
|
|
name = c.type.Name,
|
|
full_name = c.type.FullName,
|
|
@namespace = c.type.Namespace,
|
|
assembly = c.type.Assembly.GetName().Name,
|
|
is_class = c.type.IsClass,
|
|
is_enum = c.type.IsEnum,
|
|
is_interface = c.type.IsInterface,
|
|
is_struct = c.type.IsValueType && !c.type.IsEnum
|
|
})
|
|
.ToArray();
|
|
|
|
return new SuccessResponse($"Found {results.Length} type(s) matching '{query}' (scope: {scope}).", new
|
|
{
|
|
query,
|
|
scope,
|
|
count = results.Length,
|
|
results,
|
|
truncated = candidates.Count > 25
|
|
});
|
|
}
|
|
|
|
// --- Type Resolution ---
|
|
|
|
private static Type ResolveType(string className)
|
|
{
|
|
// Use the shared UnityTypeResolver which handles caching,
|
|
// namespace prefixes, player-over-editor priority, and TypeCache fallback.
|
|
var type = UnityTypeResolver.ResolveAny(className);
|
|
if (type != null) return type;
|
|
|
|
// UnityTypeResolver doesn't try our extended namespace prefixes,
|
|
// so fall back to assembly cache scan for edge cases.
|
|
var cache = GetAssemblyTypeCache();
|
|
foreach (var prefix in NamespacePrefixes)
|
|
{
|
|
string fullName = prefix + className;
|
|
foreach (var kvp in cache)
|
|
{
|
|
type = Array.Find(kvp.Value, t => t.FullName == fullName);
|
|
if (type != null) return type;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static List<Type> FindAllTypesByShortName(string shortName)
|
|
{
|
|
var matches = new List<Type>();
|
|
foreach (var kvp in GetAssemblyTypeCache())
|
|
{
|
|
foreach (var t in kvp.Value)
|
|
{
|
|
if (t.Name == shortName)
|
|
matches.Add(t);
|
|
}
|
|
}
|
|
return matches;
|
|
}
|
|
|
|
// --- Generic Name Normalization ---
|
|
|
|
private static string NormalizeGenericName(string name)
|
|
{
|
|
// Parse List<T> -> List`1, Dictionary<K,V> -> Dictionary`2
|
|
var match = Regex.Match(name, @"^(.+)<(.+)>$");
|
|
if (!match.Success) return name;
|
|
|
|
string baseName = match.Groups[1].Value;
|
|
string typeArgs = match.Groups[2].Value;
|
|
|
|
// Count generic args by tracking nesting depth
|
|
int argCount = 1;
|
|
int depth = 0;
|
|
foreach (char c in typeArgs)
|
|
{
|
|
if (c == '<') depth++;
|
|
else if (c == '>') depth--;
|
|
else if (c == ',' && depth == 0) argCount++;
|
|
}
|
|
|
|
return $"{baseName}`{argCount}";
|
|
}
|
|
|
|
// --- Type Name Formatting ---
|
|
|
|
private static string FormatTypeName(Type type)
|
|
{
|
|
if (type == null) return "null";
|
|
|
|
if (FriendlyTypeNames.TryGetValue(type, out var friendly))
|
|
return friendly;
|
|
|
|
if (type.IsArray)
|
|
return FormatTypeName(type.GetElementType()) + "[]";
|
|
|
|
if (type.IsByRef)
|
|
return FormatTypeName(type.GetElementType());
|
|
|
|
if (type.IsGenericType)
|
|
{
|
|
string baseName = type.Name;
|
|
int backtickIndex = baseName.IndexOf('`');
|
|
if (backtickIndex > 0)
|
|
baseName = baseName.Substring(0, backtickIndex);
|
|
|
|
var args = type.GetGenericArguments();
|
|
string argsStr = string.Join(", ", args.Select(FormatTypeName));
|
|
return $"{baseName}<{argsStr}>";
|
|
}
|
|
|
|
// For nested types, use dot notation
|
|
if (type.IsNested && type.DeclaringType != null)
|
|
return FormatTypeName(type.DeclaringType) + "." + type.Name;
|
|
|
|
return type.Name;
|
|
}
|
|
|
|
// --- Method Formatting ---
|
|
|
|
private static object FormatMethodDetail(MethodInfo m)
|
|
{
|
|
var parameters = m.GetParameters().Select(param =>
|
|
{
|
|
string prefix = "";
|
|
if (param.IsOut) prefix = "out ";
|
|
else if (param.ParameterType.IsByRef) prefix = "ref ";
|
|
|
|
return new
|
|
{
|
|
name = param.Name,
|
|
type = prefix + FormatTypeName(param.ParameterType),
|
|
has_default = param.HasDefaultValue,
|
|
default_value = param.HasDefaultValue ? FormatDefaultValue(param.DefaultValue) : null,
|
|
is_params = param.IsDefined(typeof(ParamArrayAttribute))
|
|
};
|
|
}).ToArray();
|
|
|
|
string signature = FormatMethodSignature(m);
|
|
var obsoleteAttr = m.GetCustomAttribute<ObsoleteAttribute>();
|
|
|
|
return new
|
|
{
|
|
signature,
|
|
return_type = FormatTypeName(m.ReturnType),
|
|
parameters,
|
|
is_static = m.IsStatic,
|
|
is_virtual = m.IsVirtual && !m.IsFinal,
|
|
is_abstract = m.IsAbstract,
|
|
is_generic = m.IsGenericMethod,
|
|
generic_arguments = m.IsGenericMethod
|
|
? m.GetGenericArguments().Select(a => a.Name).ToArray()
|
|
: null,
|
|
is_obsolete = obsoleteAttr != null,
|
|
obsolete_message = obsoleteAttr?.Message,
|
|
declaring_type = m.DeclaringType != m.ReflectedType
|
|
? FormatTypeName(m.DeclaringType)
|
|
: null
|
|
};
|
|
}
|
|
|
|
private static string FormatMethodSignature(MethodInfo m)
|
|
{
|
|
string staticPrefix = m.IsStatic ? "static " : "";
|
|
string returnType = FormatTypeName(m.ReturnType);
|
|
string name = m.Name;
|
|
|
|
if (m.IsGenericMethod)
|
|
{
|
|
var genArgs = m.GetGenericArguments();
|
|
name += "<" + string.Join(", ", genArgs.Select(a => a.Name)) + ">";
|
|
}
|
|
|
|
var paramStrings = m.GetParameters().Select(param =>
|
|
{
|
|
string prefix = "";
|
|
if (param.IsOut) prefix = "out ";
|
|
else if (param.ParameterType.IsByRef) prefix = "ref ";
|
|
|
|
if (param.IsDefined(typeof(ParamArrayAttribute)))
|
|
prefix = "params ";
|
|
|
|
return prefix + FormatTypeName(param.ParameterType) + " " + param.Name;
|
|
});
|
|
|
|
return $"{staticPrefix}{returnType} {name}({string.Join(", ", paramStrings)})";
|
|
}
|
|
|
|
private static object FormatDefaultValue(object value)
|
|
{
|
|
if (value == null) return "null";
|
|
if (value is string s) return $"\"{s}\"";
|
|
if (value is bool b) return b ? "true" : "false";
|
|
return value;
|
|
}
|
|
|
|
// --- Obsolete Member Detection ---
|
|
|
|
private static string[] GetObsoleteMembers(Type type, BindingFlags flags)
|
|
{
|
|
var obsolete = new HashSet<string>();
|
|
|
|
foreach (var m in type.GetMethods(flags).Where(m => !m.IsSpecialName))
|
|
{
|
|
if (m.GetCustomAttribute<ObsoleteAttribute>() != null)
|
|
obsolete.Add(m.Name);
|
|
}
|
|
foreach (var pr in type.GetProperties(flags))
|
|
{
|
|
if (pr.GetCustomAttribute<ObsoleteAttribute>() != null)
|
|
obsolete.Add(pr.Name);
|
|
}
|
|
foreach (var f in type.GetFields(flags))
|
|
{
|
|
if (f.GetCustomAttribute<ObsoleteAttribute>() != null)
|
|
obsolete.Add(f.Name);
|
|
}
|
|
foreach (var e in type.GetEvents(flags))
|
|
{
|
|
if (e.GetCustomAttribute<ObsoleteAttribute>() != null)
|
|
obsolete.Add(e.Name);
|
|
}
|
|
|
|
return obsolete.Count > 0 ? obsolete.OrderBy(n => n).ToArray() : Array.Empty<string>();
|
|
}
|
|
|
|
// --- Extension Method Discovery ---
|
|
|
|
private static string[] FindExtensionMethods(Type targetType)
|
|
{
|
|
if (ExtensionMethodCache.TryGetValue(targetType, out var cached))
|
|
return cached;
|
|
|
|
var extensionNames = new HashSet<string>();
|
|
var cache = GetAssemblyTypeCache();
|
|
|
|
foreach (var kvp in cache)
|
|
{
|
|
// Extract assembly name from the FullName key (e.g., "UnityEngine, Version=...")
|
|
string asmName = kvp.Key.Split(',')[0];
|
|
if (!asmName.StartsWith("UnityEngine") && !asmName.StartsWith("UnityEditor") && !asmName.StartsWith("Unity."))
|
|
continue;
|
|
|
|
foreach (var t in kvp.Value)
|
|
{
|
|
if (!t.IsAbstract || !t.IsSealed) continue; // Static classes only
|
|
if (!t.IsDefined(typeof(ExtensionAttribute), false)) continue;
|
|
|
|
foreach (var method in t.GetMethods(BindingFlags.Public | BindingFlags.Static))
|
|
{
|
|
if (!method.IsDefined(typeof(ExtensionAttribute), false)) continue;
|
|
|
|
var firstParam = method.GetParameters().FirstOrDefault();
|
|
if (firstParam == null) continue;
|
|
|
|
var paramType = firstParam.ParameterType;
|
|
if (paramType.IsAssignableFrom(targetType) || targetType.IsSubclassOf(paramType)
|
|
|| paramType == targetType
|
|
|| (paramType.IsGenericType && IsGenericMatch(paramType, targetType)))
|
|
{
|
|
extensionNames.Add(method.Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var result = extensionNames.Count > 0
|
|
? extensionNames.OrderBy(n => n).ToArray()
|
|
: Array.Empty<string>();
|
|
|
|
ExtensionMethodCache.TryAdd(targetType, result);
|
|
return result;
|
|
}
|
|
|
|
private static MethodInfo[] FindExtensionMethodInfos(Type targetType, string methodName)
|
|
{
|
|
var results = new List<MethodInfo>();
|
|
var cache = GetAssemblyTypeCache();
|
|
|
|
foreach (var kvp in cache)
|
|
{
|
|
string asmName = kvp.Key.Split(',')[0];
|
|
if (!asmName.StartsWith("UnityEngine") && !asmName.StartsWith("UnityEditor") && !asmName.StartsWith("Unity."))
|
|
continue;
|
|
|
|
foreach (var t in kvp.Value)
|
|
{
|
|
if (!t.IsAbstract || !t.IsSealed) continue;
|
|
if (!t.IsDefined(typeof(ExtensionAttribute), false)) continue;
|
|
|
|
foreach (var method in t.GetMethods(BindingFlags.Public | BindingFlags.Static))
|
|
{
|
|
if (method.Name != methodName) continue;
|
|
if (!method.IsDefined(typeof(ExtensionAttribute), false)) continue;
|
|
|
|
var firstParam = method.GetParameters().FirstOrDefault();
|
|
if (firstParam == null) continue;
|
|
|
|
var paramType = firstParam.ParameterType;
|
|
if (paramType.IsAssignableFrom(targetType) || targetType.IsSubclassOf(paramType)
|
|
|| paramType == targetType
|
|
|| (paramType.IsGenericType && IsGenericMatch(paramType, targetType)))
|
|
{
|
|
results.Add(method);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return results.ToArray();
|
|
}
|
|
|
|
private static bool IsGenericMatch(Type genericParamType, Type targetType)
|
|
{
|
|
if (!genericParamType.IsGenericType) return false;
|
|
|
|
var genDef = genericParamType.GetGenericTypeDefinition();
|
|
|
|
// Check if targetType implements or inherits from the generic definition
|
|
if (targetType.IsGenericType && targetType.GetGenericTypeDefinition() == genDef)
|
|
return true;
|
|
|
|
foreach (var iface in targetType.GetInterfaces())
|
|
{
|
|
if (iface.IsGenericType && iface.GetGenericTypeDefinition() == genDef)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// --- Scope Matching ---
|
|
|
|
private static bool MatchesScope(string assemblyName, string scope)
|
|
{
|
|
switch (scope)
|
|
{
|
|
case "unity":
|
|
return assemblyName.StartsWith("UnityEngine")
|
|
|| assemblyName.StartsWith("UnityEditor")
|
|
|| assemblyName.StartsWith("Unity.");
|
|
|
|
case "packages":
|
|
return !assemblyName.StartsWith("System")
|
|
&& !assemblyName.StartsWith("mscorlib")
|
|
&& !assemblyName.StartsWith("netstandard");
|
|
|
|
case "project":
|
|
return assemblyName == "Assembly-CSharp"
|
|
|| assemblyName == "Assembly-CSharp-Editor"
|
|
|| assemblyName.StartsWith("Assembly-CSharp-firstpass")
|
|
|| assemblyName.StartsWith("Assembly-CSharp-Editor-firstpass");
|
|
|
|
case "all":
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|