private static ProgramState RemoveCollectionConstraintsFromArguments(BaseArgumentListSyntax argumentList,
ProgramState programState)
{
return(GetArgumentSymbolicValues(argumentList, programState)
.Aggregate(programState,
(state, value) => state.RemoveConstraint(value, CollectionCapacityConstraint.Empty)));
}
private static IParameterSymbol DetermineParameterSymbol(
ISymbol symbol,
ArgumentSyntax argument,
BaseArgumentListSyntax argumentList)
{
ImmutableArray <IParameterSymbol> parameters = GetParameters(symbol);
string name = argument.NameColon?.Name?.Identifier.ValueText;
if (name != null)
{
return(parameters.FirstOrDefault(f => f.Name == name));
}
int index = argumentList.Arguments.IndexOf(argument);
if (index >= 0 &&
index < parameters.Length)
{
return(parameters[index]);
}
IParameterSymbol lastParameter = parameters.LastOrDefault();
if (lastParameter?.IsParams == true)
{
return(lastParameter);
}
return(null);
}
public void PopulateArguments(TextWriter trapFile, BaseArgumentListSyntax args, int child)
{
foreach (var arg in args.Arguments)
{
PopulateArgument(trapFile, arg, child++);
}
}
private static ITypeSymbol DetermineParameterType(
ISymbol symbol,
ArgumentSyntax argument,
BaseArgumentListSyntax argumentList)
{
IParameterSymbol parameterSymbol = DetermineParameterSymbol(symbol, argument, argumentList);
if (parameterSymbol != null)
{
ITypeSymbol typeSymbol = parameterSymbol.Type;
if (parameterSymbol.IsParams &&
typeSymbol.IsArrayType())
{
return(((IArrayTypeSymbol)typeSymbol).ElementType);
}
else
{
return(typeSymbol);
}
}
else
{
return(null);
}
}
private static bool CheckParameters(
BaseParameterListSyntax parameterList,
BaseArgumentListSyntax argumentList,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
SeparatedSyntaxList <ParameterSyntax> parameters = parameterList.Parameters;
SeparatedSyntaxList <ArgumentSyntax> arguments = argumentList.Arguments;
if (parameters.Count != arguments.Count)
{
return(false);
}
for (int i = 0; i < parameters.Count; i++)
{
if (semanticModel
.GetDeclaredSymbol(parameters[i], cancellationToken)?
.Equals(GetParameterSymbol(arguments[i].Expression, semanticModel, cancellationToken)) != true)
{
return(false);
}
}
return(true);
}
private ISet <string> GetExistingNamedParameters(BaseArgumentListSyntax argumentList, int position)
{
var existingArguments = argumentList.Arguments.Where(a => a.Span.End <= position && a.NameColon != null)
.Select(a => a.NameColon.Name.Identifier.ValueText);
return(existingArguments.ToSet());
}
public void PopulateArguments(BaseArgumentListSyntax args, int child)
{
foreach (var arg in args.Arguments)
{
PopulateArgument(arg, child++);
}
}
internal static SignatureHelpState GetSignatureHelpState(BaseArgumentListSyntax argumentList, int position)
{
return CommonSignatureHelpUtilities.GetSignatureHelpState(
argumentList, position,
s_getBaseArgumentListOpenToken,
s_getBaseArgumentListCloseToken,
s_getBaseArgumentListArgumentsWithSeparators,
s_getBaseArgumentListNames);
}
protected override Symbol MakeOutVariable(DeclarationExpressionSyntax node, BaseArgumentListSyntax argumentListSyntax, SyntaxNode nodeToBind)
{
var designation = node.VariableDesignation();
return(GlobalExpressionVariable.Create(
_containingType, _modifiers, node.Type(),
designation.Identifier.ValueText, designation, designation.Identifier.GetLocation(),
_containingFieldOpt, nodeToBind));
}
internal static SignatureHelpState GetSignatureHelpState(BaseArgumentListSyntax argumentList, int position)
{
return(CommonSignatureHelpUtilities.GetSignatureHelpState(
argumentList, position,
s_getBaseArgumentListOpenToken,
s_getBaseArgumentListCloseToken,
s_getBaseArgumentListArgumentsWithSeparators,
s_getBaseArgumentListNames));
}
internal static SignatureHelpState?GetSignatureHelpState(BaseArgumentListSyntax argumentList, int position, int parameterIndex)
{
var result = GetSignatureHelpState(argumentList, position);
if (result is not null && parameterIndex >= 0)
{
result.ArgumentIndex = parameterIndex;
}
return(result);
}
// Private Methods
FunctionArgument[] _internalVisitArgumentList(BaseArgumentListSyntax list)
{
if (list == null)
{
return(new FunctionArgument[0]);
}
var aa = list.Arguments.Select(i => Visit(i) as FunctionArgument).ToArray();
#if DEBUG
Debug.Assert(aa.Where(i => i == null).Count() == 0);
#endif
return(aa);
}
private static ITypeSymbol DetermineParameterType(
ISymbol symbol,
ArgumentSyntax argument,
BaseArgumentListSyntax argumentList)
{
IParameterSymbol parameterSymbol = DetermineParameterSymbol(symbol, argument, argumentList);
if (parameterSymbol != null)
{
return(GetParameterType(parameterSymbol));
}
return(null);
}
public static SyntaxToken GetOpenToken(this BaseArgumentListSyntax node)
{
if (node != null)
{
switch (node.Kind())
{
case SyntaxKind.ArgumentList:
return(((ArgumentListSyntax)node).OpenParenToken);
case SyntaxKind.BracketedArgumentList:
return(((BracketedArgumentListSyntax)node).OpenBracketToken);
}
}
return(default);
public static BaseArgumentListSyntax WithArguments(
this BaseArgumentListSyntax node, SeparatedSyntaxList <ArgumentSyntax> arguments)
{
switch (node.Kind())
{
case SyntaxKind.ArgumentList:
return(((ArgumentListSyntax)node).WithArguments(arguments));
case SyntaxKind.BracketedArgumentList:
return(((BracketedArgumentListSyntax)node).WithArguments(arguments));
default:
throw new InvalidOperationException();
}
}
private VariableReference[] HandleParameters(BaseArgumentListSyntax argumentListSyntax)
{
var variableReferenceList = new List <VariableReference>();
foreach (var argument in argumentListSyntax.Arguments)
{
var argumentResult = Visit(argument.Expression);
variableReferenceList.Add(new VariableReference
{
Type = VariableTypes.Value,
Value = argumentResult.Value,
ValueType = argumentResult.Type,
});
}
return(variableReferenceList.ToArray());
}
public static SyntaxToken GetCloseToken(this BaseArgumentListSyntax node)
{
if (node != null)
{
switch (node.CSharpKind())
{
case SyntaxKind.ArgumentList:
return(((ArgumentListSyntax)node).CloseParenToken);
case SyntaxKind.BracketedArgumentList:
return(((BracketedArgumentListSyntax)node).CloseBracketToken);
}
}
return(default(SyntaxToken));
}
private static IEnumerable <SymbolicValue> GetArgumentSymbolicValues(BaseArgumentListSyntax argumentList,
ProgramState programState)
{
if (argumentList?.Arguments == null)
{
return(Enumerable.Empty <SymbolicValue>());
}
var tempProgramState = programState;
return(argumentList.Arguments
.Where(HasAssociatedSymbolicValue)
.Select(argument =>
{
// We have side effect here, but it is harmless, we only need the symbolic values
tempProgramState = tempProgramState.PopValue(out var value);
return value;
}));
}
/// <summary>
/// Get from argument (names) the needed argument values
/// </summary>
private static IEnumerable <ExpressionSyntax> GetArgumentValuesList(BaseArgumentListSyntax argumentList, IDictionary <string, ExpressionSyntax> argumentValues)
{
foreach (var arg in argumentList.Arguments)
{
var key = arg.ToFullString();
if (argumentValues.TryGetValue(key, out var value))
{
yield return(value);
}
else
{
// Not defined in old call, so use the value
var staticArg = SyntaxFactory.ParseArgumentList(key).Arguments.FirstOrDefault();
if (staticArg != null)
{
yield return(staticArg.Expression);
}
}
}
}
private static TypeSyntax GetSingleType(ExpressionSyntax expression, BaseArgumentListSyntax argumentListSyntax)
{
if (expression is GenericNameSyntax name)
{
return(name.TypeArgumentList.Arguments.Single());
}
if (expression is MemberAccessExpressionSyntax memberAccess && memberAccess.Name is GenericNameSyntax genericNameSyntax)
{
return(genericNameSyntax.TypeArgumentList.Arguments.Single());
}
var argument = argumentListSyntax.Arguments.Single().Expression;
if (argument is TypeOfExpressionSyntax typeofExpression)
{
return(typeofExpression.Type);
}
throw new InvalidOperationException($"Expected either TypeInfo.From<T>() or TypeInfo.From(typeof(T)), but found: {argumentListSyntax.Parent}");
}
private static void CheckIfCommasAreAtTheSameLineAsThePreviousParameter(SyntaxNodeAnalysisContext context, List <SyntaxToken> commas,
BaseArgumentListSyntax parameterListSyntax)
{
for (int index = 0; index < commas.Count; index++)
{
var comma = commas[index];
if (parameterListSyntax.Arguments.Count <= index)
{
return;
}
var previousParameter = parameterListSyntax.Arguments[index];
var commaLocation = comma.GetLocation();
if (commaLocation.GetLineSpan().StartLinePosition.Line !=
previousParameter.GetLocation().GetLineSpan().EndLinePosition.Line)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, commaLocation));
}
}
}
/// <summary>
/// Copied from Roslyn source code. Determines the parameter for a given argument
/// </summary>
/// <param name="argumentList"></param>
/// <param name="argument"></param>
/// <param name="symbol"></param>
/// <returns></returns>
public IParameterSymbol DetermineParameter(BaseArgumentListSyntax argumentList, ArgumentSyntax argument, IMethodSymbol symbol)
{
var parameters = symbol.Parameters;
// Handle named argument
if (argument.NameColon != null && !argument.NameColon.IsMissing)
{
var name = argument.NameColon.Name.Identifier.ValueText;
return(parameters.FirstOrDefault(p => p.Name == name));
}
// Handle positional argument
var index = argumentList.Arguments.IndexOf(argument);
if (index < 0)
{
return(null);
}
if (index < parameters.Length)
{
return(parameters[index]);
}
// Handle Params
var lastParameter = parameters.LastOrDefault();
if (lastParameter == null)
{
return(null);
}
if (lastParameter.IsParams)
{
return(lastParameter);
}
return(null);
}
private void VisitDeclarationExpressionDesignation(
DeclarationExpressionSyntax node,
VariableDesignationSyntax designation,
BaseArgumentListSyntax argumentListSyntaxOpt
)
{
switch (designation.Kind())
{
case SyntaxKind.SingleVariableDesignation:
TFieldOrLocalSymbol variable = MakeDeclarationExpressionVariable(
node,
(SingleVariableDesignationSyntax)designation,
argumentListSyntaxOpt,
_nodeToBind
);
if ((object)variable != null)
{
_variablesBuilder.Add(variable);
}
break;
case SyntaxKind.DiscardDesignation:
break;
case SyntaxKind.ParenthesizedVariableDesignation:
foreach (
VariableDesignationSyntax nested in (
(ParenthesizedVariableDesignationSyntax)designation
).Variables
)
{
VisitDeclarationExpressionDesignation(node, nested, argumentListSyntaxOpt);
}
break;
default:
throw ExceptionUtilities.UnexpectedValue(designation.Kind());
}
}
private static ITypeSymbol DetermineParameterType(
ISymbol symbol,
ArgumentSyntax argument,
BaseArgumentListSyntax argumentList)
{
IParameterSymbol parameterSymbol = DetermineParameterSymbol(symbol, argument, argumentList);
if (parameterSymbol == null)
{
return(null);
}
RefKind refKind = parameterSymbol.RefKind;
if (refKind == RefKind.Out)
{
if (argument.RefOrOutKeyword.Kind() != SyntaxKind.OutKeyword)
{
return(null);
}
}
else if (refKind == RefKind.Ref)
{
if (argument.RefOrOutKeyword.Kind() != SyntaxKind.RefKeyword)
{
return(null);
}
}
ITypeSymbol typeSymbol = parameterSymbol.Type;
if (parameterSymbol.IsParams &&
typeSymbol is IArrayTypeSymbol arrayType)
{
return(arrayType.ElementType);
}
return(typeSymbol);
}
private static async Task <Document> OrderNamedArgumentsAsync(
Document document,
BaseArgumentListSyntax argumentList,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ImmutableArray <IParameterSymbol> parameters = semanticModel
.GetSymbol(argumentList.Parent, cancellationToken)
.ParametersOrDefault();
SeparatedSyntaxList <ArgumentSyntax> arguments = argumentList.Arguments;
int firstIndex = OrderNamedArgumentsAnalyzer.IndexOfFirstFixableParameter(argumentList, arguments, semanticModel, cancellationToken);
SeparatedSyntaxList <ArgumentSyntax> newArguments = arguments;
for (int i = firstIndex; i < arguments.Count; i++)
{
IParameterSymbol parameter = parameters[i];
int index = arguments.IndexOf(f => f.NameColon?.Name.Identifier.ValueText == parameter.Name);
Debug.Assert(index != -1, parameter.Name);
if (index != -1 &&
index != i)
{
newArguments = newArguments.ReplaceAt(i, arguments[index]);
}
}
BaseArgumentListSyntax newNode = argumentList
.WithArguments(newArguments)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(argumentList, newNode, cancellationToken).ConfigureAwait(false));
}
private static void AnalyzeArgumentList(SyntaxNodeAnalysisContext context, BaseArgumentListSyntax argumentListSyntax)
{
if (argumentListSyntax == null ||
argumentListSyntax.Arguments.Count < 2)
{
return;
}
var previousLine = argumentListSyntax.Arguments[0].GetLineSpan().EndLinePosition.Line;
for (int i = 1; i < argumentListSyntax.Arguments.Count; i++)
{
var currentArgument = argumentListSyntax.Arguments[i];
var lineSpan = currentArgument.GetLineSpan();
var currentLine = lineSpan.StartLinePosition.Line;
if (currentLine - previousLine > 1)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, currentArgument.GetLocation()));
}
previousLine = lineSpan.EndLinePosition.Line;
}
}
private static void AnalyzeArgumentList(SyntaxNodeAnalysisContext context, BaseArgumentListSyntax argumentListSyntax)
{
if (argumentListSyntax == null ||
argumentListSyntax.Arguments.Count < 2)
{
return;
}
var previousArgumentLine = argumentListSyntax.Arguments[0].GetLineSpan().EndLinePosition.Line;
for (int i = 1; i < argumentListSyntax.Arguments.Count; i++)
{
var currentArgument = argumentListSyntax.Arguments[i];
int currentArgumentStartLine;
int currentArgumentEndLine;
if (currentArgument.HasLeadingTrivia && IsValidTrivia(currentArgument.GetLeadingTrivia()))
{
var lineSpan = currentArgument.SyntaxTree.GetLineSpan(currentArgument.FullSpan);
currentArgumentStartLine = lineSpan.StartLinePosition.Line;
currentArgumentEndLine = lineSpan.EndLinePosition.Line;
}
else
{
var lineSpan = currentArgument.GetLineSpan();
currentArgumentStartLine = lineSpan.StartLinePosition.Line;
currentArgumentEndLine = lineSpan.EndLinePosition.Line;
}
if (currentArgumentStartLine - previousArgumentLine > 1)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, currentArgument.GetLocation()));
}
previousArgumentLine = currentArgumentEndLine;
}
}
private static void HandleBaseArgumentListSyntax(SyntaxNodeAnalysisContext context, BaseArgumentListSyntax argumentList)
{
if (argumentList != null && !argumentList.IsMissing)
{
var arguments = argumentList.Arguments;
if (arguments.Count > 1)
{
CheckIfCommasAreAtTheSameLineAsThePreviousParameter(context, arguments.GetWithSeparators());
}
}
}
public BaseArgumentListTranslation(BaseArgumentListSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Arguments = syntax.Arguments.Get<ArgumentSyntax, ArgumentTranslation>(this);
}
private static void HandleBaseArgumentListSyntax(SyntaxNodeAnalysisContext context, BaseArgumentListSyntax argumentList)
{
if (argumentList != null && !argumentList.IsMissing)
{
var arguments = argumentList.Arguments;
if (arguments.Count > 1)
{
CheckIfCommasAreAtTheSameLineAsThePreviousParameter(context, arguments.GetWithSeparators());
}
}
}
internal static TextSpan GetSignatureHelpSpan(BaseArgumentListSyntax argumentList)
{
return CommonSignatureHelpUtilities.GetSignatureHelpSpan(argumentList, s_getBaseArgumentListCloseToken);
}
/// <summary> /// Make a variable for a declaration expression other than a deconstruction left-hand-side. The only /// other legal place for a declaration expression today is an out variable declaration; this method /// handles that and the error cases as well. /// </summary> protected abstract TFieldOrLocalSymbol MakeDeclarationExpressionVariable(DeclarationExpressionSyntax node, BaseArgumentListSyntax argumentListSyntax, SyntaxNode nodeToBind);
private static void AnalyzeArgumentList(SyntaxNodeAnalysisContext context, BaseArgumentListSyntax argumentListSyntax)
{
if (argumentListSyntax == null
|| argumentListSyntax.Arguments.Count < 2)
{
return;
}
var previousArgumentLine = argumentListSyntax.Arguments[0].GetLineSpan().EndLinePosition.Line;
for (int i = 1; i < argumentListSyntax.Arguments.Count; i++)
{
var currentArgument = argumentListSyntax.Arguments[i];
int currentArgumentStartLine;
int currentArgumentEndLine;
if (currentArgument.HasLeadingTrivia && IsValidTrivia(currentArgument.GetLeadingTrivia()))
{
var lineSpan = currentArgument.SyntaxTree.GetLineSpan(currentArgument.FullSpan);
currentArgumentStartLine = lineSpan.StartLinePosition.Line;
currentArgumentEndLine = lineSpan.EndLinePosition.Line;
}
else
{
var lineSpan = currentArgument.GetLineSpan();
currentArgumentStartLine = lineSpan.StartLinePosition.Line;
currentArgumentEndLine = lineSpan.EndLinePosition.Line;
}
if (currentArgumentStartLine - previousArgumentLine > 1)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, currentArgument.GetLocation()));
}
previousArgumentLine = currentArgumentEndLine;
}
}
private static void AnalyzeArgumentList(SyntaxNodeAnalysisContext context, BaseArgumentListSyntax argumentListSyntax)
{
if (argumentListSyntax == null
|| argumentListSyntax.Arguments.Count < 2)
{
return;
}
var previousLine = argumentListSyntax.Arguments[0].GetLineSpan().EndLinePosition.Line;
for (int i = 1; i < argumentListSyntax.Arguments.Count; i++)
{
var currentArgument = argumentListSyntax.Arguments[i];
var lineSpan = currentArgument.GetLineSpan();
var currentLine = lineSpan.StartLinePosition.Line;
if (currentLine - previousLine > 1)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, currentArgument.GetLocation()));
}
previousLine = lineSpan.EndLinePosition.Line;
}
}
public BaseArgumentListTranslation(BaseArgumentListSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Arguments = syntax.Arguments.Get <ArgumentSyntax, ArgumentTranslation>(this);
}
internal static TextSpan GetSignatureHelpSpan(BaseArgumentListSyntax argumentList)
{
return(CommonSignatureHelpUtilities.GetSignatureHelpSpan(argumentList, s_getBaseArgumentListCloseToken));
}
private int GetArgumentListIndex(BaseArgumentListSyntax argumentList, SyntaxToken previousToken)
{
if (previousToken == argumentList.GetOpenToken())
{
return 0;
}
//// ( node0 , node1 , node2 , node3 ,
//
// Tokidx 0 1 2 3 4 5 6 7
//
// index 1 2 3
//
// index = (Tokidx + 1) / 2
var tokenIndex = argumentList.Arguments.GetWithSeparators().IndexOf(previousToken);
return (tokenIndex + 1) / 2;
}
