C# SyntaxTreeAnalysisContext.IsGenerated方法代码示例

 private static void AnalyzeTree(SyntaxTreeAnalysisContext context, Compilation compilation)
 {
     if (context.IsGenerated()) return;
     if (!compilation.SyntaxTrees.Contains(context.Tree)) return;
     var semanticModel = compilation.GetSemanticModel(context.Tree);
     SyntaxNode root;
     if (!context.Tree.TryGetRoot(out root)) return;
     var types = GetTypesInRoot(root);
     foreach (var type in types)
     {
         var fieldDeclarations = type.ChildNodes().OfType<FieldDeclarationSyntax>();
         var variablesToMakeReadonly = GetCandidateVariables(semanticModel, fieldDeclarations);
         var typeSymbol = semanticModel.GetDeclaredSymbol(type);
         if (typeSymbol == null) continue;
         var methods = typeSymbol.GetAllMethodsIncludingFromInnerTypes();
         foreach (var method in methods)
         {
             foreach (var syntaxReference in method.DeclaringSyntaxReferences)
             {
                 var syntaxRefSemanticModel = syntaxReference.SyntaxTree.Equals(context.Tree)
                         ? semanticModel
                         : compilation.GetSemanticModel(syntaxReference.SyntaxTree);
                 var descendants = syntaxReference.GetSyntax().DescendantNodes().ToList();
                 var assignments = descendants.OfKind(SyntaxKind.SimpleAssignmentExpression,
                     SyntaxKind.AddAssignmentExpression, SyntaxKind.AndAssignmentExpression, SyntaxKind.DivideAssignmentExpression,
                     SyntaxKind.ExclusiveOrAssignmentExpression, SyntaxKind.LeftShiftAssignmentExpression, SyntaxKind.ModuloAssignmentExpression,
                     SyntaxKind.MultiplyAssignmentExpression, SyntaxKind.OrAssignmentExpression, SyntaxKind.RightShiftAssignmentExpression,
                     SyntaxKind.SubtractAssignmentExpression);
                 foreach (AssignmentExpressionSyntax assignment in assignments)
                 {
                     var fieldSymbol = syntaxRefSemanticModel.GetSymbolInfo(assignment.Left).Symbol as IFieldSymbol;
                     VerifyVariable(variablesToMakeReadonly, method, syntaxRefSemanticModel, assignment, fieldSymbol);
                 }
                 var postFixUnaries = descendants.OfKind(SyntaxKind.PostIncrementExpression, SyntaxKind.PostDecrementExpression);
                 foreach (PostfixUnaryExpressionSyntax postFixUnary in postFixUnaries)
                 {
                     var fieldSymbol = syntaxRefSemanticModel.GetSymbolInfo(postFixUnary.Operand).Symbol as IFieldSymbol;
                     VerifyVariable(variablesToMakeReadonly, method, syntaxRefSemanticModel, postFixUnary, fieldSymbol);
                 }
                 var preFixUnaries = descendants.OfKind(SyntaxKind.PreDecrementExpression, SyntaxKind.PreIncrementExpression);
                 foreach (PrefixUnaryExpressionSyntax preFixUnary in preFixUnaries)
                 {
                     var fieldSymbol = syntaxRefSemanticModel.GetSymbolInfo(preFixUnary.Operand).Symbol as IFieldSymbol;
                     VerifyVariable(variablesToMakeReadonly, method, syntaxRefSemanticModel, preFixUnary, fieldSymbol);
                 }
             }
         }
         foreach (var readonlyVariable in variablesToMakeReadonly.Values)
         {
             var props = new Dictionary<string, string> { { "identifier", readonlyVariable.Identifier.Text } }.ToImmutableDictionary();
             var diagnostic = Diagnostic.Create(Rule, readonlyVariable.GetLocation(), props, readonlyVariable.Identifier.Text);
             context.ReportDiagnostic(diagnostic);
         }
     }
 }

 private static void AnalyzeTree(SyntaxTreeAnalysisContext context, Compilation compilation)
 {
     if (context.IsGenerated()) return;
     if (!compilation.SyntaxTrees.Contains(context.Tree)) return;
     var semanticModel = compilation.GetSemanticModel(context.Tree);
     SyntaxNode root;
     if (!context.Tree.TryGetRoot(out root)) return;
     var types = GetTypesInRoot(root);
     foreach (var type in types)
     {
         var fieldDeclarations = type.ChildNodes().OfType<FieldDeclarationSyntax>();
         var variablesToMakeReadonly = GetCandidateVariables(semanticModel, fieldDeclarations);
         var typeSymbol = semanticModel.GetDeclaredSymbol(type);
         if (typeSymbol == null) continue;
         var methods = typeSymbol.GetAllMethodsIncludingFromInnerTypes();
         foreach (var method in methods)
         {
             foreach (var syntaxReference in method.DeclaringSyntaxReferences)
             {
                 var syntaxRefSemanticModel = syntaxReference.SyntaxTree.Equals(context.Tree)
                         ? semanticModel
                         : compilation.GetSemanticModel(syntaxReference.SyntaxTree);
                 var assignments = syntaxReference.GetSyntax().DescendantNodes().OfType<AssignmentExpressionSyntax>();
                 foreach (var assignment in assignments)
                 {
                     var fieldSymbol = syntaxRefSemanticModel.GetSymbolInfo(assignment.Left).Symbol as IFieldSymbol;
                     if (fieldSymbol == null) continue;
                     if (method.MethodKind == MethodKind.StaticConstructor && fieldSymbol.IsStatic)
                         AddVariableThatWasSkippedBeforeBecauseItLackedAInitializer(variablesToMakeReadonly, fieldSymbol, assignment);
                     else if (method.MethodKind == MethodKind.Constructor && !fieldSymbol.IsStatic)
                         AddVariableThatWasSkippedBeforeBecauseItLackedAInitializer(variablesToMakeReadonly, fieldSymbol, assignment);
                     else
                         RemoveVariableThatHasAssignment(variablesToMakeReadonly, fieldSymbol);
                 }
             }
         }
         foreach (var readonlyVariable in variablesToMakeReadonly.Values)
         {
             var props = new Dictionary<string, string> { { "identifier", readonlyVariable.Identifier.Text } }.ToImmutableDictionary();
             var diagnostic = Diagnostic.Create(Rule, readonlyVariable.GetLocation(), props, readonlyVariable.Identifier.Text);
             context.ReportDiagnostic(diagnostic);
         }
     }
 }

 private static void AnalyzeTrailingTrivia(SyntaxTreeAnalysisContext context)
 {
     if (context.IsGenerated()) return;
     SourceText text;
     if (!context.Tree.TryGetText(out text)) return;
     SyntaxNode root;
     if (!context.Tree.TryGetRoot(out root)) return;
     foreach (var line in text.Lines)
     {
         if (line.End == 0) continue;
         var endSpan = TextSpan.FromBounds(line.End - 1, line.End);
         var candidateWhiteSpace = line.Text.GetSubText(endSpan).ToString();
         if (string.Compare(candidateWhiteSpace, "\n", StringComparison.Ordinal) == 0
             || !Regex.IsMatch(candidateWhiteSpace, @"\s")) continue;
         var isLiteral = root.FindNode(endSpan) is LiteralExpressionSyntax;
         if (isLiteral) return;
         var diag = Diagnostic.Create(Rule, Location.Create(context.Tree, line.Span));
         context.ReportDiagnostic(diag);
     }
 }

        private void AnalyzeSingleLineCommentTrivia(SyntaxTreeAnalysisContext context)
        {
            if (context.IsGenerated()) return;
            var root = context.Tree.GetRoot();

            var comments = root.DescendantTrivia()
                .Where(trivia => trivia.IsKind(SyntaxKind.SingleLineCommentTrivia))
                .ToArray();

            for (var i = 0; i < comments.Length; i++)
            {
                var comment = comments[i];

                var code = GetFullCommentedCode(root, comment);
                if (!CouldBeSourceCode(code.Code)) continue;

                i += code.NumberOfComments - 1;

                Location.Create(context.Tree, new TextSpan(code.Start, code.End));
                var diagnostic = Diagnostic.Create(Rule, comment.GetLocation());
                context.ReportDiagnostic(diagnostic);
            }
        }