private static void AnalyzeInvocationExpressionSyntax(SyntaxNodeAnalysisContext context, IEnumerable <INamedTypeSymbol> registeredSymbols) { var invocationExpressionSyntax = (InvocationExpressionSyntax)context.Node; ISymbol symbol = context.SemanticModel.GetSymbol(invocationExpressionSyntax, context.CancellationToken); if (symbol is null) { return; } INamedTypeSymbol containingType = symbol.ContainingType; foreach (var registeredSymbol in registeredSymbols) { if (containingType?.Equals(registeredSymbol) == true) { if (symbol.Kind == SymbolKind.Method && (symbol.Name == "ToString")) { SeparatedSyntaxList <ArgumentSyntax> arguments = invocationExpressionSyntax.ArgumentList.Arguments; if (!arguments.Any()) { return; } if (!arguments.Any(e => e.Expression.TryGetInferredMemberName() == "InvariantCulture")) { context.ReportDiagnostic(Diagnostic.Create(Rule, context.Node.GetLocation())); } } } } }
public static async Task ComputeRefactoringAsync(RefactoringContext context, EnumDeclarationSyntax enumDeclaration) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); INamedTypeSymbol enumSymbol = semanticModel.GetDeclaredSymbol(enumDeclaration, context.CancellationToken); if (!enumSymbol.IsEnumWithFlags(semanticModel)) { return; } SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members; if (!members.Any(f => f.EqualsValue == null)) { return; } SpecialType specialType = enumSymbol.EnumUnderlyingType.SpecialType; List <object> values = GetExplicitValues(enumDeclaration, semanticModel, context.CancellationToken); Optional <object> optional = FlagsUtility.GetUniquePowerOfTwo(specialType, values); if (!optional.HasValue) { return; } context.RegisterRefactoring( "Generate enum values", cancellationToken => RefactorAsync(context.Document, enumDeclaration, enumSymbol, startFromHighestExistingValue: false, cancellationToken: cancellationToken), RefactoringIdentifiers.GenerateEnumValues); if (!members.Any(f => f.EqualsValue != null)) { return; } Optional <object> optional2 = FlagsUtility.GetUniquePowerOfTwo(specialType, values, startFromHighestExistingValue: true); if (!optional2.HasValue) { return; } if (optional.Value.Equals(optional2.Value)) { return; } context.RegisterRefactoring( $"Generate enum values (starting from {optional2.Value})", cancellationToken => RefactorAsync(context.Document, enumDeclaration, enumSymbol, startFromHighestExistingValue: true, cancellationToken: cancellationToken), RefactoringIdentifiers.GenerateEnumValues); }
public static void ComputeRefactoring( RefactoringContext context, EnumDeclarationSyntax enumDeclaration, SemanticModel semanticModel) { INamedTypeSymbol enumSymbol = semanticModel.GetDeclaredSymbol(enumDeclaration, context.CancellationToken); if (enumSymbol?.HasAttribute(MetadataNames.System_FlagsAttribute) != true) { return; } SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members; if (!members.Any(f => f.EqualsValue == null)) { return; } ImmutableArray <ulong> values = GetExplicitValues(enumDeclaration, semanticModel, context.CancellationToken); Optional <ulong> optional = FlagsUtility <ulong> .Instance.GetUniquePowerOfTwo(values); if (!optional.HasValue) { return; } if (!ConvertHelpers.CanConvertFromUInt64(optional.Value, enumSymbol.EnumUnderlyingType.SpecialType)) { return; } Document document = context.Document; context.RegisterRefactoring( "Declare explicit values", ct => RefactorAsync(document, enumDeclaration, enumSymbol, values, startFromHighestExistingValue: false, cancellationToken: ct), RefactoringDescriptors.GenerateEnumValues); if (members.Any(f => f.EqualsValue != null)) { Optional <ulong> optional2 = FlagsUtility <ulong> .Instance.GetUniquePowerOfTwo(values, startFromHighestExistingValue : true); if (optional2.HasValue && optional.Value != optional2.Value) { context.RegisterRefactoring( $"Declare explicit values (starting from {optional2.Value})", ct => RefactorAsync(document, enumDeclaration, enumSymbol, values, startFromHighestExistingValue: true, cancellationToken: ct), RefactoringDescriptors.GenerateEnumValues, "StartFromHighestExistingValue"); } } }
private static bool ContainsAuthorizationAttribute(SeparatedSyntaxList <AttributeSyntax> attributes) { if (attributes.Any(x => (x.Name as IdentifierNameSyntax).Identifier.ValueText == "AllowAnonymous")) { return(true); } if (attributes.Any(x => (x.Name as IdentifierNameSyntax).Identifier.ValueText == "Authorize")) { return(true); } return(false); }
public static void AnalyzeTypeParameterList(SyntaxNodeAnalysisContext context) { var typeParameterList = (TypeParameterListSyntax)context.Node; SeparatedSyntaxList <TypeParameterSyntax> typeParameters = typeParameterList.Parameters; if (!typeParameters.Any()) { return; } SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses = GetConstraintClauses(typeParameterList.Parent); if (!constraintClauses.Any()) { return; } if (constraintClauses.SpanContainsDirectives()) { return; } if (!IsFixable(typeParameters, constraintClauses)) { return; } context.ReportDiagnostic( DiagnosticDescriptors.ReorderTypeParameterConstraints, constraintClauses.First()); }
public static void Analyze( SyntaxNodeAnalysisContext context, MemberDeclarationSyntax memberDeclaration, SeparatedSyntaxList <TypeParameterSyntax> typeParameters) { if (typeParameters.Any(f => !f.IsMissing)) { SyntaxTrivia trivia = memberDeclaration.GetSingleLineDocumentationComment(); if (trivia.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia)) { var comment = trivia.GetStructure() as DocumentationCommentTriviaSyntax; if (comment?.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia) == true) { var names = new HashSet <string>(DocumentationCommentRefactoring.GetNameAttributeValues(comment, "typeparam")); foreach (TypeParameterSyntax typeParameter in typeParameters) { if (!typeParameter.IsMissing && !names.Contains(typeParameter.Identifier.ValueText)) { context.ReportDiagnostic( DiagnosticDescriptors.AddTypeParameterToDocumentationComment, typeParameter); } } } } } }
public static ParametersInfo Create(DelegateDeclarationSyntax delegateDeclaration, bool allowMissing = false) { ParameterListSyntax parameterList = delegateDeclaration.ParameterList; if (!Check(parameterList, allowMissing)) { return(Default); } SeparatedSyntaxList <ParameterSyntax> parameters = parameterList.Parameters; if (!CheckParameters(parameters, allowMissing)) { return(Default); } TypeParameterListSyntax typeParameterList = delegateDeclaration.TypeParameterList; SeparatedSyntaxList <TypeParameterSyntax> typeParameters = typeParameterList?.Parameters ?? default(SeparatedSyntaxList <TypeParameterSyntax>); if (!CheckTypeParameters(typeParameters, allowMissing)) { return(Default); } if (!parameters.Any() && !typeParameters.Any()) { return(Default); } return(new ParametersInfo(typeParameterList, parameterList, default(CSharpSyntaxNode))); }
public static void Analyze( SyntaxNodeAnalysisContext context, MemberDeclarationSyntax memberDeclaration, SeparatedSyntaxList <ParameterSyntax> parameters) { if (!parameters.Any()) { return; } DocumentationCommentTriviaSyntax comment = memberDeclaration.GetSingleLineDocumentationComment(); if (comment == null) { return; } ImmutableArray <string> values = DocumentationCommentAnalysis.GetAttributeValues(comment, XmlElementKind.Param, "name"); if (values.IsDefault) { return; } foreach (ParameterSyntax parameter in parameters) { if (!parameter.IsMissing && !values.Contains(parameter.Identifier.ValueText)) { context.ReportDiagnostic(DiagnosticDescriptors.AddParameterToDocumentationComment, parameter.Identifier); } } }
private static ForStatementSyntax CreateForStatement( WhileStatementSyntax whileStatement, VariableDeclarationSyntax declaration, SeparatedSyntaxList <ExpressionSyntax> initializers, SeparatedSyntaxList <ExpressionSyntax> incrementors) { StatementSyntax statement = whileStatement.Statement; if (statement?.IsKind(SyntaxKind.Block) == true) { var block = (BlockSyntax)statement; incrementors = SeparatedList(GetIncrementors(block)); if (incrementors.Any()) { SyntaxList <StatementSyntax> statements = block.Statements; statement = block.WithStatements(List(statements.Take(statements.Count - incrementors.Count))); } } return(ForStatement( declaration, initializers, whileStatement.Condition, incrementors, statement)); }
public static string GetName(TypeDeclarationSyntax syntax) { string valueText = syntax.Identifier.ValueText; string containingTypeName = TypeNameResolver.GetContainingTypeName(syntax.Parent); if (!string.IsNullOrWhiteSpace(containingTypeName)) { valueText = string.Concat(containingTypeName, ".", valueText); } StringBuilder stringBuilder = new StringBuilder(); stringBuilder.Append(valueText); if (syntax.TypeParameterList != null) { SeparatedSyntaxList <TypeParameterSyntax> parameters = syntax.TypeParameterList.Parameters; if (parameters.Any()) { string str = string.Join(", ", from x in (IEnumerable <TypeParameterSyntax>) parameters select x.Identifier.ValueText); stringBuilder.AppendFormat("<{0}>", str); } } return(stringBuilder.ToString()); }
public static void ComputeRefactorings(RefactoringContext context, SwitchExpressionSyntax switchExpression) { SeparatedSyntaxList <SwitchExpressionArmSyntax> arms = switchExpression.Arms; if (!context.Span.IsEmptyAndContainedInSpan(switchExpression.SwitchKeyword)) { return; } if (!switchExpression.IsParentKind(SyntaxKind.ReturnStatement)) { return; } if (switchExpression.GoverningExpression.IsMissing) { return; } if (!arms.Any()) { return; } if (!arms.All(f => f.Pattern.IsKind(SyntaxKind.ConstantPattern, SyntaxKind.DiscardPattern))) { return; } context.RegisterRefactoring( "Convert to 'switch' statement", ct => ConvertSwitchExpressionToSwitchStatement(context.Document, switchExpression, ct), RefactoringIdentifiers.ConvertSwitchExpressionToSwitchStatement); }
public Func <SyntaxGenerator, ClassDeclarationSyntax, ClassDeclarationSyntax> GetRemoveBaseClassAction(string baseClass) { ClassDeclarationSyntax RemoveBaseClass(SyntaxGenerator syntaxGenerator, ClassDeclarationSyntax node) { SeparatedSyntaxList <BaseTypeSyntax> currentBaseTypes = node.BaseList.Types; SeparatedSyntaxList <BaseTypeSyntax> newBaseTypes = new SeparatedSyntaxList <BaseTypeSyntax>(); foreach (var baseTypeSyntax in currentBaseTypes) { if (!baseTypeSyntax.GetText().ToString().Trim().Equals(baseClass)) { newBaseTypes.Add(baseTypeSyntax); } } if (!newBaseTypes.Any()) { node = node.WithBaseList(null); } else { node = node.WithBaseList(node.BaseList.WithTypes(newBaseTypes)); } return(node); } return(RemoveBaseClass); }
static string GenerateProperty(string typeFullName, string propertyType, string propertyName, bool readOnly, bool bindableReadOnly, Tuple <MemberVisibility, MemberVisibility, bool> overridedPropertyVisibility, SeparatedSyntaxList <ArgumentSyntax> attributes) { string getterModifier = overridedPropertyVisibility == null ? "public " : overridedPropertyVisibility.Item2.ToCSharp(MemberVisibility.Private); string setterModifier = overridedPropertyVisibility == null ? (readOnly ? "private " : "") : overridedPropertyVisibility.Item1.ToCSharp(overridedPropertyVisibility.Item2); var nonBrowsable = overridedPropertyVisibility != null && overridedPropertyVisibility.Item3; var withDXDescription = attributes.Any(x => x.ToString() == "DXDescription"); string attributesString = (nonBrowsable ? "[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]\r\n" : "") + (withDXDescription ? $"[DXDescription(\"{typeFullName},{propertyName}\")]\r\n" : "") + string.Concat(attributes.Select(attribute => { if (attribute.ToString() == "DXDescription") { return(null); } var attributeExpression = attribute.Expression as InvocationExpressionSyntax; if (attributeExpression == null) { return(null); } return("[" + attributeExpression.ToString() + "]\r\n"); })); string setterAttributes = bindableReadOnly && !nonBrowsable ? "[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]\r\n " : string.Empty; string keySuffix = readOnly ? "Key" : ""; return ($@"{attributesString}{getterModifier}{propertyType} {propertyName} {{ get {{ return ({propertyType})GetValue({propertyName}Property); }} {setterAttributes}{setterModifier}set {{ SetValue({propertyName}Property{keySuffix}, value); }} }} "); }
public static AnalysisResult Analyze(InvocationExpressionSyntax invocationExpression, SemanticModel semanticModel, CancellationToken cancellationToken) { ArgumentListSyntax argumentList = invocationExpression.ArgumentList; if (argumentList != null) { SeparatedSyntaxList <ArgumentSyntax> arguments = argumentList.Arguments; if (arguments.Any()) { if (arguments.Count > 1 || !(arguments[0].Expression is LiteralExpressionSyntax)) { MethodInfo methodInfo; if (semanticModel.TryGetMethodInfo(invocationExpression, out methodInfo, cancellationToken) && methodInfo.Symbol.IsNonReducedExtensionMethod()) { InvocationExpressionSyntax newInvocationExpression = GetNewInvocation(invocationExpression); if (semanticModel .GetSpeculativeMethodSymbol(invocationExpression.SpanStart, newInvocationExpression)? .ReducedFromOrSelf() .Equals(methodInfo.ConstructedFrom) == true) { return(new AnalysisResult(invocationExpression, newInvocationExpression, methodInfo.Symbol)); } } } } } return(default(AnalysisResult)); }
public static bool IsApplicableSpan(InitializerExpressionSyntax initializer, TextSpan span) { SeparatedSyntaxList <ExpressionSyntax> expressions = initializer.Expressions; if (!expressions.Any()) { return(true); } if (span.IsEmpty) { if (expressions.Count == expressions.SeparatorCount && TextSpan.FromBounds(expressions.GetSeparator(expressions.Count - 1).Span.End, initializer.CloseBraceToken.SpanStart).Contains(span)) { return(true); } TextSpan span2 = TextSpan.FromBounds(expressions.Last().Span.End, initializer.CloseBraceToken.SpanStart); if (span2.Length > 0) { span2 = new TextSpan(span2.Start + 1, span2.Length - 1); if (span2.Contains(span)) { return(true); } } } return(false); }
public static SelectionResult Create <TNode>(SeparatedSyntaxList <TNode> nodes, TextSpan span, int minCount, int maxCount) where TNode : SyntaxNode { ThrowIfNotValidRange(minCount, maxCount); if (!nodes.Any()) { return(Fail); } if (span.IsEmpty) { return(Fail); } SelectionResult result = Create(nodes, span); if (!result.Success) { return(Fail); } if (!result.IsInRange(minCount, maxCount)) { return(Fail); } return(result); }
public void SeparatedSyntaxList_Empty() { var list = new SeparatedSyntaxList <NameExpressionSyntax>(new SyntaxNodeOrToken[0]); Assert.Equal(0, list.Count); Assert.False(list.Any()); }
public static bool ArgumentIsLiteralPredicate <T>(SeparatedSyntaxList <ArgumentSyntax> arguments, T value) { return(arguments.Any() && arguments.First().Expression is LiteralExpressionSyntax literal && literal.Token.Value is T argument && argument.Equals(value)); }
public static void Analyze( SyntaxNodeAnalysisContext context, MemberDeclarationSyntax memberDeclaration, SeparatedSyntaxList <TypeParameterSyntax> typeParameters) { if (typeParameters.Any()) { DocumentationCommentTriviaSyntax comment = memberDeclaration.GetSingleLineDocumentationComment(); if (comment != null) { ImmutableArray <string> values = DocumentationCommentAnalysis.GetAttributeValues(comment, "typeparam", "TYPEPARAM", "name"); if (!values.IsDefault) { foreach (TypeParameterSyntax typeParameter in typeParameters) { if (!typeParameter.IsMissing && !values.Contains(typeParameter.Identifier.ValueText)) { context.ReportDiagnostic( DiagnosticDescriptors.AddTypeParameterToDocumentationComment, typeParameter.Identifier); } } } } } }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, InitializerExpressionSyntax initializer) { if (initializer.IsKind(SyntaxKind.ComplexElementInitializerExpression) && initializer.IsParentKind(SyntaxKind.CollectionInitializerExpression)) { initializer = (InitializerExpressionSyntax)initializer.Parent; } if (context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(initializer) || context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(initializer.Expressions)) { SeparatedSyntaxList <ExpressionSyntax> expressions = initializer.Expressions; if (context.IsRefactoringEnabled(RefactoringIdentifiers.FormatInitializer) && expressions.Any() && !initializer.IsKind(SyntaxKind.ComplexElementInitializerExpression) && initializer.IsParentKind( SyntaxKind.ArrayCreationExpression, SyntaxKind.ImplicitArrayCreationExpression, SyntaxKind.ObjectCreationExpression, SyntaxKind.CollectionInitializerExpression)) { if (initializer.IsSingleLine(includeExteriorTrivia: false)) { context.RegisterRefactoring( "Format initializer on multiple lines", cancellationToken => SyntaxFormatter.ToMultiLineAsync( context.Document, initializer, cancellationToken), RefactoringIdentifiers.FormatInitializer); } else if (expressions.All(expression => expression.IsSingleLine()) && initializer.DescendantTrivia(initializer.Span).All(f => f.IsWhitespaceOrEndOfLineTrivia())) { context.RegisterRefactoring( "Format initializer on a single line", cancellationToken => SyntaxFormatter.ToSingleLineAsync( context.Document, initializer, cancellationToken), RefactoringIdentifiers.FormatInitializer); } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExpandInitializer)) { await ExpandInitializerRefactoring.ComputeRefactoringsAsync(context, initializer).ConfigureAwait(false); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseCSharp6DictionaryInitializer) && context.SupportsCSharp6) { await UseCSharp6DictionaryInitializerRefactoring.ComputeRefactoringAsync(context, initializer).ConfigureAwait(false); } } }
public static bool ArgumentIsVariablePredicate(SeparatedSyntaxList <ArgumentSyntax> arguments) { if (!arguments.Any()) { return(false); } return(ArgumentIsVariablePredicate(arguments.First())); }
public static async Task ComputeRefactoringAsync(RefactoringContext context, InitializerExpressionSyntax initializer) { SeparatedSyntaxList <ExpressionSyntax> expressions = initializer.Expressions; if (!expressions.Any()) { return; } if (!expressions.All(f => f.IsKind(SyntaxKind.ComplexElementInitializerExpression))) { return; } if (initializer.Parent is not ObjectCreationExpressionSyntax objectCreationExpression) { return; } var complexElementInitializer = (InitializerExpressionSyntax)expressions[0]; SeparatedSyntaxList <ExpressionSyntax> expressions2 = complexElementInitializer.Expressions; if (expressions2.Count != 2) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); IPropertySymbol propertySymbol = FindIndexerSymbol( objectCreationExpression, expressions2, semanticModel, context.CancellationToken); if (propertySymbol == null) { return; } ITypeSymbol keyType = propertySymbol.Parameters[0].Type; ITypeSymbol valueType = propertySymbol.Type; for (int i = 1; i < expressions.Count; i++) { if (!CanRefactor(((InitializerExpressionSyntax)expressions[i]).Expressions, keyType, valueType, semanticModel)) { return; } } context.RegisterRefactoring( "Use index initializer", ct => RefactorAsync(context.Document, initializer, ct), RefactoringDescriptors.UseIndexInitializer); }
public static bool MethodContainingLambdaPredicate(SeparatedSyntaxList <ArgumentSyntax> arguments) { if (!arguments.Any()) { return(false); } return(arguments.First().Expression is LambdaExpressionSyntax); }
private static bool CanExpand( InitializerExpressionSyntax initializer, SemanticModel semanticModel, CancellationToken cancellationToken) { var objectCreationExpression = (ObjectCreationExpressionSyntax)initializer.Parent; if (objectCreationExpression.Type != null) { ExpressionSyntax expression = initializer.Expressions[0]; if (expression.IsKind(SyntaxKind.SimpleAssignmentExpression)) { var assignment = (AssignmentExpressionSyntax)expression; ExpressionSyntax left = assignment.Left; if (left.IsKind(SyntaxKind.ImplicitElementAccess)) { var implicitElementAccess = (ImplicitElementAccessSyntax)left; BracketedArgumentListSyntax argumentList = implicitElementAccess.ArgumentList; if (argumentList?.Arguments.Any() == true) { return(HasPublicWritableIndexer( argumentList.Arguments[0].Expression, objectCreationExpression, semanticModel, cancellationToken)); } } else { return(true); } } else if (expression.IsKind(SyntaxKind.ComplexElementInitializerExpression)) { var initializerExpression = (InitializerExpressionSyntax)expression; SeparatedSyntaxList <ExpressionSyntax> expressions = initializerExpression.Expressions; if (expressions.Any()) { return(HasPublicWritableIndexer(expressions[0], objectCreationExpression, semanticModel, cancellationToken)); } } else { return(HasPublicAddMethod(expression, objectCreationExpression, semanticModel, cancellationToken)); } } return(false); }
public static Task <Document> RefactorAsync( Document document, ForStatementSyntax forStatement, CancellationToken cancellationToken) { var statements = new List <StatementSyntax>(); VariableDeclarationSyntax declaration = forStatement.Declaration; if (declaration != null) { statements.Add(LocalDeclarationStatement(declaration)); } else { foreach (ExpressionSyntax initializer in forStatement.Initializers) { statements.Add(ExpressionStatement(initializer)); } } StatementSyntax statement = forStatement.Statement ?? Block(); SeparatedSyntaxList <ExpressionSyntax> incrementors = forStatement.Incrementors; if (incrementors.Any()) { if (!statement.IsKind(SyntaxKind.Block)) { statement = Block(statement); } ExpressionStatementSyntax[] incrementorStatements = incrementors .Select(f => ExpressionStatement(f).WithFormatterAnnotation()) .ToArray(); var rewriter = new InsertIncrementorsBeforeContinueRewriter(incrementorStatements); statement = (StatementSyntax)rewriter.Visit(statement); statement = ((BlockSyntax)statement).AddStatements(incrementorStatements); } statements.Add(WhileStatement(forStatement.Condition ?? TrueLiteralExpression(), statement)); statements[0] = statements[0].WithLeadingTrivia(forStatement.GetLeadingTrivia()); if (forStatement.IsEmbedded()) { return(document.ReplaceNodeAsync(forStatement, Block(statements), cancellationToken)); } else { return(document.ReplaceNodeAsync(forStatement, statements, cancellationToken)); } }
private Doc PrintArgumentListLikeSyntax( SyntaxToken openParenToken, SeparatedSyntaxList <ArgumentSyntax> arguments, SyntaxToken closeParenToken) => Concat( this.PrintSyntaxToken(openParenToken), arguments.Any() ? Indent( SoftLine, this.PrintSeparatedSyntaxList( arguments, this.PrintArgumentSyntax, Line ) ) : Doc.Null, arguments.Any() ? SoftLine : Doc.Null, this.PrintSyntaxToken(closeParenToken) );
private static bool MathodContainingArgumentInvokingLambda(SeparatedSyntaxList <ArgumentSyntax> arguments) { if (!arguments.Any()) { return(false); } return(arguments[0].Expression is InvocationExpressionSyntax invocation && MemberValidator.MethodContainingLambdaPredicate(invocation.ArgumentList.Arguments)); }
public static void AnalyzeLocalDeclarationStatement(SyntaxNodeAnalysisContext context) { var localDeclaration = (LocalDeclarationStatementSyntax)context.Node; SemanticModel semanticModel = context.SemanticModel; CancellationToken cancellationToken = context.CancellationToken; if (!localDeclaration.IsConst) { StatementContainer container; if (StatementContainer.TryCreate(localDeclaration, out container)) { SyntaxList <StatementSyntax> statements = container.Statements; if (statements.Count > 1) { int index = statements.IndexOf(localDeclaration); if (index < statements.Count - 1) { VariableDeclarationSyntax variableDeclaration = localDeclaration.Declaration; if (variableDeclaration?.IsMissing == false) { SeparatedSyntaxList <VariableDeclaratorSyntax> variables = variableDeclaration.Variables; if (variables.Any()) { TypeSyntax type = variableDeclaration.Type; ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, cancellationToken); if (typeSymbol?.SupportsConstantValue() == true && variables.All(variable => HasConstantValue(variable.Initializer?.Value, typeSymbol, semanticModel, cancellationToken))) { TextSpan span = TextSpan.FromBounds(statements[index + 1].Span.Start, statements.Last().Span.End); IEnumerable <SyntaxNode> nodes = container.Node.DescendantNodes(span); if (!IsAnyVariableInvalidOrAssigned( variables, nodes, semanticModel, cancellationToken)) { context.ReportDiagnostic( DiagnosticDescriptors.MarkLocalVariableAsConst, type); } } } } } } } } }
public static bool ArgumentIsIdentifierOrLiteralPredicate(SeparatedSyntaxList <ArgumentSyntax> arguments) { if (!arguments.Any()) { return(false); } var argumentsExpression = arguments.First().Expression; return(argumentsExpression is IdentifierNameSyntax || argumentsExpression is LiteralExpressionSyntax); }
private static bool HaveCountArgumentsValidator(SeparatedSyntaxList <ArgumentSyntax> arguments) { if (!arguments.Any()) { return(false); } return(arguments[0].Expression is LiteralExpressionSyntax literal && literal.Token.Value is int argument && argument == 0); }