在Roslyn的C#编译器中合成lambda

Question

我一直在试验Roslyn中最近开源的C#编译器,看看我是否可以添加语言功能.

我现在正在尝试添加一些语法糖,一个新的前缀运算符,它基本上是某种模式的简写.就目前而言&,除了unsafe背景之外,我还捎带已经存在的"地址" .

我想扩展的模式如下:&n相当于:

Property.Bind(v => n = v, () => n)

Property.Bind假设该方法在库中可用,签名为:

public static IProperty<T> Bind<T>(Action<T> set, Func<T> get)

所以本质上我需要合成两个lambdas:

1. 绑定n为左值并从其参数中对其进行赋值,并且
2. 没有参数和评估n.然后我需要调用Property.Bind将这两个lambdas作为参数传递.

我以前的实验比这更容易,因为他们能够依靠易于查找的现有功能,所以几乎没有工作要做!

但这次我正在努力寻找类似于我在这里所做的事情.到目前为止,我一直在逐步介绍BoundLambda编译器如何从源代码构建它,并且它正在展开成一个大混乱.我修改BindAddressOfExpression的Binder_Operators.cs,使得它与一个额外的启动if安全上下文语句:

private BoundExpression BindAddressOfExpression(PrefixUnaryExpressionSyntax node, DiagnosticBag diagnostics)
{
    if (!this.InUnsafeRegion)
    {
        BoundExpression rValue = BindValue(node.Operand, diagnostics, BindValueKind.RValue);
        BoundExpression lValue = BindValue(node.Operand, diagnostics, BindValueKind.Assignment);

        var valueParamSymbol = new SourceSimpleParameterSymbol(null, rValue.Type, 0, RefKind.None, "__v", ImmutableArray<Location>.Empty);
        var valueParam = new BoundParameter(node, valueParamSymbol);
        var assignment = new BoundAssignmentOperator(node, lValue, valueParam, RefKind.None, rValue.Type);

        var assignmentStatement = new BoundExpressionStatement(node, assignment);
        var assignmentBlock = new BoundBlock(node, ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create<BoundStatement>(assignmentStatement)) { WasCompilerGenerated = true };
        assignmentBlock = FlowAnalysisPass.AppendImplicitReturn(assignmentBlock);

所以(大概!)现在我有第一个lambda的赋值块,但是完成BoundLambda它看起来是一个全新的挑战.

我想知道:有没有办法通过要求解析器/绑定器处理一串C#来"欺骗"这种语法糖,好像它已经出现在实际代码的位置？这样,手动构建所有零件并将它们拼接在一起就没有必要了.毕竟,现有的编译器非常适合这个!

Answer 1

更新:我已经确定了一个名为的新类SyntaxTemplate,它是不可变的,因此可以静态创建并重用.例如

private static readonly SyntaxTemplate _pointerIndirectionTemplate 
      = new SyntaxTemplate("p.Value");

private static readonly SyntaxTemplate _propertyReferenceTemplate
     = new SyntaxTemplate("System.Property.Bind(__v_pr__ => o = __v_pr__, () => o)");

private static readonly SyntaxTemplate _propertyReferenceTypeTemplate 
     = new SyntaxTemplate("System.IProperty<T>");

private static readonly SyntaxTemplate _enumerableTypeTemplate 
     = new SyntaxTemplate("System.Collections.Generic.IEnumerable<T>");

它内部有一个包含所有标识符的不可变字典,因此任何都可以用名称替换,例如表达式:

if (!operand.Type.IsPointerType())
    return BindExpression(
        _pointerIndirectionTemplate.Replace("p", node.Operand).Syntax, 
        diagnostics);

或者类型:

if (this.IsIndirectlyInIterator || !this.InUnsafeRegion)
    return BindNamespaceOrTypeOrAliasSymbol(
        _enumerableTypeTemplate.Replace("T", node.ElementType).Syntax,
        diagnostics, basesBeingResolved, suppressUseSiteDiagnostics);

SyntaxTemplate 看起来像这样:

internal class SyntaxTemplate
{
    public ExpressionSyntax Syntax { get; private set; }

    private readonly ImmutableDictionary<string, ImmutableList<IdentifierNameSyntax>> _identifiers;

    public SyntaxTemplate(string source)
    {
        Syntax = SyntaxFactory.ParseExpression(source);

        var identifiers = ImmutableDictionary<string, ImmutableList<IdentifierNameSyntax>.Builder>.Empty.ToBuilder();

        foreach (var node in Syntax.DescendantNodes().OfType<IdentifierNameSyntax>())
        {
            ImmutableList<IdentifierNameSyntax>.Builder list;
            if (!identifiers.TryGetValue(node.Identifier.Text, out list))
                list = identifiers[node.Identifier.Text] = 
                    ImmutableList<IdentifierNameSyntax>.Empty.ToBuilder();
            list.Add(node);
        }

        _identifiers = identifiers.ToImmutableDictionary(
            p => p.Key, p => p.Value.ToImmutableList());
    }

    private SyntaxTemplate(ExpressionSyntax syntax,
        ImmutableDictionary<string, ImmutableList<IdentifierNameSyntax>> identifiers)
    {
        Syntax = syntax;
        _identifiers = identifiers;
    }

    public SyntaxTemplate Replace(string identifier, SyntaxNode value)
    {
        return new SyntaxTemplate(
            Syntax.ReplaceNodes(_identifiers[identifier], (o1, o2) => value),
            _identifiers.Remove(identifier));
    }
}

因为替换值是a SyntaxNode,所以可以使用解析器已经创建的节点,因此不会浪费两次相同的语法.

更多:除了如果用户的源中存在错误(例如,它们在没有意义的情况下使用新语法)之外,这是有效的,那么绑定期间生成的错误是指模板源中的位置,这是无意义的在用户的来源中.因此IDE无法显示红色曲线等.

为了解决这个问题,您可以使用辅助方法在临时包中捕获诊断信息,然后将它们重放到真实包中,并将位置更改为用户源中使用语法的位置:

private T RedirectDiagnostics<T>(DiagnosticBag diagnostics, CSharpSyntaxNode nodeWithLocation, Func<DiagnosticBag, T> generate)
{
    var captured = new DiagnosticBag();
    var result = generate(captured);

    foreach (var diag in captured.AsEnumerable().OfType<DiagnosticWithInfo>())
        diagnostics.Add(new CSDiagnostic(diag.Info, nodeWithLocation.Location));

    return result;
}

示例用法,只是从上面包装第一个示例:

if (!operand.Type.IsPointerType())
    return RedirectDiagnostics(diagnostics, node, redirected => 
        BindExpression(_pointerIndirectionTemplate.Replace("p", node.Operand).Syntax, redirected));

现在红色波浪线正常工作(并且在真正的编译中,错误消息上的行号是正确的).