/Src/Compilers/CSharp/Test/Symbol/Compilation/SemanticModelGetSemanticInfoTests.cs

Large files files are truncated, but you can click here to view the full file

// Copyright (c) Microsoft Open Technologies, Inc.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.

using System;
using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis.CSharp.Symbols;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Xunit;

// Note: the easiest way to create new unit tests that use GetSemanticInfo
// is to use the SemanticInfo unit test generate in Editor Test App. 

namespace Microsoft.CodeAnalysis.CSharp.UnitTests
{
    using Utils = CompilationUtils;
    using Microsoft.CodeAnalysis.CSharp.Test.Utilities;

    public class GetExtendedSemanticInfoTests : SemanticModelTestBase
    {
        [Fact]
        public void FailedOverloadResolution()
        {
            string sourceCode = @"
class Program
{
    static void Main(string[] args)
    {
        int i = 8;
        int j = i + q;
        /*<bind>*/X.f/*</bind>*/(""hello"");
    }
}

class X
{
    public static void f() { }
    public static void f(int i) { }
}
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Null(semanticInfo.Type);
            Assert.Null(semanticInfo.ConvertedType);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.OverloadResolutionFailure, semanticInfo.CandidateReason);
            Assert.Equal(2, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("void X.f()", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.Method, sortedCandidates[0].Kind);
            Assert.Equal("void X.f(System.Int32 i)", sortedCandidates[1].ToTestDisplayString());
            Assert.Equal(SymbolKind.Method, sortedCandidates[1].Kind);

            Assert.Equal(2, semanticInfo.MethodGroup.Length);
            var sortedMethodGroup = semanticInfo.MethodGroup.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("void X.f()", sortedMethodGroup[0].ToTestDisplayString());
            Assert.Equal("void X.f(System.Int32 i)", sortedMethodGroup[1].ToTestDisplayString());

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void SimpleGenericType()
        {
            string sourceCode = @"
using System;

class Program
{
    /*<bind>*/K<int>/*</bind>*/ f;
}

class K<T>
{ }
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("K<System.Int32>", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind);
            Assert.Equal("K<System.Int32>", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Equal("K<System.Int32>", semanticInfo.Symbol.ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, semanticInfo.Symbol.Kind);
            Assert.Equal(0, semanticInfo.CandidateSymbols.Length);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void WrongArity1()
        {
            string sourceCode = @"
using System;

class Program
{
    /*<bind>*/K<int, string>/*</bind>*/ f;
}

class K<T>
{ }
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("K<T>", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind);
            Assert.Equal("K<T>", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.WrongArity, semanticInfo.CandidateReason);
            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("K<T>", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, sortedCandidates[0].Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void WrongArity2()
        {
            string sourceCode = @"
using System;

class Program
{
    /*<bind>*/K/*</bind>*/ f;
}

class K<T>
{ }
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("K<T>", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind);
            Assert.Equal("K<T>", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.WrongArity, semanticInfo.CandidateReason);
            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("K<T>", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, sortedCandidates[0].Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void WrongArity3()
        {
            string sourceCode = @"
using System;

class Program
{
    static void Main()
    {
        /*<bind>*/K<int, int>/*</bind>*/.f();
    }

}

class K<T>
{
    void f() { }
}

";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("K<T>", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind);
            Assert.Equal("K<T>", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.WrongArity, semanticInfo.CandidateReason);
            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("K<T>", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, sortedCandidates[0].Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void WrongArity4()
        {
            string sourceCode = @"

using System;

class Program
{
    static K Main()
    {
        /*<bind>*/K/*</bind>*/.f();
    }

}

class K<T>
{
    void f() { }
}
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("K<T>", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind);
            Assert.Equal("K<T>", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.WrongArity, semanticInfo.CandidateReason);
            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("K<T>", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, sortedCandidates[0].Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void NotInvocable()
        {
            string sourceCode = @"
using System;

class Program
{
    static void Main()
    {
        K./*<bind>*/f/*</bind>*/();
    }

}

class K
{
    public int f;
}
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("System.Int32", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind);
            Assert.Equal("System.Int32", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.NotInvocable, semanticInfo.CandidateReason);
            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("System.Int32 K.f", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.Field, sortedCandidates[0].Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void InaccessibleField()
        {
            string sourceCode = @"
class Program
{
    static void Main()
    {
        K./*<bind>*/f/*</bind>*/ = 3;
    }
}

class K
{
    private int f;
}
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("System.Int32", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind);
            Assert.Equal("System.Int32", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.Inaccessible, semanticInfo.CandidateReason);
            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("System.Int32 K.f", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.Field, sortedCandidates[0].Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void InaccessibleFieldAssignment()
        {
            string sourceCode =
@"class A
{
    string F;
}
class B
{
    static void M(A a)
    {
        /*<bind>*/a.F/*</bind>*/ = string.Empty;
    }
}";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);
            Assert.Equal(SpecialType.System_String, semanticInfo.Type.SpecialType);
            var symbol = semanticInfo.Symbol;
            Assert.Null(symbol);
            Assert.Equal(CandidateReason.Inaccessible, semanticInfo.CandidateReason);
            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
            symbol = semanticInfo.CandidateSymbols[0];
            Assert.Equal("System.String A.F", symbol.ToTestDisplayString());
            Assert.Equal(SymbolKind.Field, symbol.Kind);
        }

        [WorkItem(542481, "DevDiv")]
        [Fact]
        public void InaccessibleBaseClassConstructor01()
        {
            string sourceCode = @"
namespace Test
{
    public class Base
    {
        protected Base() { }
    }

    public class Derived : Base
    {
        void M()
        {
            Base b = /*<bind>*/new Base()/*</bind>*/;
        }
    }
}";
            var semanticInfo = GetSemanticInfoForTest<ObjectCreationExpressionSyntax>(sourceCode);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.Inaccessible, semanticInfo.CandidateReason);
            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("Test.Base..ctor()", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.Method, sortedCandidates[0].Kind);
        }

        [WorkItem(542481, "DevDiv")]
        [Fact]
        public void InaccessibleBaseClassConstructor02()
        {
            string sourceCode = @"
namespace Test
{
    public class Base
    {
        protected Base() { }
    }

    public class Derived : Base
    {
        void M()
        {
            Base b = new /*<bind>*/Base/*</bind>*/();
        }
    }
}";
            var semanticInfo = GetSemanticInfoForTest<NameSyntax>(sourceCode);

            Assert.Null(semanticInfo.Type);
            Assert.Null(semanticInfo.ConvertedType);

            Assert.Equal("Test.Base", semanticInfo.Symbol.ToTestDisplayString());
            Assert.Equal(CandidateReason.None, semanticInfo.CandidateReason);
            Assert.Equal(0, semanticInfo.CandidateSymbols.Length);
            Assert.Equal(0, semanticInfo.MemberGroup.Length);
        }

        [Fact]
        public void InaccessibleFieldMethodArg()
        {
            string sourceCode =
@"class A
{
    string F;
}
class B
{
    static void M(A a)
    {
        M(/*<bind>*/a.F/*</bind>*/);
    }
    static void M(string s) { }
}";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);
            Assert.Equal(SpecialType.System_String, semanticInfo.Type.SpecialType);
            var symbol = semanticInfo.Symbol;
            Assert.Null(symbol);
            Assert.Equal(CandidateReason.Inaccessible, semanticInfo.CandidateReason);
            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
            symbol = semanticInfo.CandidateSymbols[0];
            Assert.Equal("System.String A.F", symbol.ToTestDisplayString());
            Assert.Equal(SymbolKind.Field, symbol.Kind);
        }

        [Fact]
        public void TypeNotAVariable()
        {
            string sourceCode = @"
using System;

class Program
{
    static void Main()
    {
        /*<bind>*/K/*</bind>*/ = 12;
    }

}

class K
{
}
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("K", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind);
            Assert.Equal("K", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.NotAVariable, semanticInfo.CandidateReason);
            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("K", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, sortedCandidates[0].Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void InaccessibleType1()
        {
            string sourceCode = @"
using System;

class Program
{
    static void Main()
    {
        /*<bind>*/K.J/*</bind>*/ = v;
    }

}

class K
{
    protected class J { }
}
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("?", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind);
            Assert.Equal("?", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.Inaccessible, semanticInfo.CandidateReason);
            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("K.J", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, sortedCandidates[0].Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void AmbiguousTypesBetweenUsings1()
        {
            string sourceCode = @"
using System;
using N1;
using N2;

class Program
{
    /*<bind>*/A/*</bind>*/ field;
}

namespace N1
{
    class A { }
}

namespace N2
{
    class A { }
}
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("N1.A", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind);
            Assert.Equal("N1.A", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.Ambiguous, semanticInfo.CandidateReason);
            Assert.Equal(2, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("N1.A", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, sortedCandidates[0].Kind);
            Assert.Equal("N2.A", sortedCandidates[1].ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, sortedCandidates[1].Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void AmbiguousTypesBetweenUsings2()
        {
            string sourceCode = @"
using System;
using N1;
using N2;

class Program
{
    void f()
    {
        /*<bind>*/A/*</bind>*/.g();
    }
}

namespace N1
{
    class A { }
}

namespace N2
{
    class A { }
}
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("N1.A", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind);
            Assert.Equal("N1.A", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.Ambiguous, semanticInfo.CandidateReason);
            Assert.Equal(2, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("N1.A", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, sortedCandidates[0].Kind);
            Assert.Equal("N2.A", sortedCandidates[1].ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, sortedCandidates[1].Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void AmbiguousTypesBetweenUsings3()
        {
            string sourceCode = @"
using System;
using N1;
using N2;

class Program
{
    void f()
    {
        /*<bind>*/A<int>/*</bind>*/.g();
    }
}

namespace N1
{
    class A<T> { }
}

namespace N2
{
    class A<U> { }
}
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("N1.A<System.Int32>", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind);
            Assert.Equal("N1.A<System.Int32>", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.Ambiguous, semanticInfo.CandidateReason);
            Assert.Equal(2, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("N1.A<T>", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, sortedCandidates[0].Kind);
            Assert.Equal("N2.A<U>", sortedCandidates[1].ToTestDisplayString());
            Assert.Equal(SymbolKind.NamedType, sortedCandidates[1].Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void AmbiguityBetweenInterfaceMembers()
        {
            string sourceCode = @"
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

interface I1
{
    public int P { get; }
}

interface I2
{
    public string P { get; }
}

interface I3 : I1, I2
{ }

public class Class1
{
    void f()
    {
        I3 x = null;
        int o = x./*<bind>*/P/*</bind>*/;
    }
}
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("I1.P", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind);
            Assert.Equal("System.Int32", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.NoConversion, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.Ambiguous, semanticInfo.CandidateReason);
            Assert.Equal(2, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("System.Int32 I1.P { get; }", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.Property, sortedCandidates[0].Kind);
            Assert.Equal("System.String I2.P { get; }", sortedCandidates[1].ToTestDisplayString());
            Assert.Equal(SymbolKind.Property, sortedCandidates[1].Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void Alias1()
        {
            string sourceCode = @"
using O = System.Object;

partial class A : /*<bind>*/O/*</bind>*/ {}

";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Equal("System.Object", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind);
            Assert.Equal("System.Object", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.NotNull(semanticInfo.Symbol);
            Assert.Equal(0, semanticInfo.CandidateSymbols.Length);

            var aliasInfo = GetAliasInfoForTest(sourceCode);
            Assert.NotNull(aliasInfo);
            Assert.Equal("O=System.Object", aliasInfo.ToTestDisplayString());
            Assert.Equal(SymbolKind.Alias, aliasInfo.Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void Alias2()
        {
            string sourceCode = @"
using O = System.Object;

partial class A {
    void f()
    {
        /*<bind>*/O/*</bind>*/.ReferenceEquals(null, null);
    }
}

";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);
            var aliasInfo = GetAliasInfoForTest(sourceCode);

            Assert.Equal("System.Object", semanticInfo.Type.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind);
            Assert.Equal("System.Object", semanticInfo.ConvertedType.ToTestDisplayString());
            Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.NotNull(semanticInfo.Symbol);
            Assert.Equal(0, semanticInfo.CandidateSymbols.Length);

            Assert.Equal("O=System.Object", aliasInfo.ToTestDisplayString());
            Assert.Equal(SymbolKind.Alias, aliasInfo.Kind);

            Assert.Equal(0, semanticInfo.MethodGroup.Length);

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [WorkItem(539002, "DevDiv")]
        [Fact]
        public void IncompleteGenericMethodCall()
        {
            string sourceCode = @"
class Array
{
  public static void Find<T>(T t) { }
}
class C
{
  static void Main()
  {
    /*<bind>*/Array.Find<int>/*</bind>*/(
  }
}
";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);

            Assert.Null(semanticInfo.Type);
            Assert.Null(semanticInfo.ConvertedType);
            Assert.Equal(ConversionKind.Identity, semanticInfo.ImplicitConversion.Kind);

            Assert.Null(semanticInfo.Symbol);
            Assert.Equal(CandidateReason.OverloadResolutionFailure, semanticInfo.CandidateReason);
            Assert.Equal(1, semanticInfo.CandidateSymbols.Length);
            var sortedCandidates = semanticInfo.CandidateSymbols.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("void Array.Find<System.Int32>(System.Int32 t)", sortedCandidates[0].ToTestDisplayString());
            Assert.Equal(SymbolKind.Method, sortedCandidates[0].Kind);

            Assert.Equal(1, semanticInfo.MethodGroup.Length);
            var sortedMethodGroup = semanticInfo.MethodGroup.OrderBy(s => s.ToTestDisplayString()).ToArray();
            Assert.Equal("void Array.Find<System.Int32>(System.Int32 t)", sortedMethodGroup[0].ToTestDisplayString());

            Assert.False(semanticInfo.IsCompileTimeConstant);
        }

        [Fact]
        public void IncompleteExtensionMethodCall()
        {
            string sourceCode =
@"interface I<T> { }
class A { }
class B : A { }
class C
{
    static void M(A a)
    {
        /*<bind>*/a.M/*</bind>*/(
    }
}
static class S
{
    internal static void M(this object o, int x) { }
    internal static void M(this A a, int x, int y) { }
    internal static void M(this B b) { }
    internal static void M(this string s) { }
    internal static void M<T>(this T t, object o) { }
    internal static void M<T>(this T[] t) { }
    internal static void M<T, U>(this T x, I<T> y, U z) { }
}";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);
            Assert.Null(semanticInfo.Symbol);
            Utils.CheckSymbols(semanticInfo.MethodGroup,
                "void object.M(int x)",
                "void A.M(int x, int y)",
                "void A.M<A>(object o)",
                "void A.M<A, U>(I<A> y, U z)");
            Utils.CheckSymbols(semanticInfo.CandidateSymbols,
                "void object.M(int x)",
                "void A.M(int x, int y)",
                "void A.M<A>(object o)",
                "void A.M<A, U>(I<A> y, U z)");
            Utils.CheckReducedExtensionMethod((MethodSymbol)semanticInfo.MethodGroup[3],
                "void A.M<A, U>(I<A> y, U z)",
                "void S.M<T, U>(T x, I<T> y, U z)",
                "void T.M<T, U>(I<T> y, U z)",
                "void S.M<T, U>(T x, I<T> y, U z)");
        }

        [Fact]
        public void IncompleteExtensionMethodCallBadThisType()
        {
            string sourceCode =
@"interface I<T> { }
class B
{
    static void M(I<A> a)
    {
        /*<bind>*/a.M/*</bind>*/(
    }
}
static class S
{
    internal static void M(this object o) { }
    internal static void M<T>(this T t, object o) { }
    internal static void M<T>(this T[] t) { }
    internal static void M<T, U>(this I<T> x, I<T> y, U z) { }
}";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);
            Utils.CheckSymbols(semanticInfo.MethodGroup,
                "void object.M()",
                "void I<A>.M<I<A>>(object o)",
                "void I<A>.M<A, U>(I<A> y, U z)");
        }

        [WorkItem(541141, "DevDiv")]
        [Fact]
        public void IncompleteGenericExtensionMethodCall()
        {
            string sourceCode =
@"using System.Linq;
class C
{
    static void M(double[] a)
    {
        /*<bind>*/a.Where/*</bind>*/(
    }
}";
            var compilation = CreateCompilationWithMscorlib(references: new MetadataReference[] { SystemCoreRef }, text: sourceCode);
            var semanticInfo = GetSemanticInfoForTest<ExpressionSyntax>(compilation);
            Utils.CheckSymbols(semanticInfo.MethodGroup,
                "IEnumerable<double> IEnumerable<double>.Where<double>(Func<double, bool> predicate)",
                "IEnumerable<double> IEnumerable<double>.Where<double>(Func<double, int, bool> predicate)");
        }

        [WorkItem(541349, "DevDiv")]
        [Fact]
        public void GenericExtensionMethodCallExplicitTypeArgs()
        {
            string sourceCode =
@"interface I<T> { }
class C
{
    static void M(object o)
    {
        /*<bind>*/o.E<int>/*</bind>*/();
    }
}
static class S
{
    internal static void E(this object x, object y) { }
    internal static void E<T>(this object o) { }
    internal static void E<T>(this object o, T t) { }
    internal static void E<T>(this I<T> t) { }
    internal static void E<T, U>(this I<T> t) { }
}";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);
            Utils.CheckSymbol(semanticInfo.Symbol,
                "void object.E<int>()");
            Utils.CheckSymbols(semanticInfo.MethodGroup,
                "void object.E<int>()",
                "void object.E<int>(int t)");
            Utils.CheckSymbols(semanticInfo.CandidateSymbols);
        }

        [Fact]
        public void GenericExtensionMethodCallExplicitTypeArgsOfT()
        {
            string sourceCode =
@"interface I<T> { }
class C
{
    static void M<T, U>(T t, U u)
    {
        /*<bind>*/t.E<T, U>/*</bind>*/(u);
    }
}
static class S
{
    internal static void E(this object x, object y) { }
    internal static void E<T>(this object o) { }
    internal static void E<T, U>(this T t, U u) { }
    internal static void E<T, U>(this I<T> t, U u) { }
}";
            var semanticInfo = GetSemanticInfoForTest(sourceCode);
            Utils.CheckSymbols(semanticInfo.MethodGroup,
                "void T.E<T, U>(U u)");
        }

        [WorkItem(541297, "DevDiv")]
        [Fact]
        public void GenericExtensionMethodCall()
        {
            // Single applicable overload with valid argument.
            var semanticInfo = GetSemanticInfoForTest(
@"class C
{
    static void M(string s)
    {
        /*<bind>*/s.E(s)/*</bind>*/;
    }
}
static class S
{
    internal static void E<T>(this T x, object y) { }
    internal static void E<T, U>(this T x, U y) { }
}");
            Utils.CheckSymbol(semanticInfo.Symbol,
                "void string.E<string, string>(string y)");
            Utils.CheckSymbols(semanticInfo.MethodGroup);
            Utils.CheckSymbols(semanticInfo.CandidateSymbols);

            // Multiple applicable overloads with valid arguments.
            semanticInfo = GetSemanticInfoForTest(
@"class C
{
    static void M(string s, object o)
    {
        /*<bind>*/s.E(s, o)/*</bind>*/;
    }
}
static class S
{
    internal static void E<T>(this object x, T y, object z) { }
    internal static void E<T, U>(this T x, object y, U z) { }
}");
            Assert.Null(semanticInfo.Symbol);
            Utils.CheckSymbols(semanticInfo.MethodGroup);
            Utils.CheckSymbols(semanticInfo.CandidateSymbols,
                "void object.E<string>(string y, object z)",
                "void string.E<string, object>(object y, object z)");

            // Multiple applicable overloads with error argument.
            semanticInfo = GetSemanticInfoForTest(
@"class C
{
    static void M(string s)
    {
        /*<bind>*/s.E(t, s)/*</bind>*/;
    }
}
static class S
{
    internal static void E<T>(this T x, T y, object z) { }
    internal static void E<T, U>(this T x, string y, U z) { }
}");
            Assert.Null(semanticInfo.Symbol);
            Utils.CheckSymbols(semanticInfo.MethodGroup);
            Utils.CheckSymbols(semanticInfo.CandidateSymbols,
                "void string.E<string>(string y, object z)",
                "void string.E<string, string>(string y, string z)");

            // Multiple overloads but all inaccessible.
            semanticInfo = GetSemanticInfoForTest(
@"class C
{
    static void M(string s)
    {
        /*<bind>*/s.E()/*</bind>*/;
    }
}
static class S
{
    static void E(this string x) { }
    static void E<T>(this T x) { }
}");
            Assert.Null(semanticInfo.Symbol);
            Utils.CheckSymbols(semanticInfo.MethodGroup);
            Utils.CheckSymbols(semanticInfo.CandidateSymbols,
                "void string.E()",
                "void string.E<string>()"
                );
        }

        [Fact]
        public void GenericExtensionDelegateMethod()
        {
            // Single applicable overload.
            var semanticInfo = GetSemanticInfoForTest(
@"class C
{
    static void M(string s)
    {
        System.Action<string> a = /*<bind>*/s.E/*</bind>*/;
    }
}
static class S
{
    internal static void E<T>(this T x, T y) { }
    internal static void E<T>(this object x, T y) { }
}");
            Utils.CheckSymbol(semanticInfo.Symbol,
                "void string.E<string>(string y)");
            Utils.CheckSymbols(semanticInfo.MethodGroup,
                "void string.E<string>(string y)",
                "void object.E<T>(T y)");
            Utils.CheckSymbols(semanticInfo.CandidateSymbols);

            // Multiple applicable overloads.
            semanticInfo = GetSemanticInfoForTest(
@"class C
{
    static void M(string s)
    {
        System.Action<string> a = /*<bind>*/s.E/*</bind>*/;
    }
}
static class S
{
    internal static void E<T>(this T x, T y) { }
    internal static void E<T, U>(this T x, U y) { }
}");
            Assert.Null(semanticInfo.Symbol);
            Utils.CheckSymbols(semanticInfo.MethodGroup,
                "void string.E<string>(string y)",
                "void string.E<string, U>(U y)");
            Utils.CheckSymbols(semanticInfo.CandidateSymbols,
                "void string.E<string>(string y)",
                "void string.E<string, U>(U y)");
        }

        /// <summary>
        /// Overloads from different scopes should
        /// be included in method group.
        /// </summary>
        [WorkItem(541890, "DevDiv")]
        [Fact]
        public void IncompleteExtensionOverloadedDifferentScopes()
        {
            // Instance methods and extension method (implicit instance).
            var sourceCode =
@"class C
{
    void M()
    {
        /*<bind>*/F/*</bind>*/(
    }
    void F(int x) { }
    void F(object x, object y) { }
}
static class E
{
    internal static void F(this object x, object y) { }
}";
            var compilation = CreateCompilationWithMscorlib(references: new MetadataReference[] { SystemCoreRef }, text: sourceCode);
            var type = compilation.GlobalNamespace.GetMember<NamedTypeSymbol>("C");
            var tree = compilation.SyntaxTrees[0];
            var model = compilation.GetSemanticModel(tree);
            var expr = GetSyntaxNodeOfTypeForBinding<ExpressionSyntax>(GetSyntaxNodeList(tree));
            var symbols = model.GetMemberGroup(expr);
            Utils.CheckSymbols(symbols,
                "void C.F(int x)",
                "void C.F(object x, object y)");
            symbols = model.LookupSymbols(expr.SpanStart, container: null, name: "F", includeReducedExtensionMethods: true);
            Utils.CheckSymbols(symbols,
                "void C.F(int x)",
                "void C.F(object x, object y)");
            symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true);
            Utils.CheckSymbols(symbols,
                "void C.F(int x)",
                "void C.F(object x, object y)",
                "void object.F(object y)");

            // Instance methods and extension method (explicit instance).
            sourceCode =
@"class C
{
    void M()
    {
        /*<bind>*/this.F/*</bind>*/(
    }
    void F(int x) { }
    void F(object x, object y) { }
}
static class E
{
    internal static void F(this object x, object y) { }
}";
            compilation = CreateCompilationWithMscorlib(references: new MetadataReference[] { SystemCoreRef }, text: sourceCode);
            type = compilation.GlobalNamespace.GetMember<NamedTypeSymbol>("C");
            tree = compilation.SyntaxTrees[0];
            model = compilation.GetSemanticModel(tree);
            expr = GetSyntaxNodeOfTypeForBinding<ExpressionSyntax>(GetSyntaxNodeList(tree));
            symbols = model.GetMemberGroup(expr);
            Utils.CheckSymbols(symbols,
                "void C.F(int x)",
                "void C.F(object x, object y)",
                "void object.F(object y)");
            symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true);
            Utils.CheckSymbols(symbols,
                "void C.F(int x)",
                "void C.F(object x, object y)",
                "void object.F(object y)");

            // Applicable instance method and inapplicable extension method.
            sourceCode =
@"class C
{
    void M()
    {
        /*<bind>*/this.F<string>/*</bind>*/(
    }
    void F<T>(T t) { }
}
static class E
{
    internal static void F(this object x) { }
}";
            compilation = CreateCompilationWithMscorlib(references: new MetadataReference[] { SystemCoreRef }, text: sourceCode);
            type = compilation.GlobalNamespace.GetMember<NamedTypeSymbol>("C");
            tree = compilation.SyntaxTrees[0];
            model = compilation.GetSemanticModel(tree);
            expr = GetSyntaxNodeOfTypeForBinding<ExpressionSyntax>(GetSyntaxNodeList(tree));
            symbols = model.GetMemberGroup(expr);
            Utils.CheckSymbols(symbols,
                "void C.F<string>(string t)");
            symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true);
            Utils.CheckSymbols(symbols,
                "void C.F<T>(T t)",
                "void object.F()");

            // Inaccessible instance method and accessible extension method.
            sourceCode =
@"class A
{
    void F() { }
}
class B : A
{
    static void M(A a)
    {
        /*<bind>*/a.F/*</bind>*/(
    }
}
static class E
{
    internal static void F(this object x) { }
}";
            compilation = CreateCompilationWithMscorlib(references: new MetadataReference[] { SystemCoreRef }, text: sourceCode);
            type = compilation.GlobalNamespace.GetMember<NamedTypeSymbol>("A");
            tree = compilation.SyntaxTrees[0];
            model = compilation.GetSemanticModel(tree);
            expr = GetSyntaxNodeOfTypeForBinding<ExpressionSyntax>(GetSyntaxNodeList(tree));
            symbols = model.GetMemberGroup(expr);
            Utils.CheckSymbols(symbols,
                "void object.F()");
            symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true);
            Utils.CheckSymbols(symbols,
                "void object.F()");

            // Inapplicable instance method and applicable extension method.
            sourceCode =
@"class C
{
    void M()
    {
        /*<bind>*/this.F<string>/*</bind>*/(
    }
    void F(object o) { }
}
static class E
{
    internal static void F<T>(this object x) { }
}";
            compilation = CreateCompilationWithMscorlib(references: new MetadataReference[] { SystemCoreRef }, text: sourceCode);
            type = compilation.GlobalNamespace.GetMember<NamedTypeSymbol>("C");
            tree = compilation.SyntaxTrees[0];
            model = compilation.GetSemanticModel(tree);
            expr = GetSyntaxNodeOfTypeForBinding<ExpressionSyntax>(GetSyntaxNodeList(tree));
            symbols = model.GetMemberGroup(expr);
            Utils.CheckSymbols(symbols,
                "void object.F<string>()");
            symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true);
            Utils.CheckSymbols(symbols,
                "void C.F(object o)",
                "void object.F<T>()");

            // Viable instance and extension methods, binding to extension method.
            sourceCode =
@"class C
{
    void M()
    {
        /*<bind>*/this.F/*</bind>*/();
    }
    void F(object o) { }
}
static class E
{
    internal static void F(this object x) { }
}";
            compilation = CreateCompilationWithMscorlib(references: new MetadataReference[] { SystemCoreRef }, text: sourceCode);
            type = compilation.GlobalNamespace.GetMember<NamedTypeSymbol>("C");
            tree = compilation.SyntaxTrees[0];
            model = compilation.GetSemanticModel(tree);
            expr = GetSyntaxNodeOfTypeForBinding<ExpressionSyntax>(GetSyntaxNodeList(tree));
            symbols = model.GetMemberGroup(expr);
            Utils.CheckSymbols(symbols,
                "void C.F(object o)",
                "void object.F()");
            symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true);
            Utils.CheckSymbols(symbols,
                "void C.F(object o)",
                "void object.F()");

            // Applicable and inaccessible extension methods.
            sourceCode =
@"class C
{
    void M(string s)
    {
        /*<bind>*/s.F<string>/*</bind>*/(
    }
}
static class E
{
    internal static void F(this object x, object y) { }
    internal static void F<T>(this T t) { }
}";
            compilation = CreateCompilationWithMscorlib(references: new MetadataReference[] { SystemCoreRef }, text: sourceCode);
            type = compilation.GetSpecialType(SpecialType.System_String);
            tree = compilation.SyntaxTrees[0];
            model = compilation.GetSemanticModel(tree);
            expr = GetSyntaxNodeOfTypeForBinding<ExpressionSyntax>(GetSyntaxNodeList(tree));
            symbols = model.GetMemberGroup(expr);
            Utils.CheckSymbols(symbols,
                "void string.F<string>()");
            symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true);
            Utils.CheckSymbols(symbols,
                "void object.F(object y)",
                "void string.F<string>()");

            // Inapplicable and inaccessible extension methods.
            sourceCode =
@"class C
{
    void M(string s)
    {
        /*<bind>*/s.F<string>/*</bind>*/(
    }
}
static class E
{
    internal static void F(this object x, object y) { }
    private static void F<T>(this T t) { }
}";
            compilation = CreateCompilationWithMscorlib(references: new MetadataReference[] { SystemCoreRef }, text: sourceCode);
            type = compilation.GetSpecialType(SpecialType.System_String);
            tree = compilation.SyntaxTrees[0];
            model = compilation.GetSemanticModel(tree);
            expr = GetSyntaxNodeOfTypeForBinding<ExpressionSyntax>(GetSyntaxNodeList(tree));
            symbols = model.GetMemberGroup(expr);
            Utils.CheckSymbols(symbols,
                "void string.F<string>()");
            symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true);
            Utils.CheckSymbols(symbols,
                "void object.F(object y)");

            // Multiple scopes.
            sourceCode =
@"namespace N1
{
    static class E
    {
        internal static void F(this object o) { }
    }
}
namespace N2
{
    using N1;
    class C
    {
        static void M(C c)
        {
            /*<bind>*/c.F/*</bind>*/(
        }
        void F(int x) { }
    }
    static class E
    {
        internal static void F(this object x, object y) { }
    }
}
static class E
{
    internal static void F(this object x, object y, object z) { }
}";
            compilation = CreateCompilationWithMscorlib(references: new MetadataReference[] { SystemCoreRef }, text: sourceCode);
            type = compilation.GlobalNamespace.GetMember<NamespaceSymbol>("N2").GetMember<NamedTypeSymbol>("C");
            tree = compilation.SyntaxTrees[0];
            model = compilation.GetSemanticModel(tree);
            expr = GetSyntaxNodeOfTypeForBinding<ExpressionSyntax>(GetSyntaxNodeList(tree));
            symbols = model.GetMemberGroup(expr);
            Utils.CheckSymbols(symbols,
                "void C.F(int x)",
                "void object.F(object y)",
                "void object.F()",
                "void object.F(object y, object z)");
            symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true);
            Utils.CheckSymbols(symbols,
                "void C.F(int x)",
                "void object.F(object y)",
                "void object.F()",
                "void object.F(object y, object z)");

            // Multiple scopes, no instance methods.
            sourceCode =
@"namespace N
{
    class C
    {
        static void M(C c)
        {
            /*<bind>*/c.F/*</bind>*/(
        }
    }
    static class E
    {
        internal static void F(this object x, object y) { }
    }
}
static class E
{
    internal static void F(this object x, object y, object z) { }
}";
            compilation = CreateCompilationWithMscorlib(references: new MetadataReference[] { SystemCoreRef }, text: sourceCode);
            type = compilation.GlobalNamespace.GetMember<NamespaceSymbol>("N").GetMember<NamedTypeSymbol>("C");
            tree = compilation.SyntaxTrees[0];
            model = compilation.GetSemanticModel(tree);
            expr = GetSyntaxNodeOfTypeForBinding<ExpressionSyntax>(GetSyntaxNodeList(tree));
            symbols = model.GetMemberGroup(expr);
            Utils.CheckSymbols(symbols,
                "void object.F(object y)",
                "void object.F(object y, object z)");
            symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true);
            Utils.CheckSymbols(symbols,
                "void object.F(object y)",
                "void object.F(object y, object z)");
        }

        [Fact]
        public void PropertyGroup()
        {
            var source1 =
@"Imports System
Imports System.Runtime.InteropServices
<Assembly: PrimaryInteropAssembly(0, 0)> 
<Assembly: Guid(""165F752D-E9C4-4F7E-B0D0-CDFD7A36E210"")> 
<ComImport()>
<Guid(""165F752D-E9C4-4F7E-B0D0-CDFD7A36E211"")>
Public Class A
    Property P(Optional x As Integer = 0) As Object
        Get
            Return Nothing
        End Get
        Set
        End Set
    End Property
    Property P(x As Integer, y As Integer) As Integer
        Get
            Return Nothing
        End Get
        Set
        End Set
    End Property
    Property P(x As Integer, y As String) As String
        Get
            Return Nothing
        End Get
        Set
        End Set
    End Property
End Class";
            var reference1 = BasicCompilationUtils.CompileToMetadata(source1, verify: false);

            // Assignment (property group).
            var source2 =
@"class B
{
    static void M(A a)
    {
        /*<bind>*/a.P/*</bind>*/[1, null] = string.Empty;
    }
}";
            var compilation = CreateCompilationWithMscorlib(source2, new[] { reference1 });
            var semanticInfo = GetSemanticInfoForTest<ExpressionSyntax>(compilation);
            Utils.CheckSymbol(semanticInfo.Symbol, "string A.P[int x, string y]");
            Utils.CheckSymbols(semanticInfo.MemberGroup,
                "object A.P[int x = 0]",
                "int A.P[int x, int y]",
                "string A.P[int x, string y]");
            Utils.CheckSymbols(semanticInfo.CandidateSymbols);

            // Assignment (property access).
            source2 =
@"class B
{
    static void M(A a)
    {
        /*<bind>*/a.P[1, null]/*</bind>*/ = string.Empty;
    }
}";
            compilation = CreateCompilationWithMscorlib(source2, new[] { reference1 });
            semanticInfo = GetSemanticInfoForTest<ExpressionSyntax>(compilation);
            Utils.CheckSymbol(semanticInfo.Symbol, "string A.P[int x, string y]");
            Utils.CheckSym…