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); }
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);
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; }