mirror of
https://github.com/GeWuYou/GFramework.git
synced 2026-05-08 01:24:31 +08:00
8eaf837327
- 使用属性模式匹配替换条件判断语句 - 简化了方法声明语法的空值检查逻辑 - 优化了构造函数声明语法的表达式体检查 - 提高了代码可读性和维护性 - 减少了冗余的语法树遍历操作
908 lines
34 KiB
C#
908 lines
34 KiB
C#
using System.Collections.Immutable;
|
|
using GFramework.SourceGenerators.Common.Constants;
|
|
using GFramework.SourceGenerators.Diagnostics;
|
|
using Microsoft.CodeAnalysis.Diagnostics;
|
|
using Microsoft.CodeAnalysis.Operations;
|
|
|
|
namespace GFramework.SourceGenerators.Analyzers;
|
|
|
|
/// <summary>
|
|
/// 分析 Context Get 使用点是否能在所属架构中找到静态可见的 Model、System、Utility 注册。
|
|
/// </summary>
|
|
[DiagnosticAnalyzer(LanguageNames.CSharp)]
|
|
public sealed class ContextRegistrationAnalyzer : DiagnosticAnalyzer
|
|
{
|
|
/// <summary>
|
|
/// 当前分析器支持的诊断规则。
|
|
/// </summary>
|
|
public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>
|
|
ImmutableArray.Create(
|
|
ContextRegistrationDiagnostics.ModelRegistrationMissing,
|
|
ContextRegistrationDiagnostics.SystemRegistrationMissing,
|
|
ContextRegistrationDiagnostics.UtilityRegistrationMissing);
|
|
|
|
/// <summary>
|
|
/// 初始化分析器并注册字段注入与手写 GetX 调用分析。
|
|
/// </summary>
|
|
/// <param name="context">分析器上下文。</param>
|
|
public override void Initialize(AnalysisContext context)
|
|
{
|
|
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
|
|
context.EnableConcurrentExecution();
|
|
|
|
context.RegisterCompilationStartAction(static compilationContext =>
|
|
{
|
|
var symbols = SymbolCache.Create(compilationContext.Compilation);
|
|
if (!symbols.IsReady)
|
|
return;
|
|
|
|
var registrationIndex = new Lazy<RegistrationIndex>(
|
|
() => RegistrationIndex.Build(compilationContext.Compilation, symbols),
|
|
LazyThreadSafetyMode.ExecutionAndPublication);
|
|
|
|
compilationContext.RegisterSyntaxNodeAction(
|
|
syntaxContext => AnalyzeField(syntaxContext, symbols, registrationIndex.Value),
|
|
SyntaxKind.VariableDeclarator);
|
|
|
|
compilationContext.RegisterOperationAction(
|
|
operationContext => AnalyzeInvocation(operationContext, symbols, registrationIndex.Value),
|
|
OperationKind.Invocation);
|
|
});
|
|
}
|
|
|
|
private static void AnalyzeField(
|
|
SyntaxNodeAnalysisContext context,
|
|
SymbolCache symbols,
|
|
RegistrationIndex registrationIndex)
|
|
{
|
|
if (context.Node is not VariableDeclaratorSyntax variableDeclarator)
|
|
return;
|
|
|
|
if (context.SemanticModel.GetDeclaredSymbol(variableDeclarator, context.CancellationToken) is not IFieldSymbol fieldSymbol)
|
|
return;
|
|
|
|
if (!TryCreateBindingRequest(fieldSymbol, variableDeclarator.Identifier.GetLocation(), symbols, out var request))
|
|
return;
|
|
|
|
ReportMissingRegistration(context, registrationIndex, request);
|
|
}
|
|
|
|
private static void AnalyzeInvocation(
|
|
OperationAnalysisContext context,
|
|
SymbolCache symbols,
|
|
RegistrationIndex registrationIndex)
|
|
{
|
|
if (context.Operation is not IInvocationOperation invocation)
|
|
return;
|
|
|
|
if (!TryCreateBindingRequest(invocation, context.ContainingSymbol?.ContainingType, symbols, out var request))
|
|
return;
|
|
|
|
ReportMissingRegistration(context, registrationIndex, request);
|
|
}
|
|
|
|
private static void ReportMissingRegistration(
|
|
SyntaxNodeAnalysisContext context,
|
|
RegistrationIndex registrationIndex,
|
|
BindingRequest request)
|
|
{
|
|
if (!registrationIndex.TryGetOwningArchitecture(request.OwnerType, out var architectureType))
|
|
return;
|
|
|
|
if (registrationIndex.HasRegistration(architectureType, request.Kind, request.ServiceType))
|
|
return;
|
|
|
|
context.ReportDiagnostic(CreateMissingRegistrationDiagnostic(request, architectureType));
|
|
}
|
|
|
|
private static void ReportMissingRegistration(
|
|
OperationAnalysisContext context,
|
|
RegistrationIndex registrationIndex,
|
|
BindingRequest request)
|
|
{
|
|
if (!registrationIndex.TryGetOwningArchitecture(request.OwnerType, out var architectureType))
|
|
return;
|
|
|
|
if (registrationIndex.HasRegistration(architectureType, request.Kind, request.ServiceType))
|
|
return;
|
|
|
|
context.ReportDiagnostic(CreateMissingRegistrationDiagnostic(request, architectureType));
|
|
}
|
|
|
|
private static Diagnostic CreateMissingRegistrationDiagnostic(
|
|
BindingRequest request,
|
|
INamedTypeSymbol architectureType)
|
|
{
|
|
return Diagnostic.Create(
|
|
request.Kind switch
|
|
{
|
|
ComponentKind.Model => ContextRegistrationDiagnostics.ModelRegistrationMissing,
|
|
ComponentKind.System => ContextRegistrationDiagnostics.SystemRegistrationMissing,
|
|
ComponentKind.Utility => ContextRegistrationDiagnostics.UtilityRegistrationMissing,
|
|
_ => throw new ArgumentOutOfRangeException(nameof(request))
|
|
},
|
|
request.Location,
|
|
request.ServiceType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
|
|
request.OwnerType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
|
|
architectureType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat));
|
|
}
|
|
|
|
private static bool TryCreateBindingRequest(
|
|
IFieldSymbol fieldSymbol,
|
|
Location location,
|
|
SymbolCache symbols,
|
|
out BindingRequest request)
|
|
{
|
|
request = default;
|
|
|
|
if (fieldSymbol.ContainingType is not INamedTypeSymbol ownerType)
|
|
return false;
|
|
|
|
foreach (var attribute in fieldSymbol.GetAttributes())
|
|
{
|
|
if (!TryMapAttribute(attribute.AttributeClass, symbols, out var componentKind, out var expectsCollection))
|
|
continue;
|
|
|
|
var serviceType = expectsCollection
|
|
? TryGetCollectionElementType(fieldSymbol.Type, symbols)
|
|
: fieldSymbol.Type as INamedTypeSymbol;
|
|
|
|
if (serviceType == null)
|
|
return false;
|
|
|
|
request = new BindingRequest(componentKind, ownerType, serviceType, location);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool TryCreateBindingRequest(
|
|
IInvocationOperation invocation,
|
|
INamedTypeSymbol? ownerType,
|
|
SymbolCache symbols,
|
|
out BindingRequest request)
|
|
{
|
|
request = default;
|
|
|
|
var targetMethod = invocation.TargetMethod;
|
|
if (!targetMethod.IsGenericMethod || targetMethod.TypeArguments.Length != 1)
|
|
return false;
|
|
|
|
if (invocation.Syntax.SyntaxTree.FilePath.EndsWith(".g.cs", StringComparison.OrdinalIgnoreCase))
|
|
return false;
|
|
|
|
if (targetMethod.TypeArguments[0] is not INamedTypeSymbol serviceType)
|
|
return false;
|
|
|
|
if (_contextAwareBindingNames.TryGetValue(targetMethod.Name, out var modelKind))
|
|
{
|
|
if (!IsSupportedGetInvocationTarget(targetMethod, symbols))
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (ownerType == null)
|
|
return false;
|
|
|
|
request = new BindingRequest(modelKind, ownerType, serviceType, invocation.Syntax.GetLocation());
|
|
return true;
|
|
}
|
|
|
|
private static bool TryMapAttribute(
|
|
INamedTypeSymbol? attributeType,
|
|
SymbolCache symbols,
|
|
out ComponentKind componentKind,
|
|
out bool expectsCollection)
|
|
{
|
|
componentKind = default;
|
|
expectsCollection = false;
|
|
|
|
if (attributeType == null)
|
|
return false;
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(attributeType, symbols.GetModelAttribute))
|
|
{
|
|
componentKind = ComponentKind.Model;
|
|
return true;
|
|
}
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(attributeType, symbols.GetModelsAttribute))
|
|
{
|
|
componentKind = ComponentKind.Model;
|
|
expectsCollection = true;
|
|
return true;
|
|
}
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(attributeType, symbols.GetSystemAttribute))
|
|
{
|
|
componentKind = ComponentKind.System;
|
|
return true;
|
|
}
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(attributeType, symbols.GetSystemsAttribute))
|
|
{
|
|
componentKind = ComponentKind.System;
|
|
expectsCollection = true;
|
|
return true;
|
|
}
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(attributeType, symbols.GetUtilityAttribute))
|
|
{
|
|
componentKind = ComponentKind.Utility;
|
|
return true;
|
|
}
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(attributeType, symbols.GetUtilitiesAttribute))
|
|
{
|
|
componentKind = ComponentKind.Utility;
|
|
expectsCollection = true;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool IsSupportedGetInvocationTarget(
|
|
IMethodSymbol targetMethod,
|
|
SymbolCache symbols)
|
|
{
|
|
if (targetMethod.ContainingType == null)
|
|
return false;
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(targetMethod.ContainingType, symbols.ContextAwareServiceExtensions))
|
|
return true;
|
|
|
|
return SymbolHelpers.IsAssignableTo(targetMethod.ContainingType, symbols.IArchitectureContext);
|
|
}
|
|
|
|
private static INamedTypeSymbol? TryGetCollectionElementType(
|
|
ITypeSymbol fieldType,
|
|
SymbolCache symbols)
|
|
{
|
|
if (fieldType is not INamedTypeSymbol namedType)
|
|
return null;
|
|
|
|
if (!SymbolEqualityComparer.Default.Equals(namedType.OriginalDefinition, symbols.IReadOnlyList))
|
|
return null;
|
|
|
|
return namedType.TypeArguments[0] as INamedTypeSymbol;
|
|
}
|
|
|
|
private static readonly IReadOnlyDictionary<string, ComponentKind> _contextAwareBindingNames =
|
|
new Dictionary<string, ComponentKind>(StringComparer.Ordinal)
|
|
{
|
|
["GetModel"] = ComponentKind.Model,
|
|
["GetModels"] = ComponentKind.Model,
|
|
["GetSystem"] = ComponentKind.System,
|
|
["GetSystems"] = ComponentKind.System,
|
|
["GetUtility"] = ComponentKind.Utility,
|
|
["GetUtilities"] = ComponentKind.Utility
|
|
};
|
|
|
|
private enum ComponentKind
|
|
{
|
|
Model,
|
|
System,
|
|
Utility
|
|
}
|
|
|
|
private readonly record struct BindingRequest(
|
|
ComponentKind Kind,
|
|
INamedTypeSymbol OwnerType,
|
|
INamedTypeSymbol ServiceType,
|
|
Location Location);
|
|
|
|
private sealed class SymbolCache
|
|
{
|
|
private SymbolCache(
|
|
INamedTypeSymbol? architectureType,
|
|
INamedTypeSymbol? iArchitectureType,
|
|
INamedTypeSymbol? iArchitectureModuleType,
|
|
INamedTypeSymbol? iArchitectureContextType,
|
|
INamedTypeSymbol? iReadOnlyListType,
|
|
INamedTypeSymbol? contextAwareServiceExtensionsType,
|
|
INamedTypeSymbol? getModelAttribute,
|
|
INamedTypeSymbol? getModelsAttribute,
|
|
INamedTypeSymbol? getSystemAttribute,
|
|
INamedTypeSymbol? getSystemsAttribute,
|
|
INamedTypeSymbol? getUtilityAttribute,
|
|
INamedTypeSymbol? getUtilitiesAttribute)
|
|
{
|
|
ArchitectureType = architectureType;
|
|
IArchitectureType = iArchitectureType;
|
|
IArchitectureModuleType = iArchitectureModuleType;
|
|
IArchitectureContext = iArchitectureContextType;
|
|
IReadOnlyList = iReadOnlyListType;
|
|
ContextAwareServiceExtensions = contextAwareServiceExtensionsType;
|
|
GetModelAttribute = getModelAttribute;
|
|
GetModelsAttribute = getModelsAttribute;
|
|
GetSystemAttribute = getSystemAttribute;
|
|
GetSystemsAttribute = getSystemsAttribute;
|
|
GetUtilityAttribute = getUtilityAttribute;
|
|
GetUtilitiesAttribute = getUtilitiesAttribute;
|
|
}
|
|
|
|
public INamedTypeSymbol? ArchitectureType { get; }
|
|
|
|
public INamedTypeSymbol? IArchitectureType { get; }
|
|
|
|
public INamedTypeSymbol? IArchitectureModuleType { get; }
|
|
|
|
public INamedTypeSymbol? IArchitectureContext { get; }
|
|
|
|
public INamedTypeSymbol? IReadOnlyList { get; }
|
|
|
|
public INamedTypeSymbol? ContextAwareServiceExtensions { get; }
|
|
|
|
public INamedTypeSymbol? GetModelAttribute { get; }
|
|
|
|
public INamedTypeSymbol? GetModelsAttribute { get; }
|
|
|
|
public INamedTypeSymbol? GetSystemAttribute { get; }
|
|
|
|
public INamedTypeSymbol? GetSystemsAttribute { get; }
|
|
|
|
public INamedTypeSymbol? GetUtilityAttribute { get; }
|
|
|
|
public INamedTypeSymbol? GetUtilitiesAttribute { get; }
|
|
|
|
public bool IsReady =>
|
|
ArchitectureType != null &&
|
|
IArchitectureType != null &&
|
|
IArchitectureModuleType != null &&
|
|
IArchitectureContext != null &&
|
|
IReadOnlyList != null &&
|
|
ContextAwareServiceExtensions != null &&
|
|
GetModelAttribute != null &&
|
|
GetModelsAttribute != null &&
|
|
GetSystemAttribute != null &&
|
|
GetSystemsAttribute != null &&
|
|
GetUtilityAttribute != null &&
|
|
GetUtilitiesAttribute != null;
|
|
|
|
public static SymbolCache Create(Compilation compilation)
|
|
{
|
|
return new SymbolCache(
|
|
compilation.GetTypeByMetadataName($"{PathContests.CoreNamespace}.Architectures.Architecture"),
|
|
compilation.GetTypeByMetadataName($"{PathContests.CoreAbstractionsNamespace}.Architectures.IArchitecture"),
|
|
compilation.GetTypeByMetadataName($"{PathContests.CoreAbstractionsNamespace}.Architectures.IArchitectureModule"),
|
|
compilation.GetTypeByMetadataName($"{PathContests.CoreAbstractionsNamespace}.Architectures.IArchitectureContext"),
|
|
compilation.GetTypeByMetadataName("System.Collections.Generic.IReadOnlyList`1"),
|
|
compilation.GetTypeByMetadataName($"{PathContests.CoreNamespace}.Extensions.ContextAwareServiceExtensions"),
|
|
compilation.GetTypeByMetadataName($"{PathContests.SourceGeneratorsAbstractionsPath}.Rule.GetModelAttribute"),
|
|
compilation.GetTypeByMetadataName($"{PathContests.SourceGeneratorsAbstractionsPath}.Rule.GetModelsAttribute"),
|
|
compilation.GetTypeByMetadataName($"{PathContests.SourceGeneratorsAbstractionsPath}.Rule.GetSystemAttribute"),
|
|
compilation.GetTypeByMetadataName($"{PathContests.SourceGeneratorsAbstractionsPath}.Rule.GetSystemsAttribute"),
|
|
compilation.GetTypeByMetadataName($"{PathContests.SourceGeneratorsAbstractionsPath}.Rule.GetUtilityAttribute"),
|
|
compilation.GetTypeByMetadataName($"{PathContests.SourceGeneratorsAbstractionsPath}.Rule.GetUtilitiesAttribute"));
|
|
}
|
|
}
|
|
|
|
private sealed class RegistrationIndex
|
|
{
|
|
private RegistrationIndex(
|
|
Compilation compilation,
|
|
IReadOnlyDictionary<INamedTypeSymbol, ArchitectureRegistrationData> registrations)
|
|
{
|
|
_compilation = compilation;
|
|
_registrations = registrations;
|
|
}
|
|
|
|
private readonly Compilation _compilation;
|
|
private readonly IReadOnlyDictionary<INamedTypeSymbol, ArchitectureRegistrationData> _registrations;
|
|
|
|
public static RegistrationIndex Build(
|
|
Compilation compilation,
|
|
SymbolCache symbols)
|
|
{
|
|
var registrations = new Dictionary<INamedTypeSymbol, ArchitectureRegistrationData>(SymbolEqualityComparer.Default);
|
|
|
|
foreach (var type in SymbolHelpers.EnumerateNamedTypes(compilation.Assembly.GlobalNamespace))
|
|
{
|
|
if (!SymbolHelpers.IsAssignableTo(type, symbols.ArchitectureType))
|
|
continue;
|
|
|
|
if (type.IsAbstract)
|
|
continue;
|
|
|
|
var data = AnalyzeArchitecture(compilation, symbols, type);
|
|
if (data.IsEmpty)
|
|
continue;
|
|
|
|
registrations[type] = data;
|
|
}
|
|
|
|
return new RegistrationIndex(compilation, registrations);
|
|
}
|
|
|
|
public bool TryGetOwningArchitecture(
|
|
INamedTypeSymbol ownerType,
|
|
out INamedTypeSymbol architectureType)
|
|
{
|
|
architectureType = default!;
|
|
|
|
if (_registrations.ContainsKey(ownerType))
|
|
{
|
|
architectureType = ownerType;
|
|
return true;
|
|
}
|
|
|
|
INamedTypeSymbol? candidate = null;
|
|
foreach (var pair in _registrations)
|
|
{
|
|
if (!pair.Value.ContainsOwner(ownerType, _compilation))
|
|
continue;
|
|
|
|
if (candidate != null)
|
|
return false;
|
|
|
|
candidate = pair.Key;
|
|
}
|
|
|
|
if (candidate == null)
|
|
return false;
|
|
|
|
architectureType = candidate;
|
|
return true;
|
|
}
|
|
|
|
public bool HasRegistration(
|
|
INamedTypeSymbol architectureType,
|
|
ComponentKind componentKind,
|
|
INamedTypeSymbol serviceType)
|
|
{
|
|
if (!_registrations.TryGetValue(architectureType, out var data))
|
|
return false;
|
|
|
|
return data.HasRegistration(componentKind, serviceType, _compilation);
|
|
}
|
|
|
|
private static ArchitectureRegistrationData AnalyzeArchitecture(
|
|
Compilation compilation,
|
|
SymbolCache symbols,
|
|
INamedTypeSymbol architectureType)
|
|
{
|
|
var data = new ArchitectureRegistrationData();
|
|
var visitedMethods = new HashSet<IMethodSymbol>(SymbolEqualityComparer.Default);
|
|
var pendingMethods = new Queue<IMethodSymbol>();
|
|
var visitedModules = new HashSet<INamedTypeSymbol>(SymbolEqualityComparer.Default);
|
|
|
|
foreach (var rootMethod in GetArchitectureRootMethods(architectureType))
|
|
pendingMethods.Enqueue(rootMethod);
|
|
|
|
while (pendingMethods.Count > 0)
|
|
{
|
|
var method = pendingMethods.Dequeue();
|
|
if (!visitedMethods.Add(method))
|
|
continue;
|
|
|
|
foreach (var invocation in SymbolHelpers.GetInvocationOperations(method, compilation))
|
|
{
|
|
if (TryGetRegistration(invocation, symbols, out var kind, out var registeredType))
|
|
{
|
|
data.Add(kind, registeredType);
|
|
continue;
|
|
}
|
|
|
|
if (TryGetInstalledModuleType(invocation, symbols, out var moduleType) &&
|
|
visitedModules.Add(moduleType))
|
|
{
|
|
AnalyzeModule(compilation, symbols, moduleType, data, visitedModules);
|
|
continue;
|
|
}
|
|
|
|
if (TryResolveArchitectureHelperMethod(invocation.TargetMethod, architectureType, out var helperMethod))
|
|
pendingMethods.Enqueue(helperMethod);
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
private static void AnalyzeModule(
|
|
Compilation compilation,
|
|
SymbolCache symbols,
|
|
INamedTypeSymbol moduleType,
|
|
ArchitectureRegistrationData data,
|
|
ISet<INamedTypeSymbol> visitedModules)
|
|
{
|
|
var visitedMethods = new HashSet<IMethodSymbol>(SymbolEqualityComparer.Default);
|
|
var pendingMethods = new Queue<IMethodSymbol>();
|
|
|
|
foreach (var rootMethod in GetModuleRootMethods(moduleType))
|
|
pendingMethods.Enqueue(rootMethod);
|
|
|
|
while (pendingMethods.Count > 0)
|
|
{
|
|
var method = pendingMethods.Dequeue();
|
|
if (!visitedMethods.Add(method))
|
|
continue;
|
|
|
|
foreach (var invocation in SymbolHelpers.GetInvocationOperations(method, compilation))
|
|
{
|
|
if (TryGetRegistration(invocation, symbols, out var kind, out var registeredType))
|
|
{
|
|
data.Add(kind, registeredType);
|
|
continue;
|
|
}
|
|
|
|
if (TryGetInstalledModuleType(invocation, symbols, out var nestedModuleType) &&
|
|
visitedModules.Add(nestedModuleType))
|
|
{
|
|
AnalyzeModule(compilation, symbols, nestedModuleType, data, visitedModules);
|
|
continue;
|
|
}
|
|
|
|
if (TryResolveModuleHelperMethod(invocation.TargetMethod, moduleType, out var helperMethod))
|
|
pendingMethods.Enqueue(helperMethod);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static IEnumerable<IMethodSymbol> GetArchitectureRootMethods(INamedTypeSymbol architectureType)
|
|
{
|
|
foreach (var type in SymbolHelpers.EnumerateTypeHierarchy(architectureType))
|
|
{
|
|
foreach (var member in type.GetMembers())
|
|
{
|
|
if (member is not IMethodSymbol method)
|
|
continue;
|
|
|
|
if (method.IsStatic)
|
|
continue;
|
|
|
|
if (method.Name is not ("OnInitialize" or "InstallModules"))
|
|
continue;
|
|
|
|
if (method.DeclaringSyntaxReferences.Length == 0)
|
|
continue;
|
|
|
|
yield return method;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static IEnumerable<IMethodSymbol> GetModuleRootMethods(INamedTypeSymbol moduleType)
|
|
{
|
|
foreach (var type in SymbolHelpers.EnumerateTypeHierarchy(moduleType))
|
|
{
|
|
foreach (var member in type.GetMembers("Install").OfType<IMethodSymbol>())
|
|
{
|
|
if (member.IsStatic || member.Parameters.Length != 1)
|
|
continue;
|
|
|
|
if (member.DeclaringSyntaxReferences.Length == 0)
|
|
continue;
|
|
|
|
yield return member;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static bool TryGetInstalledModuleType(
|
|
IInvocationOperation invocation,
|
|
SymbolCache symbols,
|
|
out INamedTypeSymbol moduleType)
|
|
{
|
|
moduleType = default!;
|
|
|
|
if (invocation.Arguments.Length == 0)
|
|
return false;
|
|
|
|
if (invocation.TargetMethod.Name is not ("InstallModule" or "InstallGodotModule"))
|
|
return false;
|
|
|
|
var candidateType = SymbolHelpers.TryGetCreatedType(invocation.Arguments[0].Value);
|
|
if (candidateType == null)
|
|
return false;
|
|
|
|
if (!SymbolHelpers.IsAssignableTo(candidateType, symbols.IArchitectureModuleType))
|
|
return false;
|
|
|
|
moduleType = candidateType;
|
|
return true;
|
|
}
|
|
|
|
private static bool TryGetRegistration(
|
|
IInvocationOperation invocation,
|
|
SymbolCache symbols,
|
|
out ComponentKind componentKind,
|
|
out INamedTypeSymbol registeredType)
|
|
{
|
|
componentKind = default;
|
|
registeredType = default!;
|
|
|
|
var targetMethod = invocation.TargetMethod;
|
|
if (!targetMethod.IsGenericMethod || targetMethod.TypeArguments.Length != 1)
|
|
return false;
|
|
|
|
if (targetMethod.TypeArguments[0] is not INamedTypeSymbol namedType)
|
|
return false;
|
|
|
|
if (targetMethod.Name == "RegisterModel" &&
|
|
SymbolHelpers.IsAssignableTo(targetMethod.ContainingType, symbols.IArchitectureType))
|
|
{
|
|
componentKind = ComponentKind.Model;
|
|
registeredType = namedType;
|
|
return true;
|
|
}
|
|
|
|
if (targetMethod.Name == "RegisterSystem" &&
|
|
SymbolHelpers.IsAssignableTo(targetMethod.ContainingType, symbols.IArchitectureType))
|
|
{
|
|
componentKind = ComponentKind.System;
|
|
registeredType = namedType;
|
|
return true;
|
|
}
|
|
|
|
if (targetMethod.Name == "RegisterUtility" &&
|
|
SymbolHelpers.IsAssignableTo(targetMethod.ContainingType, symbols.IArchitectureType))
|
|
{
|
|
componentKind = ComponentKind.Utility;
|
|
registeredType = namedType;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool TryResolveArchitectureHelperMethod(
|
|
IMethodSymbol targetMethod,
|
|
INamedTypeSymbol architectureType,
|
|
out IMethodSymbol helperMethod)
|
|
{
|
|
helperMethod = default!;
|
|
|
|
if (targetMethod.MethodKind is not (MethodKind.Ordinary or MethodKind.Constructor))
|
|
return false;
|
|
|
|
if (!SymbolHelpers.IsWithinTypeHierarchy(targetMethod.ContainingType, architectureType))
|
|
return false;
|
|
|
|
// 对已经具备源码的方法保留原始目标，避免把显式的 base 调用重新折回到当前 override。
|
|
helperMethod = targetMethod.DeclaringSyntaxReferences.Length > 0 && !targetMethod.IsAbstract
|
|
? targetMethod
|
|
: SymbolHelpers.ResolveHierarchyMethodImplementation(targetMethod, architectureType) ?? targetMethod;
|
|
return helperMethod.DeclaringSyntaxReferences.Length > 0;
|
|
}
|
|
|
|
private static bool TryResolveModuleHelperMethod(
|
|
IMethodSymbol targetMethod,
|
|
INamedTypeSymbol moduleType,
|
|
out IMethodSymbol helperMethod)
|
|
{
|
|
helperMethod = default!;
|
|
|
|
if (targetMethod.MethodKind is not (MethodKind.Ordinary or MethodKind.Constructor))
|
|
return false;
|
|
|
|
if (!SymbolHelpers.IsWithinTypeHierarchy(targetMethod.ContainingType, moduleType))
|
|
return false;
|
|
|
|
helperMethod = targetMethod.DeclaringSyntaxReferences.Length > 0 && !targetMethod.IsAbstract
|
|
? targetMethod
|
|
: SymbolHelpers.ResolveHierarchyMethodImplementation(targetMethod, moduleType) ?? targetMethod;
|
|
return helperMethod.DeclaringSyntaxReferences.Length > 0;
|
|
}
|
|
}
|
|
|
|
private sealed class ArchitectureRegistrationData
|
|
{
|
|
private readonly HashSet<INamedTypeSymbol> _models = new(SymbolEqualityComparer.Default);
|
|
private readonly HashSet<INamedTypeSymbol> _systems = new(SymbolEqualityComparer.Default);
|
|
private readonly HashSet<INamedTypeSymbol> _utilities = new(SymbolEqualityComparer.Default);
|
|
|
|
public bool IsEmpty => _models.Count == 0 && _systems.Count == 0 && _utilities.Count == 0;
|
|
|
|
public void Add(ComponentKind componentKind, INamedTypeSymbol registeredType)
|
|
{
|
|
GetCollection(componentKind).Add(registeredType);
|
|
}
|
|
|
|
public bool HasRegistration(
|
|
ComponentKind componentKind,
|
|
INamedTypeSymbol requestedType,
|
|
Compilation compilation)
|
|
{
|
|
return GetCollection(componentKind).Any(candidate =>
|
|
SymbolHelpers.IsServiceCompatible(candidate, requestedType, compilation));
|
|
}
|
|
|
|
public bool ContainsOwner(
|
|
INamedTypeSymbol ownerType,
|
|
Compilation compilation)
|
|
{
|
|
return _models.Any(candidate => SymbolHelpers.IsOwnershipCompatible(ownerType, candidate, compilation)) ||
|
|
_systems.Any(candidate => SymbolHelpers.IsOwnershipCompatible(ownerType, candidate, compilation)) ||
|
|
_utilities.Any(candidate => SymbolHelpers.IsOwnershipCompatible(ownerType, candidate, compilation));
|
|
}
|
|
|
|
private ISet<INamedTypeSymbol> GetCollection(ComponentKind componentKind)
|
|
{
|
|
return componentKind switch
|
|
{
|
|
ComponentKind.Model => _models,
|
|
ComponentKind.System => _systems,
|
|
ComponentKind.Utility => _utilities,
|
|
_ => throw new ArgumentOutOfRangeException(nameof(componentKind))
|
|
};
|
|
}
|
|
}
|
|
|
|
private static class SymbolHelpers
|
|
{
|
|
public static IEnumerable<INamedTypeSymbol> EnumerateNamedTypes(INamespaceSymbol namespaceSymbol)
|
|
{
|
|
foreach (var namespaceMember in namespaceSymbol.GetNamespaceMembers())
|
|
{
|
|
foreach (var nestedType in EnumerateNamedTypes(namespaceMember))
|
|
yield return nestedType;
|
|
}
|
|
|
|
foreach (var typeMember in namespaceSymbol.GetTypeMembers())
|
|
{
|
|
yield return typeMember;
|
|
|
|
foreach (var nestedType in EnumerateNestedTypes(typeMember))
|
|
yield return nestedType;
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<INamedTypeSymbol> EnumerateTypeHierarchy(INamedTypeSymbol type)
|
|
{
|
|
for (var current = type; current != null; current = current.BaseType)
|
|
yield return current;
|
|
}
|
|
|
|
public static bool IsAssignableTo(ITypeSymbol? fromType, ITypeSymbol? toType)
|
|
{
|
|
if (fromType == null || toType == null)
|
|
return false;
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(fromType, toType))
|
|
return true;
|
|
|
|
return fromType.AllInterfaces.Any(interfaceType =>
|
|
SymbolEqualityComparer.Default.Equals(interfaceType, toType)) ||
|
|
EnumerateBaseTypes(fromType).Any(baseType =>
|
|
SymbolEqualityComparer.Default.Equals(baseType, toType));
|
|
}
|
|
|
|
public static bool IsWithinTypeHierarchy(
|
|
INamedTypeSymbol? candidateType,
|
|
INamedTypeSymbol ownerType)
|
|
{
|
|
if (candidateType == null)
|
|
return false;
|
|
|
|
return EnumerateTypeHierarchy(ownerType).Any(type =>
|
|
SymbolEqualityComparer.Default.Equals(type, candidateType));
|
|
}
|
|
|
|
public static IMethodSymbol? ResolveHierarchyMethodImplementation(
|
|
IMethodSymbol method,
|
|
INamedTypeSymbol ownerType)
|
|
{
|
|
foreach (var type in EnumerateTypeHierarchy(ownerType))
|
|
{
|
|
foreach (var candidate in type.GetMembers(method.Name).OfType<IMethodSymbol>())
|
|
{
|
|
if (!HasCompatibleSignature(candidate, method))
|
|
continue;
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(candidate.OriginalDefinition, method.OriginalDefinition))
|
|
return candidate;
|
|
|
|
for (var overridden = candidate.OverriddenMethod; overridden != null; overridden = overridden.OverriddenMethod)
|
|
{
|
|
if (SymbolEqualityComparer.Default.Equals(overridden.OriginalDefinition, method.OriginalDefinition))
|
|
return candidate;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static IEnumerable<IInvocationOperation> GetInvocationOperations(
|
|
IMethodSymbol method,
|
|
Compilation compilation)
|
|
{
|
|
foreach (var syntaxReference in method.DeclaringSyntaxReferences)
|
|
{
|
|
var syntax = syntaxReference.GetSyntax();
|
|
var semanticModel = compilation.GetSemanticModel(syntax.SyntaxTree);
|
|
var operation = syntax switch
|
|
{
|
|
MethodDeclarationSyntax { Body: not null } methodDeclaration =>
|
|
semanticModel.GetOperation(methodDeclaration.Body),
|
|
MethodDeclarationSyntax { ExpressionBody: not null } methodDeclaration =>
|
|
semanticModel.GetOperation(methodDeclaration.ExpressionBody.Expression),
|
|
ConstructorDeclarationSyntax { Body: not null } constructorDeclaration =>
|
|
semanticModel.GetOperation(constructorDeclaration.Body),
|
|
ConstructorDeclarationSyntax { ExpressionBody: not null } constructorDeclaration =>
|
|
semanticModel.GetOperation(constructorDeclaration.ExpressionBody.Expression),
|
|
_ => null
|
|
};
|
|
|
|
if (operation == null)
|
|
continue;
|
|
|
|
foreach (var invocation in operation.DescendantsAndSelf().OfType<IInvocationOperation>())
|
|
yield return invocation;
|
|
}
|
|
}
|
|
|
|
public static INamedTypeSymbol? TryGetCreatedType(IOperation operation)
|
|
{
|
|
var current = operation;
|
|
|
|
while (current is IConversionOperation conversionOperation)
|
|
current = conversionOperation.Operand;
|
|
|
|
return current switch
|
|
{
|
|
IObjectCreationOperation objectCreationOperation => objectCreationOperation.Type as INamedTypeSymbol,
|
|
_ => null
|
|
};
|
|
}
|
|
|
|
public static bool IsServiceCompatible(
|
|
INamedTypeSymbol registeredType,
|
|
INamedTypeSymbol requestedType,
|
|
Compilation compilation)
|
|
{
|
|
if (IsAssignableTo(registeredType, requestedType))
|
|
return true;
|
|
|
|
return compilation.ClassifyConversion(registeredType, requestedType).IsImplicit;
|
|
}
|
|
|
|
public static bool IsOwnershipCompatible(
|
|
INamedTypeSymbol ownerType,
|
|
INamedTypeSymbol registeredType,
|
|
Compilation compilation)
|
|
{
|
|
if (IsAssignableTo(ownerType, registeredType) || IsAssignableTo(registeredType, ownerType))
|
|
return true;
|
|
|
|
return compilation.ClassifyConversion(ownerType, registeredType).IsImplicit ||
|
|
compilation.ClassifyConversion(registeredType, ownerType).IsImplicit;
|
|
}
|
|
|
|
private static IEnumerable<INamedTypeSymbol> EnumerateNestedTypes(INamedTypeSymbol type)
|
|
{
|
|
foreach (var nestedType in type.GetTypeMembers())
|
|
{
|
|
yield return nestedType;
|
|
|
|
foreach (var childType in EnumerateNestedTypes(nestedType))
|
|
yield return childType;
|
|
}
|
|
}
|
|
|
|
private static IEnumerable<INamedTypeSymbol> EnumerateBaseTypes(ITypeSymbol type)
|
|
{
|
|
for (var current = type.BaseType; current != null; current = current.BaseType)
|
|
yield return current;
|
|
}
|
|
|
|
private static bool HasCompatibleSignature(
|
|
IMethodSymbol candidate,
|
|
IMethodSymbol target)
|
|
{
|
|
if (candidate.Parameters.Length != target.Parameters.Length)
|
|
return false;
|
|
|
|
if (candidate.TypeParameters.Length != target.TypeParameters.Length)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|