public override void Initialize(AnalysisContext analysisContext)
{
analysisContext.EnableConcurrentExecution();
analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
analysisContext.RegisterCompilationStartAction(
context =>
{
INamedTypeSymbol?disposableType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemIDisposable);
if (disposableType == null)
{
return;
}
if (!(disposableType.GetMembers(DisposeMethodName).FirstOrDefault() is IMethodSymbol disposeInterfaceMethod))
{
return;
}
INamedTypeSymbol?garbageCollectorType = context.Compilation.GetOrCreateTypeByMetadataName(GarbageCollectorTypeName);
if (garbageCollectorType == null)
{
return;
}
if (!(garbageCollectorType.GetMembers(SuppressFinalizeMethodName).FirstOrDefault() is IMethodSymbol suppressFinalizeMethod))
{
return;
}
var analyzer = new PerCompilationAnalyzer(disposableType, disposeInterfaceMethod, suppressFinalizeMethod);
analyzer.Initialize(context);
});
}
public override void Initialize(AnalysisContext analysisContext)
{
// this is stateless analyzer, can run concurrently
analysisContext.EnableConcurrentExecution();
// this has no meaning on running on generated code which user can't control
analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
analysisContext.RegisterCompilationStartAction(c =>
{
INamedTypeSymbol @string = WellKnownTypes.String(c.Compilation);
INamedTypeSymbol uri = WellKnownTypes.Uri(c.Compilation);
if (@string == null || uri == null)
{
// we don't have required types
return;
}
var analyzer = new PerCompilationAnalyzer(c.Compilation, @string, uri, GetInvocationExpression);
// REVIEW: I need to do this thing because OperationAnalysisContext doesn't give me OwningSymbol
c.RegisterOperationBlockStartAction(sc =>
{
sc.RegisterOperationAction(oc => analyzer.Analyze(oc, sc.OwningSymbol), OperationKind.InvocationExpression);
});
});
}
public override void Initialize(AnalysisContext analysisContext)
{
analysisContext.RegisterCompilationStartAction(
context =>
{
INamedTypeSymbol disposableType = WellKnownTypes.IDisposable(context.Compilation);
if (disposableType == null)
{
return;
}
var disposeInterfaceMethod = disposableType.GetMembers(DisposeMethodName).Single() as IMethodSymbol;
if (disposeInterfaceMethod == null)
{
return;
}
INamedTypeSymbol garbageCollectorType = context.Compilation.GetTypeByMetadataName(GarbageCollectorTypeName);
if (garbageCollectorType == null)
{
return;
}
var suppressFinalizeMethod = garbageCollectorType.GetMembers(SuppressFinalizeMethodName).Single() as IMethodSymbol;
if (suppressFinalizeMethod == null)
{
return;
}
var analyzer = new PerCompilationAnalyzer(context.Compilation, disposableType, disposeInterfaceMethod, suppressFinalizeMethod);
analyzer.Initialize(context);
});
}
public override void Initialize(AnalysisContext analysisContext)
{
// this is stateless analyzer, can run concurrently
analysisContext.EnableConcurrentExecution();
// this has no meaning on running on generated code which user can't control
analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
analysisContext.RegisterCompilationStartAction(c =>
{
INamedTypeSymbol @string = WellKnownTypes.String(c.Compilation);
INamedTypeSymbol uri = WellKnownTypes.Uri(c.Compilation);
if (@string == null || uri == null)
{
// we don't have required types
return;
}
var analyzer = new PerCompilationAnalyzer(c.Compilation, @string, uri, GetInvocationExpression);
// REVIEW: I need to do this thing because OperationAnalysisContext doesn't give me OwningSymbol
c.RegisterOperationBlockStartAction(sc =>
{
sc.RegisterOperationAction(oc => analyzer.Analyze(oc, sc.OwningSymbol), OperationKind.Invocation);
});
});
}
private void PrepareForAnalysis(CompilationStartAnalysisContext context)
{
var perCompilationAnalyzer = new PerCompilationAnalyzer(context.Compilation);
// TODO: Change this from a SyntaxNode action to an operation attribute once attribute application is represented in the
// IOperation tree by Roslyn.
context.RegisterSyntaxNodeAction(perCompilationAnalyzer.AnalyzeAttribute, SyntaxKind.Attribute);
}
private void PrepareForAnalysis(CompilationStartAnalysisContext context)
{
if (context.Compilation.GetBestTypeByMetadataName(TypeNames.CustomMarshallerAttribute) is not null)
{
var perCompilationAnalyzer = new PerCompilationAnalyzer(context.Compilation);
// TODO: Change this from a SyntaxNode action to an operation attribute once attribute application is represented in the
// IOperation tree by Roslyn.
context.RegisterSyntaxNodeAction(perCompilationAnalyzer.AnalyzeAttribute, SyntaxKind.Attribute);
}
}
public override void Initialize(AnalysisContext context)
{
context.EnableConcurrentExecution();
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.RegisterCompilationStartAction(context =>
{
if (context.Compilation.TryGetOrCreateTypeByMetadataName(
WellKnownTypeNames.SystemRuntimeCompilerServicesDisableRuntimeMarshallingAttribute,
out INamedTypeSymbol? disableRuntimeMarshallingAttribute) &&
context.Compilation.Assembly.HasAttribute(disableRuntimeMarshallingAttribute))
{
var perCompilationAnalyzer = new PerCompilationAnalyzer(context.Compilation);
perCompilationAnalyzer.RegisterActions(context);
}
});
}
public override void Initialize(AnalysisContext context)
{
// this is stateless analyzer, can run concurrently
context.EnableConcurrentExecution();
// this has no meaning on running on generated code which user can't control
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.RegisterCompilationStartAction(c =>
{
var attribute = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemAttribute);
if (attribute == null)
{
// we don't have required types
return;
}
var analyzer = new PerCompilationAnalyzer(attribute);
c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Property);
});
}
public override void Initialize(AnalysisContext context)
{
// this is stateless analyzer, can run concurrently
context.EnableConcurrentExecution();
// this has no meaning on running on generated code which user can't control
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.RegisterCompilationStartAction(c =>
{
INamedTypeSymbol?uri = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemUri);
if (uri == null)
{
// we don't have required types
return;
}
var analyzer = new PerCompilationAnalyzer(c.Compilation, uri, GetInvocationExpression);
c.RegisterOperationAction(analyzer.Analyze, OperationKind.Invocation);
});
}
public override void Initialize(AnalysisContext analysisContext)
{
// this is stateless analyzer, can run concurrently
analysisContext.EnableConcurrentExecution();
// this has no meaning on running on generated code which user can't control
analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
analysisContext.RegisterCompilationStartAction(c =>
{
var @string = WellKnownTypes.String(c.Compilation);
var uri = WellKnownTypes.Uri(c.Compilation);
if (@string == null || uri == null)
{
// we don't have required types
return;
}
var analyzer = new PerCompilationAnalyzer(@string, uri);
c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Method);
});
}
public override void Initialize(AnalysisContext analysisContext)
{
// this is stateless analyzer, can run concurrently
analysisContext.EnableConcurrentExecution();
// this has no meaning on running on generated code which user can't control
analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
analysisContext.RegisterCompilationStartAction(c =>
{
var @string = WellKnownTypes.String(c.Compilation);
var attribute = WellKnownTypes.Attribute(c.Compilation);
if (@string == null || attribute == null)
{
// we don't have required types
return;
}
var analyzer = new PerCompilationAnalyzer(@string, attribute);
c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Property);
});
}
public override void Initialize(AnalysisContext analysisContext)
{
analysisContext.EnableConcurrentExecution();
analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
analysisContext.RegisterCompilationStartAction(
context =>
{
INamedTypeSymbol disposableType = WellKnownTypes.IDisposable(context.Compilation);
if (disposableType == null)
{
return;
}
var disposeInterfaceMethod = disposableType.GetMembers(DisposeMethodName).Single() as IMethodSymbol;
if (disposeInterfaceMethod == null)
{
return;
}
INamedTypeSymbol garbageCollectorType = context.Compilation.GetTypeByMetadataName(GarbageCollectorTypeName);
if (garbageCollectorType == null)
{
return;
}
var suppressFinalizeMethod = garbageCollectorType.GetMembers(SuppressFinalizeMethodName).Single() as IMethodSymbol;
if (suppressFinalizeMethod == null)
{
return;
}
var analyzer = new PerCompilationAnalyzer(disposableType, disposeInterfaceMethod, suppressFinalizeMethod);
analyzer.Initialize(context);
});
}
