private string GetParameterName(ISyntaxFactsService service, int index) { if (Arguments.IsDefault || index >= Arguments.Length) { return(string.Empty); } return(service.GetNameForArgument(Arguments[index])); }
private string GetParameterName(ISyntaxFactsService service, int index) { if (index >= this.Arguments?.Count) { return(string.Empty); } return(service.GetNameForArgument(this.Arguments?[index])); }
> GetArgumentInsertPositionForMethodCandidates( TArgumentSyntax argumentOpt, SemanticModel semanticModel, ISyntaxFactsService syntaxFacts, SeparatedSyntaxList <TArgumentSyntax> arguments, ImmutableArray <IMethodSymbol> methodCandidates ) { var comparer = syntaxFacts.StringComparer; var methodsAndArgumentToAdd = ArrayBuilder < ArgumentInsertPositionData <TArgumentSyntax> > .GetInstance(); foreach (var method in methodCandidates.OrderBy(m => m.Parameters.Length)) { if (method.IsNonImplicitAndFromSource()) { var isNamedArgument = !string.IsNullOrWhiteSpace( syntaxFacts.GetNameForArgument(argumentOpt) ); if (isNamedArgument || NonParamsParameterCount(method) < arguments.Count) { var argumentToAdd = DetermineFirstArgumentToAdd( semanticModel, syntaxFacts, comparer, method, arguments ); if (argumentToAdd != null) { if (argumentOpt != null && argumentToAdd != argumentOpt) { // We were trying to fix a specific argument, but the argument we want // to fix is something different. That means there was an error earlier // than this argument. Which means we're looking at a non-viable // constructor or method. Skip this one. continue; } methodsAndArgumentToAdd.Add( new ArgumentInsertPositionData <TArgumentSyntax>( method, argumentToAdd, arguments.IndexOf(argumentToAdd) ) ); } } } } return(methodsAndArgumentToAdd.ToImmutableAndFree()); }
private static TArgumentSyntax DetermineFirstArgumentToAdd( SemanticModel semanticModel, ISyntaxFactsService syntaxFacts, StringComparer comparer, IMethodSymbol method, SeparatedSyntaxList <TArgumentSyntax> arguments) { var compilation = semanticModel.Compilation; var methodParameterNames = new HashSet <string>(comparer); methodParameterNames.AddRange(method.Parameters.Select(p => p.Name)); for (int i = 0, n = arguments.Count; i < n; i++) { var argument = arguments[i]; var argumentName = syntaxFacts.GetNameForArgument(argument); if (!string.IsNullOrWhiteSpace(argumentName)) { // If the user provided an argument-name and we don't have any parameters that // match, then this is the argument we want to add a parameter for. if (!methodParameterNames.Contains(argumentName)) { return(argument); } } else { // Positional argument. If the position is beyond what the method supports, // then this definitely is an argument we could add. if (i >= method.Parameters.Length) { if (method.Parameters.LastOrDefault()?.IsParams == true) { // Last parameter is a params. We can't place any parameters past it. return(null); } return(argument); } // Now check the type of the argument versus the type of the parameter. If they // don't match, then this is the argument we should make the parameter for. var expressionOfArgument = syntaxFacts.GetExpressionOfArgument(argument); if (expressionOfArgument is null) { return(null); } var argumentTypeInfo = semanticModel.GetTypeInfo(expressionOfArgument); var isNullLiteral = syntaxFacts.IsNullLiteralExpression(expressionOfArgument); var isDefaultLiteral = syntaxFacts.IsDefaultLiteralExpression(expressionOfArgument); if (argumentTypeInfo.Type == null && argumentTypeInfo.ConvertedType == null) { // Didn't know the type of the argument. We shouldn't assume it doesn't // match a parameter. However, if the user wrote 'null' and it didn't // match anything, then this is the problem argument. if (!isNullLiteral && !isDefaultLiteral) { continue; } } var parameter = method.Parameters[i]; if (!TypeInfoMatchesType( compilation, argumentTypeInfo, parameter.Type, isNullLiteral, isDefaultLiteral)) { if (TypeInfoMatchesWithParamsExpansion( compilation, argumentTypeInfo, parameter, isNullLiteral, isDefaultLiteral)) { // The argument matched if we expanded out the params-parameter. // As the params-parameter has to be last, there's nothing else to // do here. return(null); } return(argument); } } } return(null); }
private string GetArgumentName(TArgumentSyntax argument, ISyntaxFactsService syntaxFactsService) => syntaxFactsService.GetNameForArgument(argument);