Skip to content
Merged
Show file tree
Hide file tree
Changes from 5 commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions src/Orleans.Analyzers/AnalyzerReleases.Unshipped.md
Original file line number Diff line number Diff line change
Expand Up @@ -4,6 +4,7 @@

Rule ID | Category | Severity | Notes
--------|----------|----------|-------
ORLEANS0026 | Usage | Error | Invalid invokable base type mapping
ORLEANS0014 | Usage | Warning | ConfigureAwaitAnalyzer, Grain code should not use ConfigureAwait(false) or ConfigureAwait without ContinueOnCapturedContext
ORLEANS0016 | Orleans.Versioning | Warning | GrainInterfaceVersionAnalyzer, Grain interface not declared in OrleansContracts.txt
ORLEANS0017 | Orleans.Versioning | Warning | GrainInterfaceVersionAnalyzer, Grain interface version mismatch between code and file
Expand Down
Original file line number Diff line number Diff line change
@@ -1,23 +1,33 @@
using System;
using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
using Orleans.CodeGenerator;

namespace Orleans.Analyzers
{
[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class GrainInterfaceMethodReturnTypeDiagnosticAnalyzer : DiagnosticAnalyzer
{
public const string DiagnosticId = "ORLEANS0009";
public const string Title = "Grain interfaces methods must return a compatible type";
public const string MessageFormat = $"Grain interfaces methods must return a compatible type, such as Task, Task<T>, ValueTask, ValueTask<T>, or void";
public const string Title = "Grain interface methods must return a registered grain-call return type";
public const string MessageFormat = "Grain interface methods must return a registered grain-call return type";
public const string Category = "Usage";
public const string InvalidMappingDiagnosticId = "ORLEANS0026";

private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, Category, DiagnosticSeverity.Error, isEnabledByDefault: true);
private static readonly DiagnosticDescriptor InvalidMappingRule = new(
InvalidMappingDiagnosticId,
"Invalid invokable base type mapping",
"{0}",
Category,
DiagnosticSeverity.Error,
isEnabledByDefault: true);

public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = [Rule];
public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = [Rule, InvalidMappingRule];

public override void Initialize(AnalysisContext context)
{
Expand All @@ -30,29 +40,19 @@ public override void Initialize(AnalysisContext context)
return;
}

var builder = ImmutableHashSet.CreateBuilder<ITypeSymbol>(SymbolEqualityComparer.Default);

AddIfNotNull(builder, context.Compilation.GetTypeByMetadataName("System.Threading.Tasks.Task"));
AddIfNotNull(builder, context.Compilation.GetTypeByMetadataName("System.Threading.Tasks.Task`1"));
AddIfNotNull(builder, context.Compilation.GetTypeByMetadataName("System.Threading.Tasks.ValueTask"));
AddIfNotNull(builder, context.Compilation.GetTypeByMetadataName("System.Threading.Tasks.ValueTask`1"));
AddIfNotNull(builder, context.Compilation.GetTypeByMetadataName("System.Collections.Generic.IAsyncEnumerable`1"));
AddIfNotNull(builder, context.Compilation.GetSpecialType(SpecialType.System_Void));

context.RegisterSymbolAction(context => AnalyzeMethod(context, baseInterface, builder.ToImmutable()), SymbolKind.Method);
var resolver = new InvokableBaseTypeResolver(context.Compilation);
var generateMethodSerializersAttribute = context.Compilation.GetTypeByMetadataName("Orleans.GenerateMethodSerializersAttribute");
context.RegisterSymbolAction(
context => AnalyzeMethod(context, baseInterface, generateMethodSerializersAttribute, resolver),
SymbolKind.Method);
});


static void AddIfNotNull(ImmutableHashSet<ITypeSymbol>.Builder builder, INamedTypeSymbol? symbol)
{
if (symbol is not null)
{
builder.Add(symbol);
}
}
}

private static void AnalyzeMethod(SymbolAnalysisContext context, INamedTypeSymbol baseInterface, ImmutableHashSet<ITypeSymbol> supportedTypes)
private static void AnalyzeMethod(
SymbolAnalysisContext context,
INamedTypeSymbol baseInterface,
INamedTypeSymbol? generateMethodSerializersAttribute,
InvokableBaseTypeResolver resolver)
{
var symbol = (IMethodSymbol)context.Symbol;

Expand All @@ -72,11 +72,64 @@ private static void AnalyzeMethod(SymbolAnalysisContext context, INamedTypeSymbo
}
}

if (!isIAddressableInterface || supportedTypes.Contains(symbol.ReturnType.OriginalDefinition))
if (!isIAddressableInterface)
return;

var proxyBaseTypes = GetProxyBaseTypes(symbol.ContainingType, generateMethodSerializersAttribute);
ResolverDiagnostic? mappingDiagnostic = null;
foreach (var proxyBaseType in proxyBaseTypes)
{
if (resolver.TryResolve(proxyBaseType, symbol, out _, out var diagnostic))
{
return;
}

if (diagnostic is { Kind: ResolverDiagnosticKind.InvalidMapping })
{
mappingDiagnostic ??= diagnostic;
}
}

var syntaxReference = symbol.DeclaringSyntaxReferences;
if (mappingDiagnostic is not null)
{
context.ReportDiagnostic(Diagnostic.Create(
InvalidMappingRule,
mappingDiagnostic.Location ?? Location.Create(syntaxReference[0].SyntaxTree, syntaxReference[0].Span),
mappingDiagnostic.Message));
return;
}

context.ReportDiagnostic(Diagnostic.Create(Rule, Location.Create(syntaxReference[0].SyntaxTree, syntaxReference[0].Span)));
}

private static ImmutableArray<INamedTypeSymbol> GetProxyBaseTypes(
INamedTypeSymbol interfaceType,
INamedTypeSymbol? generateMethodSerializersAttribute)
{
if (generateMethodSerializersAttribute is null)
{
return [];
}

var result = ImmutableArray.CreateBuilder<INamedTypeSymbol>();
foreach (var candidate in interfaceType.AllInterfaces.Add(interfaceType))
{
foreach (var attribute in candidate.GetAttributes())
{
if (SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, generateMethodSerializersAttribute)
&& attribute.ConstructorArguments.Length > 0
&& attribute.ConstructorArguments[0].Value is INamedTypeSymbol proxyBaseType
&& !result.Any(existing => SymbolEqualityComparer.Default.Equals(existing, proxyBaseType)))
{
result.Add(proxyBaseType.OriginalDefinition);
}
}
}

return [.. result.OrderBy(
static type => type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat),
StringComparer.Ordinal)];
}
}
}
4 changes: 4 additions & 0 deletions src/Orleans.Analyzers/Orleans.Analyzers.csproj
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,10 @@
<PackageReference Update="NETStandard.Library" PrivateAssets="all" />
</ItemGroup>

<ItemGroup>
<Compile Include="..\Orleans.CodeGenerator.Shared\InvokableBaseTypeResolver.cs" Link="InvokableBaseTypeResolver.cs" />
</ItemGroup>

<ItemGroup>
<None Include="$(OutputPath)\$(AssemblyName).dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
<AdditionalFiles Include="AnalyzerReleases.Shipped.md" />
Expand Down
Loading
Loading