Question

背景故事（对于我的问题不是必不可少的，但有些背景可能有帮助）

在我的公司，我们使用IResult<T>类型来处理函数式错误，而不是抛出异常并希望某些客户端捕获它们。 IResult<T>可以是DataResult<T> T或ErrorResult<T> Error，但不能同时为Error。 Exception大致相当于IResult<T>。因此，典型函数将返回throw以通过返回值传递任何遇到的错误，而不是使用IResult<T>备份堆栈。

我们在Bind上有扩展方法来组成函数链。两个主要的是Let和Bind。

bind是函数式语言的标准monadic IResult运算符。基本上，如果static IResult<T2> Bind( this IResult<T1> @this, Func<T1, IResult<T2>> projection) { return @this.HasValue ? projection(@this.Value) : new ErrorResult<T2>(@this.Error); }有一个值，它会调整值，否则它会转发错误。它是这样实现的

Let

static IResult<T> Let( this IResult<T> @this, Action<T> action) { if (@this.HasValue) { action(@this.Value); } return @this; }用于执行副作用，只要在函数链中没有遇到错误。它实现为

IResult<T>

我的Roslyn分析器用例

使用此IResult<T> API时常犯的一个错误是调用一个函数，该函数在传递给Action<T>的{{1}}内返回Let。发生这种情况时，如果内部函数返回Error，则错误将丢失，并且执行将继续，就像没有出错一样。当发生这种情况时，这可能是一个非常难以追踪的错误，并且在过去一年中已经发生了好几次。在这些情况下，应使用Bind代替，以便可以传播错误。

我想识别对作为IResult<T>的参数传递的lambda表达式中返回Let的函数的任何调用，并将它们标记为编译器警告。

我已经创建了一个分析器来执行此操作。您可以在此处查看完整的源代码：https://github.com/JamesFaix/NContext.Analyzers以下是解决方案中的主要分析器文件：

using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;

namespace NContext.Analyzers
{
    [DiagnosticAnalyzer(LanguageNames.CSharp)]
    public class BindInsteadOfLetAnalyzer : DiagnosticAnalyzer
    {
        public const string DiagnosticId = "NContext_0001";
        private const string _Category = "Safety";
        private const string _Title = "Unsafe use of IServiceResponse<T> inside Let expression";
        private const string _MessageFormat = "Unsafe use of IServiceResponse<T> inside Let expression.";
        private const string _Description = "If calling any methods that return IServiceResponse<T>, use Bind instead of Let. " + 
            "Otherwise, any returned ErrorResponses will be lost, execution will continue as if no error occurred, and no error will be logged.";

        private static DiagnosticDescriptor _Rule = 
            new DiagnosticDescriptor(
                DiagnosticId, 
                _Title, 
                _MessageFormat,
                _Category, 
                DiagnosticSeverity.Warning, 
                isEnabledByDefault: true, 
                description: _Description);

        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
            ImmutableArray.Create(_Rule);

        public override void Initialize(AnalysisContext context)
        { 
            context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.InvocationExpression);
        }

        private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
        {
            var functionChain = (InvocationExpressionSyntax) context.Node;

            //When invoking an extension method, the first child node should be a MemberAccessExpression
            var memberAccess = functionChain.ChildNodes().First() as MemberAccessExpressionSyntax;
            if (memberAccess == null)
            {
                return;
            }

            //When invoking an extension method, the last child node of the member access should be an IdentifierName
            var letIdentifier = memberAccess.ChildNodes().Last() as IdentifierNameSyntax;
            if (letIdentifier == null)
            {
                return;
            }

            //Ignore method invocations that do not have "Let" in the name
            if (!letIdentifier.GetText().ToString().Contains("Let")) 
            {
               return;
            }

            var semanticModel = context.SemanticModel;

            var unsafeNestedInvocations = functionChain.ArgumentList
                //Get nested method calls
                .DescendantNodes().OfType<InvocationExpressionSyntax>()
                //Get any identifier names in those calls
                .SelectMany(node => node.DescendantNodes().OfType<IdentifierNameSyntax>())
                //Get tuples of syntax nodes and the methods they refer to
                .Select(node => new 
                {
                    Node = node,
                    Symbol = semanticModel.GetSymbolInfo(node).Symbol as IMethodSymbol
                })
                //Ignore identifiers that do not refer to methods
                .Where(x => x.Symbol != null
                //Ignore methods that do not have "IServiceResponse" in the return type
                    && x.Symbol.ReturnType.ToDisplayString().Contains("IServiceResponse"));

            //Just report the first one to reduce error log clutter
            var firstUnsafe = unsafeNestedInvocations.FirstOrDefault();
            if (firstUnsafe != null)
            {
                var diagnostic = Diagnostic.Create(_Rule, firstUnsafe.Node.GetLocation(), firstUnsafe.Node.GetText().ToString());
                context.ReportDiagnostic(diagnostic);
            }
        }
    }
}

问题

我的分析器适用于当前打开的任何*.cs个文件。警告将添加到“错误”窗口中，绿色警告下划线将显示在文本编辑器中。但是，如果我关闭包含带有这些警告的callite的文件，则会从“错误”窗口中删除错误。此外，如果我只是在没有打开文件的情况下编译我的解决方案，则不会记录任何警告。在调试模式下运行分析器解决方案时，如果在Visual Studio的调试沙箱实例中没有打开源代码文件，则不会触发任何断点。

如何让分析仪检查所有文件，甚至是关闭文件？

Answer 1

我从这个问题找到答案：How can I make my code diagnostic syntax node action work on closed files?

显然，如果您的分析器作为Visual Studio扩展安装，而不是作为项目级别的软件包安装，则默认只分析打开的文件。你可以去工具＆gt;选项＆gt;文本编辑器＆gt; C＃＆gt;高级并检查启用完整解决方案分析，使其适用于当前解决方案中的任何文件。

多么奇怪的默认行为。 ¯\ _（ツ）_ /¯

Roslyn分析器仅针对打开的文件运行

1 个答案: