Improve analysis capability for partial methods (C#)

[mkrueger]

using System.Diagnostics;

partial class Test
{
    partial void FooBar();
}

partial class Test
{
    public void Foo()
    {
        FooBar();
    }
}

When analyzing the FooBar(); invocation there is no way to find out that FooBar(); has no body.

method.PartialDefinitionPart == null and method.PartialImplementationPart == null

ATM I would expect that PartialDefinitionPart != null and PartialImplementationPart == null in the case above. It would be nice if there would be a flag to flag partial methods.

If that's all too c# specific a ICSharpSourceMethod interface would solve that issue.

[amcasey]

Doesn't the fact that PartialImplementationPart is null tell you that it has no body? I believe PartialDefinitionPart is null because you're already on the definition part.

    /// <summary>
    /// If this is a partial method implementation part, returns the corresponding
    /// definition part.  Otherwise null.
    /// </summary>
    IMethodSymbol PartialDefinitionPart { get; }

[JoshVarty]

I think the issue here is that it's difficult to figure out if it's a partial method if you have the IMethodSymbol. Both PartialDefinitionPart and PartialImplementationPart are null.

For example:

var tree = CSharpSyntaxTree.ParseText(@"
public class MyClass
{
    partial void MyMethod();
}");

var Mscorlib = PortableExecutableReference.CreateFromAssembly(typeof(object).Assembly);
var compilation = CSharpCompilation.Create("MyCompilation",
    syntaxTrees: new[] { tree }, references: new[] { Mscorlib });

var model = compilation.GetSemanticModel(tree);
var methodSyntax = tree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().Single();
var methodSymbol = model.GetDeclaredSymbol(methodSyntax);

//Both are null. The same results for non-partial methods.
Console.WriteLine(methodSymbol.PartialDefinitionPart);
Console.WriteLine(methodSymbol.PartialImplementationPart);

[amcasey]

Well that seems unhelpful. @rchande tells me that the IDE iterates over the DeclaringSyntaxNodes property but that doesn't seem like a very clean solution. There should probably be an API for this.

[JoshVarty]

I'd propose the addition of an IsPartial property on IMethodSymbol. I think it would solve @mkrueger's problem and make partials easier to detect. It also seems to fit well with the rest of the API as there is an easy way to detect most other modifiers via IsPublic, IsStatic, IsPartial, IsVirtual, IsAsync and so on.

Perhaps the broader question is "Should there be an Is_____ field for all modifiers?" I believe IsUnsafe is missing as well.

[amcasey]

I suspect the reason that it doesn't exist now is that - unlike public, static, and virtual - partial is a source-only concept. Since we have exposed other aspects of partial-ness on IMethodSymbol, we should probably expose IsPartial as well. However, I doubt we will end up exposing IsUnsafe - it's a source concept that is easily checked on the DeclaringSyntaxNodes.

[mkrueger]

Using the nodes is fine for me.

I use now this method that:

static bool IsEmptyPartialMethod(IMethodSymbol method, CancellationToken cancellationToken = default(CancellationToken))
{
    if (method.IsDefinedInMetadata ())
        return false;
    foreach (var r in method.DeclaringSyntaxReferences) {
        var node = r.GetSyntax (cancellationToken) as MethodDeclarationSyntax;
        if (node == null)
            continue;
        if (node.Body != null || !node.Modifiers.Any(m => m.IsKind (SyntaxKind.PartialKeyword)))
            return false;
    }

    return true;
}

I think that issue can be closed.