/// <summary> /// Updates the given SimpleNameSyntax node with the given identifier token. /// This function is a wrapper that calls WithIdentifier on derived syntax nodes. /// </summary> /// <param name="simpleName"></param> /// <param name="identifier"></param> /// <returns>The given simple name updated with the given identifier.</returns> public static SimpleNameSyntax WithIdentifier( this SimpleNameSyntax simpleName, SyntaxToken identifier ) { return(simpleName.Kind() == SyntaxKind.IdentifierName ? (SimpleNameSyntax)((IdentifierNameSyntax)simpleName).WithIdentifier(identifier) : (SimpleNameSyntax)((GenericNameSyntax)simpleName).WithIdentifier(identifier)); }
private static bool IsPropertyOfNullableOfT(ExpressionSyntax expression, string name, SemanticModel semanticModel, CancellationToken cancellationToken) { if (expression?.Kind() == SyntaxKind.SimpleMemberAccessExpression) { var memberAccessExpression = (MemberAccessExpressionSyntax)expression; SimpleNameSyntax simpleName = memberAccessExpression.Name; if (simpleName?.Kind() == SyntaxKind.IdentifierName) { var identifierName = (IdentifierNameSyntax)simpleName; return(string.Equals(identifierName.Identifier.ValueText, name, StringComparison.Ordinal) && SyntaxUtility.IsPropertyOfNullableOfT(expression, name, semanticModel, cancellationToken)); } } return(false); }
private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context) { var binaryExpression = (BinaryExpressionSyntax)context.Node; BinaryExpressionInfo binaryExpressionInfo = SyntaxInfo.BinaryExpressionInfo(binaryExpression); if (!binaryExpressionInfo.Success) { return; } if (binaryExpressionInfo.Right.Kind() != SyntaxKind.TrueLiteralExpression) { return; } ExpressionSyntax left = binaryExpressionInfo.Left; if (left.Kind() != SyntaxKind.ConditionalAccessExpression) { return; } var conditionalAccess = (ConditionalAccessExpressionSyntax)left; ExpressionSyntax whenNotNull = conditionalAccess.WhenNotNull; if (whenNotNull.Kind() != SyntaxKind.InvocationExpression) { return; } var invocationExpression = (InvocationExpressionSyntax)whenNotNull; if (invocationExpression.ArgumentList.Arguments.Count != 1) { return; } ExpressionSyntax expression = invocationExpression.Expression; if (expression.Kind() != SyntaxKind.MemberBindingExpression) { return; } var memberBindingExpression = (MemberBindingExpressionSyntax)expression; SimpleNameSyntax name = memberBindingExpression.Name; if (name.Kind() != SyntaxKind.IdentifierName) { return; } var identifierName = (IdentifierNameSyntax)name; if (!string.Equals(identifierName.Identifier.ValueText, "IsKind", StringComparison.Ordinal)) { return; } ISymbol symbol = context.SemanticModel.GetSymbol(invocationExpression, context.CancellationToken); if (symbol?.Kind != SymbolKind.Method) { return; } var methodSymbol = (IMethodSymbol)symbol; if (methodSymbol.MethodKind != MethodKind.ReducedExtension) { return; } if (methodSymbol.ReturnType.SpecialType != SpecialType.System_Boolean) { return; } if (methodSymbol.ContainingType?.HasMetadataName(RoslynMetadataNames.Microsoft_CodeAnalysis_CSharpExtensions) != true) { return; } ImmutableArray <IParameterSymbol> parameters = methodSymbol .ReducedFrom .Parameters; if (parameters.Length != 2) { return; } if (!parameters[0].Type.HasMetadataName(RoslynMetadataNames.Microsoft_CodeAnalysis_SyntaxNode)) { return; } if (!parameters[1].Type.HasMetadataName(CSharpMetadataNames.Microsoft_CodeAnalysis_CSharp_SyntaxKind)) { return; } DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.UnnecessaryConditionalAccess, conditionalAccess.OperatorToken); DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.UnnecessaryConditionalAccessFadeOut, binaryExpression.Right); }
public static string InvocationExpressionRootName(this ExpressionSyntax invocation, string[] classNames) { if (invocation == null) { return(""); } if (invocation is IdentifierNameSyntax) { if ((invocation as IdentifierNameSyntax).Identifier == null) { return(""); } return((invocation as IdentifierNameSyntax).Identifier.ValueText); } foreach (SyntaxNode invchnd in invocation.ChildNodes()) { if (invchnd.Kind() == SyntaxKind.SimpleMemberAccessExpression) { ExpressionSyntax exst = (invchnd as MemberAccessExpressionSyntax).Expression; if (exst != null) { if (exst is IdentifierNameSyntax) { if ((exst as IdentifierNameSyntax).Identifier == null) { return(""); } if (classNames != null) { if (classNames.Count() > 0) { SimpleNameSyntax aname = (invchnd as MemberAccessExpressionSyntax).Name; if (aname.Kind() == SyntaxKind.GenericName) { if (!"Entity".Equals(aname.Identifier.ValueText)) { return(""); } TypeArgumentListSyntax typeArgumentList = (aname as GenericNameSyntax).TypeArgumentList; if (typeArgumentList != null) { if (typeArgumentList.Arguments != null) { string locClassName = ""; foreach (TypeSyntax ts in typeArgumentList.Arguments) { locClassName = ts.ToString(); } if (classNames.Any(i => string.Equals(i, locClassName))) { return((exst as IdentifierNameSyntax).Identifier.ValueText); } } } } } } return(""); } else { return(exst.InvocationExpressionRootName(classNames)); } } } } return(""); }