private static bool CanRefactor(
SeparatedSyntaxListSelection <ArgumentSyntax> selection,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
for (int i = selection.StartIndex; i <= selection.EndIndex; i++)
{
ArgumentSyntax argument = selection.Items[i];
NameColonSyntax nameColon = argument.NameColon;
if (nameColon == null ||
nameColon.IsMissing)
{
IParameterSymbol parameterSymbol = semanticModel.DetermineParameter(
argument,
allowParams: false,
cancellationToken: cancellationToken);
if (parameterSymbol != null)
{
return(true);
}
}
}
return(false);
}
private void ReportDiagnosticsIfNeeded(NameColonSyntax nameColon, SyntaxNodeAnalysisContext context, AnalyzerOptions options, SyntaxTree syntaxTree, CancellationToken cancellationToken)
{
if (!nameColon.Parent.IsKind(SyntaxKind.Argument, out ArgumentSyntax? argument))
{
return;
}
var parseOptions = (CSharpParseOptions)syntaxTree.Options;
var preference = options.GetOption(
CodeStyleOptions.PreferInferredTupleNames, context.Compilation.Language, syntaxTree, cancellationToken);
if (!preference.Value ||
!CSharpInferredMemberNameReducer.CanSimplifyTupleElementName(argument, parseOptions))
{
return;
}
// Create a normal diagnostic
context.ReportDiagnostic(
DiagnosticHelper.Create(
Descriptor,
nameColon.GetLocation(),
preference.Notification.Severity,
additionalLocations: null,
properties: null));
// Also fade out the part of the name-colon syntax
RoslynDebug.AssertNotNull(UnnecessaryWithoutSuggestionDescriptor);
var fadeSpan = TextSpan.FromBounds(nameColon.Name.SpanStart, nameColon.ColonToken.Span.End);
context.ReportDiagnostic(
Diagnostic.Create(
UnnecessaryWithoutSuggestionDescriptor,
syntaxTree.GetLocation(fadeSpan)));
}
private void ReportDiagnosticsIfNeeded(NameColonSyntax nameColon, SyntaxNodeAnalysisContext context, OptionSet optionSet, SyntaxTree syntaxTree)
{
if (!nameColon.IsParentKind(SyntaxKind.Argument))
{
return;
}
var argument = (ArgumentSyntax)nameColon.Parent;
var parseOptions = (CSharpParseOptions)syntaxTree.Options;
if (!optionSet.GetOption(CSharpCodeStyleOptions.PreferInferredTupleNames).Value ||
!CSharpInferredMemberNameReducer.CanSimplifyTupleElementName(argument, parseOptions))
{
return;
}
// Create a normal diagnostic
context.ReportDiagnostic(
Diagnostic.Create(GetDescriptorWithSeverity(
optionSet.GetOption(CSharpCodeStyleOptions.PreferInferredTupleNames).Notification.Value),
nameColon.GetLocation()));
// Also fade out the part of the name-colon syntax
var fadeSpan = TextSpan.FromBounds(nameColon.Name.SpanStart, nameColon.ColonToken.Span.End);
context.ReportDiagnostic(
Diagnostic.Create(
UnnecessaryWithoutSuggestionDescriptor,
syntaxTree.GetLocation(fadeSpan)));
}
private Doc PrintNameColonSyntax(NameColonSyntax node)
{
return(Concat(
this.PrintSyntaxToken(node.Name.Identifier),
this.PrintSyntaxToken(node.ColonToken, " ")
));
}
private void ReportDiagnosticsIfNeeded(NameColonSyntax nameColon, SyntaxNodeAnalysisContext context, AnalyzerOptions options, SyntaxTree syntaxTree, CancellationToken cancellationToken)
{
if (!nameColon.Parent.IsKind(SyntaxKind.Argument, out ArgumentSyntax? argument))
{
return;
}
var parseOptions = (CSharpParseOptions)syntaxTree.Options;
var preference = options.GetOption(
CodeStyleOptions2.PreferInferredTupleNames, context.Compilation.Language, syntaxTree, cancellationToken);
if (!preference.Value ||
!CSharpInferredMemberNameSimplifier.CanSimplifyTupleElementName(argument, parseOptions))
{
return;
}
// Create a normal diagnostic
var fadeSpan = TextSpan.FromBounds(nameColon.Name.SpanStart, nameColon.ColonToken.Span.End);
context.ReportDiagnostic(
DiagnosticHelper.CreateWithLocationTags(
Descriptor,
nameColon.GetLocation(),
preference.Notification.Severity,
additionalLocations: ImmutableArray <Location> .Empty,
additionalUnnecessaryLocations: ImmutableArray.Create(syntaxTree.GetLocation(fadeSpan))));
}
public static Doc Print(NameColonSyntax node)
{
return(Doc.Concat(
Token.Print(node.Name.Identifier),
Token.PrintWithSuffix(node.ColonToken, " ")
));
}
public override void AddChildren()
{
Kind = Node.Kind();
_nameColon = ((ArgumentSyntax)Node).NameColon;
_nameColonIsChanged = false;
_refOrOutKeyword = ((ArgumentSyntax)Node).RefOrOutKeyword;
_refOrOutKeywordIsChanged = false;
_expression = ((ArgumentSyntax)Node).Expression;
_expressionIsChanged = false;
}
public override void AddChildren()
{
Kind = Node.Kind();
_nameEquals = ((AttributeArgumentSyntax)Node).NameEquals;
_nameEqualsIsChanged = false;
_nameColon = ((AttributeArgumentSyntax)Node).NameColon;
_nameColonIsChanged = false;
_expression = ((AttributeArgumentSyntax)Node).Expression;
_expressionIsChanged = false;
}
public override void VisitNameColon(NameColonSyntax node)
{
if (!PreVisit(node))
{
return;
}
node.Name?.Accept(this);
base.VisitNameColon(node);
PostVisit(node);
}
private static bool CanRefactor(SeparatedSyntaxListSelection <ArgumentSyntax> selection)
{
for (int i = 0; i < selection.Count; i++)
{
NameColonSyntax nameColon = selection[i].NameColon;
if (nameColon?.IsMissing == false)
{
return(true);
}
}
return(false);
}
private static bool CanRefactor(SeparatedSyntaxListSelection <ArgumentSyntax> selection)
{
for (int i = selection.StartIndex; i <= selection.EndIndex; i++)
{
NameColonSyntax nameColon = selection.Items[i].NameColon;
if (nameColon?.IsMissing == false)
{
return(true);
}
}
return(false);
}
private SubpatternSyntax ParseSubpatternElement()
{
NameColonSyntax nameColon = null;
if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken && this.PeekToken(1).Kind == SyntaxKind.ColonToken)
{
var name = this.ParseIdentifierName();
var colon = this.EatToken(SyntaxKind.ColonToken);
nameColon = _syntaxFactory.NameColon(name, colon);
}
var pattern = ParsePattern(Precedence.Ternary);
return(this._syntaxFactory.Subpattern(nameColon, pattern));
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitNameColon(NameColonSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitNameColon(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitNameColon(NameColonSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitNameColon(node);
}
private static int TryDetermineParameterIndex(NameColonSyntax argumentNameColon, IMethodSymbol method)
{
var name = argumentNameColon.Name.Identifier.ValueText;
return(method.Parameters.IndexOf(p => p.Name == name));
}
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
{
// Note: According to specification, argument is either at its position (as declared), or it is a named argument
// That is, named argument specification can appear only after all fixed arguments have been specified
// Considers:
// foo(a: 1, b: 2) -> foo(b: 2)
// foo(b: 2, a: 1) -> foo(b: 2)
// foo(1, b: 2) -> foo(b: 2)
// foo(1, 2) -> foo(2)
// foo(a: 1, b: foo(a: 1, b: 2))
// Check does invocation refer to updated method
ISymbol referencedMethod = this.model.GetSymbolInfo(node.Expression, this.cancellationToken).Symbol;
if (referencedMethod != null && referencedMethod.Equals(this.methodSymbol))
{
SeparatedSyntaxList <ArgumentSyntax> newArgumentSeparatedList = Syntax.SeparatedList <ArgumentSyntax>();
// Check is the removed parameter referenced by name within method invocation, e.g. foo(1, 2, >a:2<)
// Note: Must be a direct child! Not nested descendant like foo(a: foo(>a:<1)) !
NameColonSyntax namedArgument = null;
foreach (ArgumentSyntax argument in node.ArgumentList.Arguments)
{
namedArgument = argument.ChildNodes()
.OfType <NameColonSyntax>()
.FirstOrDefault(
(n) =>
{
ISymbol nameSymbol = this.model.GetSymbolInfo(n.Identifier).Symbol;
return(nameSymbol != null && nameSymbol.Equals(this.parameterSymbol));
});
if (namedArgument != null)
{
break;
}
}
int argumentOrder = 0;
foreach (ArgumentSyntax argument in node.ArgumentList.Arguments)
{
if (namedArgument != null && argument.ChildNodes().Contains(namedArgument))
{
// Remove the named argument. That is, do not add to new argument list
}
else if (namedArgument == null && argumentOrder == this.order)
{
// Remove the named argument. That is, do not add to new argument list
}
else
{
// Some other argument. Process it recursively.
// Considers:
// foo(a: 1, b: foo(a: 1, b: 2))
ArgumentSyntax processedArgument = (ArgumentSyntax)base.VisitArgument(argument);
if (processedArgument != null)
{
newArgumentSeparatedList = newArgumentSeparatedList.Add(processedArgument);
}
}
++argumentOrder;
}
InvocationExpressionSyntax newInvocation = node.WithArgumentList(Syntax.ArgumentList(newArgumentSeparatedList))
.WithAdditionalAnnotations(CodeAnnotations.Formatting);
return(newInvocation);
}
return(base.VisitInvocationExpression(node));
}
public override void VisitNameColon(NameColonSyntax node)
{
throw new NotImplementedException();
}
public override void VisitNameColon(NameColonSyntax node)
{
node.Name?.Accept(this);
base.VisitNameColon(node);
}
public override void VisitNameColon(NameColonSyntax node)
{
//base.VisitNameColon(node);
}
public TameNameColonSyntax(NameColonSyntax node)
{
Node = node;
AddChildren();
}
public void VisitNameColon(NameColonSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
node.Name.Accept(this);
_writer.WriteSyntax(Syntax.Colon);
_writer.WriteSpace();
}
public ArgumentSyntax Update(NameColonSyntax nameColon, SyntaxToken outKeyword, VariableDeclarationSyntax declaration)
{
return this.Update(nameColon, outKeyword, (CSharpSyntaxNode)declaration);
}
public ArgumentSyntax Update(NameColonSyntax nameColon, SyntaxToken refOrOutKeyword, ExpressionSyntax expression)
{
return this.Update(nameColon, refOrOutKeyword, (CSharpSyntaxNode)expression) ;
}
private IEnumerable<ITypeSymbol> InferTypeInNameColon(NameColonSyntax nameColon, SyntaxToken previousToken)
{
if (previousToken != nameColon.ColonToken)
{
// Must follow the colon token.
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
var argumentSyntax = nameColon.Parent as ArgumentSyntax;
if (argumentSyntax != null)
{
return InferTypeInArgument(argumentSyntax);
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
public override Evaluation VisitNameColon(NameColonSyntax node)
{
node.Name?.Accept <Evaluation>(this);
return(base.VisitNameColon(node));
}
// // Summary: // Called when the visitor visits a NameColonSyntax node. public virtual void VisitNameColon(NameColonSyntax node);
public static int IndexOfFirstFixableParameter(
BaseArgumentListSyntax argumentList,
SeparatedSyntaxList <ArgumentSyntax> arguments,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
int firstIndex = -1;
for (int i = 0; i < arguments.Count; i++)
{
if (arguments[i].NameColon != null)
{
firstIndex = i;
break;
}
}
if (firstIndex != -1 &&
firstIndex != arguments.Count - 1)
{
ISymbol symbol = semanticModel.GetSymbol(argumentList.Parent, cancellationToken);
if (symbol != null)
{
ImmutableArray <IParameterSymbol> parameters = symbol.ParametersOrDefault();
Debug.Assert(!parameters.IsDefault, symbol.Kind.ToString());
if (!parameters.IsDefault &&
parameters.Length == arguments.Count)
{
for (int i = firstIndex; i < arguments.Count; i++)
{
ArgumentSyntax argument = arguments[i];
NameColonSyntax nameColon = argument.NameColon;
if (nameColon == null)
{
break;
}
if (!string.Equals(
nameColon.Name.Identifier.ValueText,
parameters[i].Name,
StringComparison.Ordinal))
{
int fixableIndex = i;
i++;
while (i < arguments.Count)
{
if (arguments[i].NameColon == null)
{
break;
}
i++;
}
return(fixableIndex);
}
}
}
}
}
return(-1);
}
public override SyntaxNode VisitNameColon(NameColonSyntax node)
{
node = (NameColonSyntax)base.VisitNameColon(node);
Classes.Add(node);
return node;
}
public override LuaSyntaxNode VisitNameColon(NameColonSyntax node)
{
throw new InvalidOperationException();
}
public override void VisitNameColon(NameColonSyntax node)
{
}
public override void VisitNameColon(NameColonSyntax node)
{
throw new NotSupportedException();
}
