private void AnalyzeInterpolation(OperationAnalysisContext context)
{
var option = context.GetAnalyzerOptions().PreferSimplifiedInterpolation;
if (!option.Value)
{
// No point in analyzing if the option is off.
return;
}
var interpolation = (IInterpolationOperation)context.Operation;
GetHelpers().UnwrapInterpolation <TInterpolationSyntax, TExpressionSyntax>(
GetVirtualCharService(), GetSyntaxFacts(), interpolation, out _, out var alignment, out _,
out var formatString, out var unnecessaryLocations);
if (alignment == null && formatString == null)
{
return;
}
// The diagnostic itself fades the first unnecessary location, and the remaining locations are passed as
// additional unnecessary locations.
var firstUnnecessaryLocation = unnecessaryLocations[0];
var remainingUnnecessaryLocations = unnecessaryLocations.RemoveAt(0);
context.ReportDiagnostic(DiagnosticHelper.CreateWithLocationTags(
Descriptor,
firstUnnecessaryLocation,
option.Notification.Severity,
additionalLocations: ImmutableArray.Create(interpolation.Syntax.GetLocation()),
additionalUnnecessaryLocations: remainingUnnecessaryLocations));
}
private void AnalyzeOperation(OperationAnalysisContext context)
{
// We only create a diagnostic if the option's value is set to true.
var option = context.GetAnalyzerOptions().PreferExplicitTupleNames;
if (!option.Value)
{
return;
}
var severity = option.Notification.Severity;
if (severity == ReportDiagnostic.Suppress)
{
return;
}
var fieldReferenceOperation = (IFieldReferenceOperation)context.Operation;
var field = fieldReferenceOperation.Field;
if (field.ContainingType.IsTupleType)
{
if (field.CorrespondingTupleField?.Equals(field) == true)
{
var namedField = GetNamedField(field.ContainingType, field, context.CancellationToken);
if (namedField != null)
{
var memberAccessSyntax = fieldReferenceOperation.Syntax;
var nameNode = memberAccessSyntax.ChildNodesAndTokens().Reverse().FirstOrDefault().AsNode();
if (nameNode != null)
{
var properties = ImmutableDictionary <string, string?> .Empty.Add(
nameof(ElementName), namedField.Name);
context.ReportDiagnostic(DiagnosticHelper.Create(
Descriptor,
nameNode.GetLocation(),
severity,
additionalLocations: null,
properties));
}
}
}
}
}
protected sealed override CodeStyleOption2 <bool> GetStylePreference(OperationAnalysisContext context) => context.GetAnalyzerOptions().PreferConditionalExpressionOverAssignment;
private void AnalyzeOperation(OperationAnalysisContext context, IOperation operation, IOperation?instanceOperation)
{
// this is a static reference so we don't care if it's qualified
if (instanceOperation == null)
{
return;
}
// if we're not referencing `this.` or `Me.` (e.g., a parameter, local, etc.)
if (instanceOperation.Kind != OperationKind.InstanceReference)
{
return;
}
// We shouldn't qualify if it is inside a property pattern
if (context.Operation.Parent?.Kind == OperationKind.PropertySubpattern)
{
return;
}
// Initializer lists are IInvocationOperation which if passed to GetApplicableOptionFromSymbolKind
// will incorrectly fetch the options for method call.
// We still want to handle InstanceReferenceKind.ContainingTypeInstance
if ((instanceOperation as IInstanceReferenceOperation)?.ReferenceKind == InstanceReferenceKind.ImplicitReceiver)
{
return;
}
// If we can't be qualified (e.g., because we're already qualified with `base.`), we're done.
if (!CanMemberAccessBeQualified(context.ContainingSymbol, instanceOperation.Syntax))
{
return;
}
// if we can't find a member then we can't do anything. Also, we shouldn't qualify
// accesses to static members.
if (IsStaticMemberOrIsLocalFunction(operation))
{
return;
}
if (instanceOperation.Syntax is not TSimpleNameSyntax simpleName)
{
return;
}
var symbolKind = operation switch
{
IMemberReferenceOperation memberReferenceOperation => memberReferenceOperation.Member.Kind,
IInvocationOperation invocationOperation => invocationOperation.TargetMethod.Kind,
_ => throw ExceptionUtilities.UnexpectedValue(operation),
};
var simplifierOptions = context.GetAnalyzerOptions().GetSimplifierOptions(Simplification);
if (!simplifierOptions.TryGetQualifyMemberAccessOption(symbolKind, out var optionValue))
{
return;
}
var shouldOptionBePresent = optionValue.Value;
var severity = optionValue.Notification.Severity;
if (!shouldOptionBePresent || severity == ReportDiagnostic.Suppress)
{
return;
}
if (!IsAlreadyQualifiedMemberAccess(simpleName))
{
context.ReportDiagnostic(DiagnosticHelper.Create(
Descriptor,
GetLocation(operation),
severity,
additionalLocations: null,
properties: null));
}
}
