public void LanguageId() { var source = @"class C { static void F() { } }"; var bytes = CreateCompilationWithMscorlib(source).EmitToArray(); var resolver = Resolver.VisualBasicResolver; var csharpLanguageId = Guid.Parse("3f5162f8-07c6-11d3-9053-00c04fa302a1"); var vbLanguageId = Guid.Parse("3a12d0b8-c26c-11d0-b442-00a0244a1dd2"); var cppLanguageId = Guid.Parse("3a12d0b7-c26c-11d0-b442-00a0244a1dd2"); // Module loaded before requests. var module = new Module(bytes); using (var process = new Process(module)) { var requestDefaultId = new Request(null, MemberSignatureParser.Parse("F"), Guid.Empty); var requestMethodId = new Request(null, MemberSignatureParser.Parse("F"), DkmLanguageId.MethodId); var requestCSharp = new Request(null, MemberSignatureParser.Parse("F"), csharpLanguageId); var requestVB = new Request(null, MemberSignatureParser.Parse("F"), vbLanguageId); var requestCPP = new Request(null, MemberSignatureParser.Parse("F"), cppLanguageId); resolver.EnableResolution(process, requestDefaultId); VerifySignatures(requestDefaultId, "C.F()"); resolver.EnableResolution(process, requestMethodId); VerifySignatures(requestMethodId); resolver.EnableResolution(process, requestCSharp); VerifySignatures(requestCSharp); resolver.EnableResolution(process, requestVB); VerifySignatures(requestVB, "C.F()"); resolver.EnableResolution(process, requestCPP); VerifySignatures(requestCPP); } // Module loaded after requests. module = new Module(bytes); using (var process = new Process()) { var requestDefaultId = new Request(null, MemberSignatureParser.Parse("F"), Guid.Empty); var requestMethodId = new Request(null, MemberSignatureParser.Parse("F"), DkmLanguageId.MethodId); var requestCSharp = new Request(null, MemberSignatureParser.Parse("F"), csharpLanguageId); var requestVB = new Request(null, MemberSignatureParser.Parse("F"), vbLanguageId); var requestCPP = new Request(null, MemberSignatureParser.Parse("F"), cppLanguageId); resolver.EnableResolution(process, requestCPP); resolver.EnableResolution(process, requestVB); resolver.EnableResolution(process, requestCSharp); resolver.EnableResolution(process, requestMethodId); resolver.EnableResolution(process, requestDefaultId); process.AddModule(module); resolver.OnModuleLoad(process, module); VerifySignatures(requestDefaultId, "C.F()"); VerifySignatures(requestMethodId); VerifySignatures(requestCSharp); VerifySignatures(requestVB, "C.F()"); VerifySignatures(requestCPP); } }
public void OnLoad() { var source = @"class C { static void F(object o) { } object F() => null; }"; var compilation = CreateCompilationWithMscorlib(source); var module = new Module(compilation.EmitToArray()); using (var process = new Process()) { var resolver = Resolver.CSharpResolver; var request = new Request(null, MemberSignatureParser.Parse("C.F")); resolver.EnableResolution(process, request); VerifySignatures(request); process.AddModule(module); resolver.OnModuleLoad(process, module); VerifySignatures(request, "C.F(System.Object)", "C.F()"); } }
public void SpecialTypes() { var source = @"class C<T1, T2, T3, T4> { } class C { static void F(bool a, char b, sbyte c, byte d) { } static void F(short a, ushort b, int c, uint d) { } static void F(C<uint, long, ulong, float> o) { } static void F(C<double, string, object, decimal> o) { } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F(bool, char, sbyte, byte)", "C.F(System.Boolean, System.Char, System.SByte, System.Byte)"); Resolve(process, resolver, "F(System.Int16, System.UInt16, System.Int32, System.UInt32)", "C.F(System.Int16, System.UInt16, System.Int32, System.UInt32)"); Resolve(process, resolver, "F(C<UInt32, Int64, UInt64, Single>)", "C.F(C<System.UInt32, System.Int64, System.UInt64, System.Single>)"); Resolve(process, resolver, "F(C<double, string, object, decimal>)", "C.F(C<System.Double, System.String, System.Object, System.Decimal>)"); Resolve(process, resolver, "F(bool, char, sbyte)"); Resolve(process, resolver, "F(C<double, string, object, decimal, bool>)"); } }
public void DifferentCase_NamespacesAndTypes() { var source = @"namespace one.two { class THREE { static void Method(THREE t) { } } } namespace One.Two { class Three { static void Method(Three t) { } } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.VisualBasicResolver; Resolve(process, resolver, "Method", "One.Two.Three.Method(One.Two.Three)", "one.two.THREE.Method(one.two.THREE)"); Resolve(process, resolver, "Three.Method", "One.Two.Three.Method(One.Two.Three)", "one.two.THREE.Method(one.two.THREE)"); Resolve(process, resolver, "three.Method(three)", "One.Two.Three.Method(One.Two.Three)", "one.two.THREE.Method(one.two.THREE)"); Resolve(process, resolver, "THREE.Method(THREE)", "One.Two.Three.Method(One.Two.Three)", "one.two.THREE.Method(one.two.THREE)"); Resolve(process, resolver, "ONE.TWO.THREE.Method", "One.Two.Three.Method(One.Two.Three)", "one.two.THREE.Method(one.two.THREE)"); Resolve(process, resolver, "one.two.three.Method(one.two.three)", "One.Two.Three.Method(One.Two.Three)", "one.two.THREE.Method(one.two.THREE)"); Resolve(process, resolver, "THREE", "One.Two.Three..ctor()", "one.two.THREE..ctor()"); } }
public void TypeParameters() { var source = @"class A { class B<T> { static void F<U>(B<T> t) { } static void F<U>(B<U> u) { } } } class A<T> { class B<U> { static void F<V>(T t) { } static void F<V>(A<U> u) { } static void F<V>(B<V> v) { } } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F<T>", "A.B<T>.F<U>(A.B<T>)", "A.B<T>.F<U>(A.B<U>)", "A<T>.B<U>.F<V>(T)", "A<T>.B<U>.F<V>(A<U>)", "A<T>.B<U>.F<V>(A<T>.B<V>)"); Resolve(process, resolver, "B<T>.F<U>", "A.B<T>.F<U>(A.B<T>)", "A.B<T>.F<U>(A.B<U>)", "A<T>.B<U>.F<V>(T)", "A<T>.B<U>.F<V>(A<U>)", "A<T>.B<U>.F<V>(A<T>.B<V>)"); Resolve(process, resolver, "F<T>(B<T>)", "A.B<T>.F<U>(A.B<U>)"); Resolve(process, resolver, "F<U>(B<T>)"); // No T in signature to bind to. Resolve(process, resolver, "F<T>(B<U>)"); // No U in signature to bind to. Resolve(process, resolver, "B<X>.F<Y>(B<X>)", "A.B<T>.F<U>(A.B<T>)"); Resolve(process, resolver, "B<X>.F<Y>(B<Y>)", "A.B<T>.F<U>(A.B<U>)"); Resolve(process, resolver, "B<U>.F<V>(T)"); // No T in signature to bind to. Resolve(process, resolver, "B<U>.F<V>(A<U>)", "A<T>.B<U>.F<V>(A<U>)"); Resolve(process, resolver, "B<U>.F<V>(B<V>)", "A.B<T>.F<U>(A.B<U>)"); Resolve(process, resolver, "B<V>.F<U>(B<U>)", "A.B<T>.F<U>(A.B<U>)"); Resolve(process, resolver, "A<X>.B<Y>.F<Z>(X)", "A<T>.B<U>.F<V>(T)"); Resolve(process, resolver, "A<X>.B<Y>.F<Z>(B<Z>)", "A<T>.B<U>.F<V>(A<T>.B<V>)"); } }
public void NamespacesAndTypes() { var source = @"namespace A.B { class T { } class C { static void F(C c) { } static void F(A.B<T>.C c) { } } } namespace A { class B<T> { internal class C { static void F(C c) { } static void F(A.B.C c) { } } } } class A<T> { internal class B { internal class C { static void F(C c) { } static void F(A.B<T>.C c) { } } } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "A.B.C.F(A.B.C)", "A.B.C.F(A.B<A.B.T>.C)", "A.B<T>.C.F(A.B<T>.C)", "A.B<T>.C.F(A.B.C)", "A<T>.B.C.F(A<T>.B.C)", "A<T>.B.C.F(A.B<T>.C)"); Resolve(process, resolver, "F(C)", "A.B.C.F(A.B.C)", "A.B.C.F(A.B<A.B.T>.C)", "A.B<T>.C.F(A.B.C)"); Resolve(process, resolver, "F(B.C)", "A.B.C.F(A.B.C)", "A.B<T>.C.F(A.B.C)"); Resolve(process, resolver, "F(B<T>.C)", "A.B.C.F(A.B<A.B.T>.C)"); Resolve(process, resolver, "A.B.C.F", "A.B.C.F(A.B.C)", "A.B.C.F(A.B<A.B.T>.C)"); Resolve(process, resolver, "A<T>.B.C.F", "A<T>.B.C.F(A<T>.B.C)", "A<T>.B.C.F(A.B<T>.C)"); Resolve(process, resolver, "A.B<T>.C.F", "A.B<T>.C.F(A.B<T>.C)", "A.B<T>.C.F(A.B.C)"); Resolve(process, resolver, "B<T>.C.F(B<T>.C)", "A.B<T>.C.F(A.B<T>.C)"); } }
public void Namespaces() { var source = @"namespace N { namespace M { class A<T> { static void F() { } } } } namespace N { class B { static void F() { } } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "N.B.F()", "N.M.A<T>.F()"); Resolve(process, resolver, "A<T>.F", "N.M.A<T>.F()"); Resolve(process, resolver, "N.A<T>.F"); Resolve(process, resolver, "M.A<T>.F", "N.M.A<T>.F()"); Resolve(process, resolver, "N.M.A<T>.F", "N.M.A<T>.F()"); Resolve(process, resolver, "N.B.F", "N.B.F()"); } }
public void Constructors() { var source = @"class A { static A() { } A() { } A(object o) { } } class B { } class C<T> { } class D { static object A => null; static void B<T>() { } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "A", "A..ctor()", "A..ctor(System.Object)", "D.get_A()"); Resolve(process, resolver, "A.A", "A..ctor()", "A..ctor(System.Object)"); Resolve(process, resolver, "B", "B..ctor()"); Resolve(process, resolver, "B<T>", "D.B<T>()"); Resolve(process, resolver, "C", "C<T>..ctor()"); Resolve(process, resolver, "C<T>"); Resolve(process, resolver, "C<T>.C", "C<T>..ctor()"); Assert.Null(MemberSignatureParser.Parse(".ctor")); Assert.Null(MemberSignatureParser.Parse("A..ctor")); } }
public void PInvoke() { var source = @"using System.Runtime.InteropServices; class A { [DllImport(""extern.dll"")] public static extern int F(); } class B { public static int F() => 0; }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "B.F()"); } }
public void UnexpectedArity() { var sourceA = @".class public A<T> { }"; var sourceB = @"class B { static void F(object o) { } static void F(A<object> a) { } }"; ImmutableArray<byte> bytesA; ImmutableArray<byte> pdbA; EmitILToArray(sourceA, appendDefaultHeader: true, includePdb: false, assemblyBytes: out bytesA, pdbBytes: out pdbA); var refA = AssemblyMetadata.CreateFromImage(bytesA).GetReference(); var compilationB = CreateCompilationWithMscorlib(sourceB, references: new[] { refA }); var bytesB = compilationB.EmitToArray(); using (var process = new Process(new Module(bytesB))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "B.F(System.Object)", "B.F([notsupported])"); Resolve(process, resolver, "F(A<object>)"); } }
public void Global() { var source = @"class C { static void F(N.C o) { } static void F(global::C o) { } } namespace N { class C { static void F(N.C o) { } static void F(global::C o) { } } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "C.F(C)", "C.F(N.C)", "C.F(C)", "N.C.F(N.C)", "N.C.F(C)"); Resolve(process, resolver, "C.F(N.C)", "C.F(N.C)", "N.C.F(N.C)"); Resolve(process, resolver, "global::C.F(C)", "C.F(N.C)", "C.F(C)"); // Dev14 does not bind global:: Resolve(process, resolver, "C.F(global::C)", "C.F(C)", "N.C.F(C)"); // Dev14 does not bind global:: } }
public void Async() { var source = @"using System.Threading.Tasks; class C { static async Task F() { await Task.Delay(0); } }"; var compilation = CreateCompilationWithMscorlib46(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "C.F()"); } }
public void Iterator() { var source = @"class C { static System.Collections.IEnumerable F() { yield break; } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "C.F()"); } }
public void Dynamic() { var source = @"class C<T> { } class C { static void F(dynamic d) { } static void F(C<dynamic[]> d) { } }"; var compilation = CreateCompilationWithMscorlib(source, references: new[] { CSharpRef, SystemCoreRef }); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "C.F(System.Object)", "C.F(C<System.Object[]>)"); Resolve(process, resolver, "F(object)", "C.F(System.Object)"); Resolve(process, resolver, "F(C<object[]>)", "C.F(C<System.Object[]>)"); Resolve(process, resolver, "F(dynamic)"); Resolve(process, resolver, "F(C<dynamic[]>)"); } }
public void SpecialTypes_More() { var source = @"class C { static void F(System.IntPtr p) { } static void F(System.UIntPtr p) { } static void F(System.TypedReference r) { } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F(object)"); Resolve(process, resolver, "F(IntPtr)", "C.F(System.IntPtr)"); Resolve(process, resolver, "F(UIntPtr)", "C.F(System.UIntPtr)"); Resolve(process, resolver, "F(TypedReference)", "C.F(System.TypedReference)"); } }
public void ByRef() { var source = @"class @ref { } class @out { } class C { static void F(@out a, @ref b) { } static void F(ref @out a, out @ref b) { b = null; } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "C.F(out, ref)", "C.F(ref out, ref ref)"); Assert.Null(MemberSignatureParser.Parse("F(ref, out)")); Assert.Null(MemberSignatureParser.Parse("F(ref ref, out out)")); Resolve(process, resolver, "F(@out, @ref)", "C.F(out, ref)"); Resolve(process, resolver, "F(@out, out @ref)"); Resolve(process, resolver, "F(ref @out, @ref)"); Resolve(process, resolver, "F(ref @out, out @ref)", "C.F(ref out, ref ref)"); Resolve(process, resolver, "F(out @out, ref @ref)", "C.F(ref out, ref ref)"); } }
public void Methods() { var source = @"abstract class A { abstract internal object F(); } class B { object F() => null; } class C { static object F() => null; } interface I { object F(); }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "B.F()", "C.F()"); Resolve(process, resolver, "A.F"); Resolve(process, resolver, "B.F", "B.F()"); Resolve(process, resolver, "B.F()", "B.F()"); Resolve(process, resolver, "B.F(object)"); Resolve(process, resolver, "B.F<T>"); Resolve(process, resolver, "C.F", "C.F()"); } }
public void MissingMetadata() { var sourceA = @"class A { static void F1() { } static void F2() { } static void F3() { } static void F4() { } }"; var sourceC = @"class C { static void F1() { } static void F2() { } static void F3() { } static void F4() { } }"; var moduleA = new Module(CreateCompilationWithMscorlib(sourceA).EmitToArray(), name: "A.dll"); var moduleB = new Module(default(ImmutableArray<byte>), name: "B.dll"); var moduleC = new Module(CreateCompilationWithMscorlib(sourceC).EmitToArray(), name: "C.dll"); using (var process = new Process()) { var resolver = Resolver.CSharpResolver; var requestAll = new Request(null, MemberSignatureParser.Parse("F1")); var requestA = new Request("A.dll", MemberSignatureParser.Parse("F2")); var requestB = new Request("B.dll", MemberSignatureParser.Parse("F3")); var requestC = new Request("C.dll", MemberSignatureParser.Parse("F4")); // Request to all modules. resolver.EnableResolution(process, requestAll); Assert.Equal(0, moduleA.GetMetadataCount); Assert.Equal(0, moduleB.GetMetadataCount); Assert.Equal(0, moduleC.GetMetadataCount); // Load module A (available). process.AddModule(moduleA); resolver.OnModuleLoad(process, moduleA); Assert.Equal(1, moduleA.GetMetadataCount); Assert.Equal(0, moduleB.GetMetadataCount); Assert.Equal(0, moduleC.GetMetadataCount); VerifySignatures(requestAll, "A.F1()"); VerifySignatures(requestA); VerifySignatures(requestB); VerifySignatures(requestC); // Load module B (missing). process.AddModule(moduleB); resolver.OnModuleLoad(process, moduleB); Assert.Equal(1, moduleA.GetMetadataCount); Assert.Equal(1, moduleB.GetMetadataCount); Assert.Equal(0, moduleC.GetMetadataCount); VerifySignatures(requestAll, "A.F1()"); VerifySignatures(requestA); VerifySignatures(requestB); VerifySignatures(requestC); // Load module C (available). process.AddModule(moduleC); resolver.OnModuleLoad(process, moduleC); Assert.Equal(1, moduleA.GetMetadataCount); Assert.Equal(1, moduleB.GetMetadataCount); Assert.Equal(1, moduleC.GetMetadataCount); VerifySignatures(requestAll, "A.F1()", "C.F1()"); VerifySignatures(requestA); VerifySignatures(requestB); VerifySignatures(requestC); // Request to module A (available). resolver.EnableResolution(process, requestA); Assert.Equal(2, moduleA.GetMetadataCount); Assert.Equal(1, moduleB.GetMetadataCount); Assert.Equal(1, moduleC.GetMetadataCount); VerifySignatures(requestAll, "A.F1()", "C.F1()"); VerifySignatures(requestA, "A.F2()"); VerifySignatures(requestB); VerifySignatures(requestC); // Request to module B (missing). resolver.EnableResolution(process, requestB); Assert.Equal(2, moduleA.GetMetadataCount); Assert.Equal(2, moduleB.GetMetadataCount); Assert.Equal(1, moduleC.GetMetadataCount); VerifySignatures(requestAll, "A.F1()", "C.F1()"); VerifySignatures(requestA, "A.F2()"); VerifySignatures(requestB); VerifySignatures(requestC); // Request to module C (available). resolver.EnableResolution(process, requestC); Assert.Equal(2, moduleA.GetMetadataCount); Assert.Equal(2, moduleB.GetMetadataCount); Assert.Equal(2, moduleC.GetMetadataCount); VerifySignatures(requestAll, "A.F1()", "C.F1()"); VerifySignatures(requestA, "A.F2()"); VerifySignatures(requestB); VerifySignatures(requestC, "C.F4()"); } }
public void GenericMethods() { var source = @"class A { static void F() { } void F<T, U>() { } static void F<T>() { } } class A<T> { static void F() { } void F<U, V>() { } } class B : A<int> { static void F<T>() { } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { // Note, Dev14 matches type ignoring type parameters. For instance, // "A<T>.F" will bind to A.F() and A<T>.F(), and "A.F" will bind to A.F() // and A<T>.F. However, Dev14 does expect method type parameters to // match. Here, we expect both type and method parameters to match. var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "A.F", "A.F()"); Resolve(process, resolver, "A.F<U>()", "A.F<T>()"); Resolve(process, resolver, "A.F<T>", "A.F<T>()"); Resolve(process, resolver, "A.F<T, T>", "A.F<T, U>()"); Assert.Null(MemberSignatureParser.Parse("A.F<>()")); Assert.Null(MemberSignatureParser.Parse("A.F<,>()")); Resolve(process, resolver, "A<T>.F", "A<T>.F()"); Resolve(process, resolver, "A<_>.F<_>"); Resolve(process, resolver, "A<_>.F<_, _>", "A<T>.F<U, V>()"); Resolve(process, resolver, "B.F()"); Resolve(process, resolver, "B.F<T>()", "B.F<T>()"); Resolve(process, resolver, "B.F<T, U>()"); } }
public void ModuleName() { var sourceA = @"public struct A { static void F() { } }"; var nameA = GetUniqueName(); var compilationA = CreateCompilationWithMscorlib(sourceA, assemblyName: nameA); var imageA = compilationA.EmitToArray(); var refA = AssemblyMetadata.CreateFromImage(imageA).GetReference(); var sourceB = @"class B { static void F(A a) { } static void Main() { } }"; var nameB = GetUniqueName(); var compilationB = CreateCompilationWithMscorlib(sourceB, assemblyName: nameB, options: TestOptions.DebugExe, references: new[] { refA }); var imageB = compilationB.EmitToArray(); using (var process = new Process(new Module(imageA, nameA + ".dll"), new Module(imageB, nameB + ".exe"))) { var signature = MemberSignatureParser.Parse("F"); var resolver = Resolver.CSharpResolver; // No module name. var request = new Request("", signature); resolver.EnableResolution(process, request); VerifySignatures(request, "A.F()", "B.F(A)"); // DLL module name, uppercase. request = new Request(nameA.ToUpper() + ".DLL", signature); resolver.EnableResolution(process, request); VerifySignatures(request, "A.F()"); // EXE module name. request = new Request(nameB + ".EXE", signature); resolver.EnableResolution(process, request); VerifySignatures(request, "B.F(A)"); // EXE module name, lowercase. request = new Request(nameB.ToLower() + ".exe", signature); resolver.EnableResolution(process, request); VerifySignatures(request, "B.F(A)"); // EXE module name, no extension. request = new Request(nameB, signature); resolver.EnableResolution(process, request); VerifySignatures(request); } }
public void NestedTypes() { var source = @"class A { class B { static void F() { } } class B<T> { static void F<U>() { } } } class B { static void F() { } } namespace N { class A<T> { class B { static void F<U>() { } } class B<U> { static void F() { } } } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { // See comment in GenericMethods regarding differences with Dev14. var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "B.F()", "A.B.F()", "N.A<T>.B<U>.F()"); Resolve(process, resolver, "F<T>", "A.B<T>.F<U>()", "N.A<T>.B.F<U>()"); Resolve(process, resolver, "A.F"); Resolve(process, resolver, "A.B.F", "A.B.F()"); Resolve(process, resolver, "A.B.F<T>"); Resolve(process, resolver, "A.B<T>.F<U>", "A.B<T>.F<U>()"); Resolve(process, resolver, "A<T>.B.F<U>", "N.A<T>.B.F<U>()"); Resolve(process, resolver, "A<T>.B<U>.F", "N.A<T>.B<U>.F()"); Resolve(process, resolver, "B.F", "B.F()", "A.B.F()"); Resolve(process, resolver, "B.F<T>", "N.A<T>.B.F<U>()"); Resolve(process, resolver, "B<T>.F", "N.A<T>.B<U>.F()"); Resolve(process, resolver, "B<T>.F<U>", "A.B<T>.F<U>()"); Assert.Null(MemberSignatureParser.Parse("A+B.F")); Assert.Null(MemberSignatureParser.Parse("A.B`1.F<T>")); } }
public void ShouldEnableFunctionResolver() { var sourceA = @"class A { static void F() { } static void G() { } }"; var sourceB = @"class B { static void F() { } static void G() { } }"; var bytesA = CreateCompilationWithMscorlib(sourceA).EmitToArray(); var bytesB = CreateCompilationWithMscorlib(sourceB).EmitToArray(); var resolver = Resolver.CSharpResolver; // Two modules loaded before two global requests, // ... resolver enabled. var moduleA = new Module(bytesA, name: "A.dll"); var moduleB = new Module(bytesB, name: "B.dll"); using (var process = new Process(shouldEnable: true, modules: new[] { moduleA, moduleB })) { var requestF = new Request(null, MemberSignatureParser.Parse("F")); var requestG = new Request(null, MemberSignatureParser.Parse("G")); Assert.Equal(0, process.ShouldEnableRequests); resolver.EnableResolution(process, requestF); Assert.Equal(1, process.ShouldEnableRequests); resolver.EnableResolution(process, requestG); Assert.Equal(2, process.ShouldEnableRequests); VerifySignatures(requestF, "A.F()", "B.F()"); VerifySignatures(requestG, "A.G()", "B.G()"); } // ... resolver disabled. moduleA = new Module(bytesA, name: "A.dll"); moduleB = new Module(bytesB, name: "B.dll"); using (var process = new Process(shouldEnable: false, modules: new[] { moduleA, moduleB })) { var requestF = new Request(null, MemberSignatureParser.Parse("F")); var requestG = new Request(null, MemberSignatureParser.Parse("G")); Assert.Equal(0, process.ShouldEnableRequests); resolver.EnableResolution(process, requestF); Assert.Equal(1, process.ShouldEnableRequests); resolver.EnableResolution(process, requestG); Assert.Equal(2, process.ShouldEnableRequests); VerifySignatures(requestF); VerifySignatures(requestG); } // Two modules loaded before two requests for same module, // ... resolver enabled. moduleA = new Module(bytesA, name: "A.dll"); moduleB = new Module(bytesB, name: "B.dll"); using (var process = new Process(shouldEnable: true, modules: new[] { moduleA, moduleB })) { var requestF = new Request("B.dll", MemberSignatureParser.Parse("F")); var requestG = new Request("B.dll", MemberSignatureParser.Parse("G")); Assert.Equal(0, process.ShouldEnableRequests); resolver.EnableResolution(process, requestF); Assert.Equal(1, process.ShouldEnableRequests); resolver.EnableResolution(process, requestG); Assert.Equal(2, process.ShouldEnableRequests); VerifySignatures(requestF, "B.F()"); VerifySignatures(requestG, "B.G()"); } // ... resolver disabled. moduleA = new Module(bytesA, name: "A.dll"); moduleB = new Module(bytesB, name: "B.dll"); using (var process = new Process(shouldEnable: false, modules: new[] { moduleA, moduleB })) { var requestF = new Request("B.dll", MemberSignatureParser.Parse("F")); var requestG = new Request("B.dll", MemberSignatureParser.Parse("G")); Assert.Equal(0, process.ShouldEnableRequests); resolver.EnableResolution(process, requestF); Assert.Equal(1, process.ShouldEnableRequests); resolver.EnableResolution(process, requestG); Assert.Equal(2, process.ShouldEnableRequests); VerifySignatures(requestF); VerifySignatures(requestG); } // Two modules loaded after two global requests, // ... resolver enabled. moduleA = new Module(bytesA, name: "A.dll"); moduleB = new Module(bytesB, name: "B.dll"); using (var process = new Process(shouldEnable: true)) { var requestF = new Request(null, MemberSignatureParser.Parse("F")); var requestG = new Request(null, MemberSignatureParser.Parse("G")); resolver.EnableResolution(process, requestF); resolver.EnableResolution(process, requestG); Assert.Equal(0, process.ShouldEnableRequests); process.AddModule(moduleA); resolver.OnModuleLoad(process, moduleA); Assert.Equal(1, process.ShouldEnableRequests); VerifySignatures(requestF, "A.F()"); VerifySignatures(requestG, "A.G()"); process.AddModule(moduleB); resolver.OnModuleLoad(process, moduleB); Assert.Equal(2, process.ShouldEnableRequests); VerifySignatures(requestF, "A.F()", "B.F()"); VerifySignatures(requestG, "A.G()", "B.G()"); } // ... resolver enabled. moduleA = new Module(bytesA, name: "A.dll"); moduleB = new Module(bytesB, name: "B.dll"); using (var process = new Process(shouldEnable: false)) { var requestF = new Request(null, MemberSignatureParser.Parse("F")); var requestG = new Request(null, MemberSignatureParser.Parse("G")); resolver.EnableResolution(process, requestF); resolver.EnableResolution(process, requestG); Assert.Equal(0, process.ShouldEnableRequests); process.AddModule(moduleA); resolver.OnModuleLoad(process, moduleA); Assert.Equal(1, process.ShouldEnableRequests); VerifySignatures(requestF); VerifySignatures(requestG); process.AddModule(moduleB); resolver.OnModuleLoad(process, moduleB); Assert.Equal(2, process.ShouldEnableRequests); VerifySignatures(requestF); VerifySignatures(requestG); } // Two modules after two requests for same module, // ... resolver enabled. moduleA = new Module(bytesA, name: "A.dll"); moduleB = new Module(bytesB, name: "B.dll"); using (var process = new Process(shouldEnable: true)) { var requestF = new Request("A.dll", MemberSignatureParser.Parse("F")); var requestG = new Request("A.dll", MemberSignatureParser.Parse("G")); resolver.EnableResolution(process, requestF); resolver.EnableResolution(process, requestG); Assert.Equal(0, process.ShouldEnableRequests); process.AddModule(moduleA); resolver.OnModuleLoad(process, moduleA); Assert.Equal(1, process.ShouldEnableRequests); VerifySignatures(requestF, "A.F()"); VerifySignatures(requestG, "A.G()"); process.AddModule(moduleB); resolver.OnModuleLoad(process, moduleB); Assert.Equal(2, process.ShouldEnableRequests); VerifySignatures(requestF, "A.F()"); VerifySignatures(requestG, "A.G()"); } // ... resolver enabled. moduleA = new Module(bytesA, name: "A.dll"); moduleB = new Module(bytesB, name: "B.dll"); using (var process = new Process(shouldEnable: false)) { var requestF = new Request("A.dll", MemberSignatureParser.Parse("F")); var requestG = new Request("A.dll", MemberSignatureParser.Parse("G")); resolver.EnableResolution(process, requestF); resolver.EnableResolution(process, requestG); Assert.Equal(0, process.ShouldEnableRequests); process.AddModule(moduleA); resolver.OnModuleLoad(process, moduleA); Assert.Equal(1, process.ShouldEnableRequests); VerifySignatures(requestF); VerifySignatures(requestG); process.AddModule(moduleB); resolver.OnModuleLoad(process, moduleB); Assert.Equal(2, process.ShouldEnableRequests); VerifySignatures(requestF); VerifySignatures(requestG); } }
public void NamespacesAndTypes_More() { var source = @"namespace A1.B { class C { static void F(C c) { } } } namespace A2 { class B { internal class C { static void F(C c) { } static void F(A1.B.C c) { } } } } class A3 { internal class B { internal class C { static void F(C c) { } static void F(A2.B.C c) { } } } } namespace B { class C { static void F(C c) { } static void F(A3.B.C c) { } } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F(C)", "B.C.F(B.C)", "B.C.F(A3.B.C)", "A1.B.C.F(A1.B.C)", "A2.B.C.F(A2.B.C)", "A2.B.C.F(A1.B.C)", "A3.B.C.F(A3.B.C)", "A3.B.C.F(A2.B.C)"); Resolve(process, resolver, "B.C.F(B.C)", "B.C.F(B.C)", "B.C.F(A3.B.C)", "A1.B.C.F(A1.B.C)", "A2.B.C.F(A2.B.C)", "A2.B.C.F(A1.B.C)", "A3.B.C.F(A3.B.C)", "A3.B.C.F(A2.B.C)"); Resolve(process, resolver, "B.C.F(A1.B.C)", "A1.B.C.F(A1.B.C)", "A2.B.C.F(A1.B.C)"); Resolve(process, resolver, "B.C.F(A2.B.C)", "A2.B.C.F(A2.B.C)", "A3.B.C.F(A2.B.C)"); Resolve(process, resolver, "B.C.F(A3.B.C)", "B.C.F(A3.B.C)", "A3.B.C.F(A3.B.C)"); } }
public void Arrays() { var source = @"class A { } class B { static void F(A o) { } static void F(A[] o) { } static void F(A[,,] o) { } static void F(A[,,][] o) { } static void F(A[][,,] o) { } static void F(A[][][] o) { } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "B.F(A)", "B.F(A[])", "B.F(A[,,])", "B.F(A[][,,])", "B.F(A[,,][])", "B.F(A[][][])"); Resolve(process, resolver, "F(A)", "B.F(A)"); Resolve(process, resolver, "F(A[])", "B.F(A[])"); Resolve(process, resolver, "F(A[][])"); Resolve(process, resolver, "F(A[,])"); Resolve(process, resolver, "F(A[,,])", "B.F(A[,,])"); Resolve(process, resolver, "F(A[,,][])", "B.F(A[,,][])"); Resolve(process, resolver, "F(A[][,,])", "B.F(A[][,,])"); Resolve(process, resolver, "F(A[,][,,])"); Resolve(process, resolver, "F(A[][][])", "B.F(A[][][])"); Resolve(process, resolver, "F(A[][][][])"); } }
public void DifferentCase_MethodsAndProperties() { var source = @"class A { static void method() { } static void Method(object o) { } object property => null; } class B { static void Method() { } object Property { get; set; } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.VisualBasicResolver; Resolve(process, resolver, "method", "A.method()", "A.Method(System.Object)", "B.Method()"); Resolve(process, resolver, "Method", "A.method()", "A.Method(System.Object)", "B.Method()"); Resolve(process, resolver, "[property]", "A.get_property()", "B.get_Property()", "B.set_Property(System.Object)"); Resolve(process, resolver, "[Property]", "A.get_property()", "B.get_Property()", "B.set_Property(System.Object)"); Resolve(process, resolver, "[PROPERTY]", "A.get_property()", "B.get_Property()", "B.set_Property(System.Object)"); Resolve(process, resolver, "GET_PROPERTY", "A.get_property()", "B.get_Property()"); } }
public void Pointers() { var source = @"class C { static unsafe void F(int*[] p) { } static unsafe void F(int** q) { } }"; var compilation = CreateCompilationWithMscorlib(source, options: TestOptions.UnsafeDebugDll); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "C.F(System.Int32*[])", "C.F(System.Int32**)"); Resolve(process, resolver, "F(int)"); Resolve(process, resolver, "F(int*)"); Resolve(process, resolver, "F(int[])"); Resolve(process, resolver, "F(int*[])", "C.F(System.Int32*[])"); Resolve(process, resolver, "F(int**)", "C.F(System.Int32**)"); Resolve(process, resolver, "F(Int32**)", "C.F(System.Int32**)"); Resolve(process, resolver, "F(C<int*>)"); Resolve(process, resolver, "F(C<int>*)"); } }
private static void Resolve(Process process, Resolver resolver, string str, params string[] expectedSignatures) { var signature = MemberSignatureParser.Parse(str); Assert.NotNull(signature); Resolve(process, resolver, signature, expectedSignatures); }
public void Nullable() { var source = @"struct S { void F(S? o) { } static void F(int?[] o) { } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "S.F(System.Nullable<S>)", "S.F(System.Nullable<System.Int32>[])"); Resolve(process, resolver, "F(S)"); Resolve(process, resolver, "F(S?)", "S.F(System.Nullable<S>)"); Resolve(process, resolver, "F(S??)"); Resolve(process, resolver, "F(int?[])", "S.F(System.Nullable<System.Int32>[])"); } }
public void Properties() { var source = @"abstract class A { abstract internal object P { get; set; } } class B { object P { get; set; } } class C { static object P { get; } } class D { int P { set { } } } interface I { object P { get; set; } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.VisualBasicResolver; Resolve(process, resolver, "P", "B.get_P()", "B.set_P(System.Object)", "C.get_P()", "D.set_P(System.Int32)"); Resolve(process, resolver, "A.P"); Resolve(process, resolver, "B.P", "B.get_P()", "B.set_P(System.Object)"); Resolve(process, resolver, "B.P()"); Resolve(process, resolver, "B.P(Object)"); Resolve(process, resolver, "B.P(Of T)"); Resolve(process, resolver, "C.P", "C.get_P()"); Resolve(process, resolver, "C.P()"); Resolve(process, resolver, "D.P", "D.set_P(System.Int32)"); Resolve(process, resolver, "D.P()"); Resolve(process, resolver, "D.P(Object)"); Resolve(process, resolver, "get_P", "B.get_P()", "C.get_P()"); Resolve(process, resolver, "set_P", "B.set_P(System.Object)", "D.set_P(System.Int32)"); Resolve(process, resolver, "B.get_P()", "B.get_P()"); Resolve(process, resolver, "B.set_P", "B.set_P(System.Object)"); } }
public void EscapedNames() { var source = @"class @object { } class Object { } class C { static void F(@object o) { } static void F(Object o) { } static void F(object o) { } }"; var compilation = CreateCompilationWithMscorlib(source); using (var process = new Process(new Module(compilation.EmitToArray()))) { var resolver = Resolver.CSharpResolver; Resolve(process, resolver, "F", "C.F(object)", "C.F(Object)", "C.F(System.Object)"); Resolve(process, resolver, "F(object)", "C.F(System.Object)"); Resolve(process, resolver, "F(Object)", "C.F(Object)", "C.F(System.Object)"); Resolve(process, resolver, "F(System.Object)", "C.F(System.Object)"); Resolve(process, resolver, "F(@object)", "C.F(object)"); Resolve(process, resolver, "F(@Object)", "C.F(Object)", "C.F(System.Object)"); } }