private static void AnalyzeInvocationOp(OperationAnalysisContext context) { var invocation = (IInvocationOperation)context.Operation; if (invocation.TargetMethod.Kind != SymbolKind.Method || !invocation.TargetMethod.IsStatic) { return; } if (!IsCodeContractToReplace(context.Compilation, invocation)) { return; } DiagnosticDescriptor rule = Rule; if (ContractStatementAnalyzer.IsContractClass(context.ContainingSymbol)) { rule = RuleWithinCC; } var invocationSyntax = (InvocationExpressionSyntax)invocation.Syntax; if (invocationSyntax.Expression is MemberAccessExpressionSyntax memberAccess) { context.ReportDiagnostic(Diagnostic.Create(rule, memberAccess.Expression.GetLocation())); } }
private static void AnalyzeInvocationOp(OperationAnalysisContext context) { var statement = (IExpressionStatementOperation)context.Operation; var invocation = statement.Operation as IInvocationOperation; if (invocation == null) { return; } if (!IsCodeContractToRemove(context.Compilation, invocation)) { return; } if (ContractStatementAnalyzer.IsInvariantMethod(context.ContainingSymbol) || ContractStatementAnalyzer.IsContractClass(context.ContainingSymbol)) { return; } var invocationSyntax = (InvocationExpressionSyntax)invocation.Syntax; if (invocationSyntax.Expression is MemberAccessExpressionSyntax memberAccess) { context.ReportDiagnostic(Diagnostic.Create(Rule, statement.Syntax.GetLocation())); } }
private static void AnalyzeMethodDeclaration(CodeBlockAnalysisContext context) { MethodDeclarationSyntax methodSyntax = context.CodeBlock as MethodDeclarationSyntax; IMethodSymbol method = context.OwningSymbol as IMethodSymbol; if (method == null || methodSyntax == null) { return; } if (!ContractStatementAnalyzer.IsInvariantMethod(method)) { return; } context.ReportDiagnostic(Diagnostic.Create(Rule, methodSyntax.Identifier.GetLocation())); }
private static bool IsEquivalentRequireStatements(StatementSyntax a, StatementSyntax b, bool smart) { if (!smart) { return(a.IsEquivalentTo(b)); } var aCond = ContractStatementAnalyzer.ParseInvocation(a, out var aInv) ? aInv.Condition : null; var bCond = ContractStatementAnalyzer.ParseInvocation(b, out var bInv) ? bInv.Condition : null; if (aCond == null || bCond == null) { return(false); } return(aCond.IsEquivalentTo(bCond)); }
internal static void ReplaceWithEnumerable(DocumentEditor editor, SyntaxNode nodeToReplace) { ContractInvocationInfo contractCallInfo = null; if (!ContractStatementAnalyzer.ParseInvocation(nodeToReplace.Parent as ExpressionStatementSyntax, out contractCallInfo)) { if (!ContractStatementAnalyzer.ParseInvocation(nodeToReplace as InvocationExpressionSyntax, out contractCallInfo)) { return; } } if (!contractCallInfo.IsContractType || !ContractForAllToEnumerableAnalyzer.MethodNamesToFix.Contains(contractCallInfo.MethodNameAsString)) { return; } var generator = editor.Generator; var trailingTrivia = nodeToReplace.GetTrailingTrivia(); var leadingTrivia = nodeToReplace.GetLeadingTrivia(); SyntaxNode newCallNode = null; if (contractCallInfo.MethodNameAsString == nameof(System.Diagnostics.Contracts.Contract.ForAll) && contractCallInfo.AllArguments.Arguments.Count == 2) { newCallNode = generator.InvocationExpression( generator.MemberAccessExpression(contractCallInfo.AllArguments.Arguments[0].Expression, nameof(Enumerable.All)), contractCallInfo.AllArguments.Arguments[1]); } else if (contractCallInfo.MethodNameAsString == nameof(System.Diagnostics.Contracts.Contract.Exists) && contractCallInfo.AllArguments.Arguments.Count == 2) { newCallNode = generator.InvocationExpression( generator.MemberAccessExpression(contractCallInfo.AllArguments.Arguments[0].Expression, nameof(Enumerable.Any)), contractCallInfo.AllArguments.Arguments[1]); } if (newCallNode != null) { newCallNode = newCallNode.WithTrailingTrivia(trailingTrivia).WithLeadingTrivia(leadingTrivia); editor.ReplaceNode(nodeToReplace, newCallNode); } }
private static async Task <Document> ReplaceWithTurboContract(Document document, SyntaxNode nodeToReplace, string stringText, CancellationToken cancellationToken) { var editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false); var generator = editor.Generator; var semanticModel = await document.GetSemanticModelAsync(cancellationToken); ContractInvocationInfo contractCallInfo = null; if (!ContractStatementAnalyzer.ParseInvocation(nodeToReplace.Parent as ExpressionStatementSyntax, out contractCallInfo) || !contractCallInfo.IsSpecialContractType || !TurboContractConditionStringNotInSyncAnalyzer.MethodNamesToFix.Contains(contractCallInfo.MethodNameAsString)) { return(document); } var trailingTrivia = nodeToReplace.GetTrailingTrivia(); var leadingTrivia = nodeToReplace.GetLeadingTrivia(); SyntaxNode debugAssertCallNode = null; if (contractCallInfo.Message == null) { debugAssertCallNode = generator.InvocationExpression( generator.MemberAccessExpression(generator.IdentifierName(ContractStatementAnalyzer.SpecialContractClass), contractCallInfo.MethodName), contractCallInfo.Condition, generator.Argument("conditionString", RefKind.None, generator.LiteralExpression(contractCallInfo.Condition.ToString()))); } else { debugAssertCallNode = generator.InvocationExpression( generator.MemberAccessExpression(generator.IdentifierName(ContractStatementAnalyzer.SpecialContractClass), contractCallInfo.MethodName), contractCallInfo.Condition, contractCallInfo.Message, generator.Argument("conditionString", RefKind.None, generator.LiteralExpression(contractCallInfo.Condition.ToString()))); } debugAssertCallNode = debugAssertCallNode.WithTrailingTrivia(trailingTrivia).WithLeadingTrivia(leadingTrivia); editor.ReplaceNode(nodeToReplace, debugAssertCallNode); return(editor.GetChangedDocument()); }
private static void AnalyzeClassDeclaration(SymbolAnalysisContext context) { var namedType = context.Symbol as INamedTypeSymbol; if (namedType == null || namedType.TypeKind != TypeKind.Class) { return; } if (!ContractStatementAnalyzer.IsContractClass(namedType)) { return; } foreach (var syntax in namedType.DeclaringSyntaxReferences) { var syntaxNode = syntax.GetSyntax(context.CancellationToken); if (syntaxNode is ClassDeclarationSyntax classDecl) { context.ReportDiagnostic(Diagnostic.Create(Rule, classDecl.Identifier.GetLocation())); } } }
private static void AnalyzeInvocationOp(OperationAnalysisContext context) { var invocation = (IInvocationOperation)context.Operation; if (invocation.TargetMethod.Kind != SymbolKind.Method || !invocation.TargetMethod.IsStatic) { return; } if (invocation.Parent.Kind != OperationKind.ExpressionStatement) { return; } if (!IsCodeContractToReplace(invocation)) { return; } if (ContractStatementAnalyzer.IsContractClass(context.ContainingSymbol)) { return; } context.ReportDiagnostic(Diagnostic.Create(Rule, invocation.Parent.Syntax.GetLocation())); }
internal static void ReplaceWithDebugAssert(DocumentEditor editor, SyntaxNode nodeToReplace) { ContractInvocationInfo contractCallInfo = null; if (!ContractStatementAnalyzer.ParseInvocation(nodeToReplace.Parent as ExpressionStatementSyntax, out contractCallInfo) || !contractCallInfo.IsContractType || !ContractToDebugAssertAnalyzer.MethodNamesToFix.Contains(contractCallInfo.MethodNameAsString)) { return; } var generator = editor.Generator; var trailingTrivia = nodeToReplace.GetTrailingTrivia(); var leadingTrivia = nodeToReplace.GetLeadingTrivia(); SyntaxNode debugAssertCallNode = null; if (contractCallInfo.Message == null) { debugAssertCallNode = generator.InvocationExpression( generator.MemberAccessExpression(generator.IdentifierName(nameof(Debug)), nameof(Debug.Assert)), contractCallInfo.Condition, generator.LiteralExpression(contractCallInfo.Condition.ToString())); } else { debugAssertCallNode = generator.InvocationExpression( generator.MemberAccessExpression(generator.IdentifierName(nameof(Debug)), nameof(Debug.Assert)), contractCallInfo.Condition, generator.LiteralExpression(contractCallInfo.Condition.ToString()), contractCallInfo.Message); } debugAssertCallNode = debugAssertCallNode.WithTrailingTrivia(trailingTrivia).WithLeadingTrivia(leadingTrivia); editor.ReplaceNode(nodeToReplace, debugAssertCallNode); }
private static bool IsDebugAssertStatement(StatementSyntax statement) { return(ContractStatementAnalyzer.ParseInvocation(statement, out var invocationInfo) && invocationInfo.MethodNameAsString == "Assert" && invocationInfo.IsDebugType); }
private static bool IsTurboRequiresStatement(StatementSyntax statement) { return(ContractStatementAnalyzer.ParseInvocation(statement, out var invocationInfo) && invocationInfo.MethodNameAsString == "Requires" && invocationInfo.IsSpecialContractType); }