public void MangledNames_StaticMembers() { var il = @" .class public auto ansi beforefieldinit '<>Mangled' extends [mscorlib]System.Object { .field public static int32 x .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ldarg.0 call instance void [mscorlib]System.Object::.ctor() ret } } .class public auto ansi beforefieldinit 'NotMangled' extends '<>Mangled' { .field public static int32 y .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ldarg.0 call instance void '<>Mangled'::.ctor() ret } } "; ImmutableArray <byte> assemblyBytes; ImmutableArray <byte> pdbBytes; CSharpTestBase.EmitILToArray(il, appendDefaultHeader: true, includePdb: false, assemblyBytes: out assemblyBytes, pdbBytes: out pdbBytes); var assembly = ReflectionUtilities.Load(assemblyBytes); var baseValue = CreateDkmClrValue(assembly.GetType("<>Mangled").Instantiate()); var root = FormatResult("o", baseValue); var children = GetChildren(root); Verify(children, EvalResult("Static members", null, "", null, DkmEvaluationResultFlags.Expandable | DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Class)); Verify(GetChildren(children.Single()), EvalResult("x", "0", "int", null)); var derivedValue = CreateDkmClrValue(assembly.GetType("NotMangled").Instantiate()); root = FormatResult("o", derivedValue); children = GetChildren(root); Verify(children, EvalResult("Static members", null, "", "NotMangled", DkmEvaluationResultFlags.Expandable | DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Class)); Verify(GetChildren(children.Single()), EvalResult("x", "0", "int", null, DkmEvaluationResultFlags.None, DkmEvaluationResultCategory.Data, DkmEvaluationResultAccessType.Public), EvalResult("y", "0", "int", "NotMangled.y", DkmEvaluationResultFlags.None, DkmEvaluationResultCategory.Data, DkmEvaluationResultAccessType.Public)); }
public void MangledNames_CastRequired() { var il = @" .class public auto ansi beforefieldinit '<>Mangled' extends [mscorlib]System.Object { .field public int32 x .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ldarg.0 call instance void [mscorlib]System.Object::.ctor() ret } } .class public auto ansi beforefieldinit 'NotMangled' extends '<>Mangled' { .field public int32 x .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ldarg.0 call instance void '<>Mangled'::.ctor() ret } } "; ImmutableArray <byte> assemblyBytes; ImmutableArray <byte> pdbBytes; CSharpTestBase.EmitILToArray( il, appendDefaultHeader: true, includePdb: false, assemblyBytes: out assemblyBytes, pdbBytes: out pdbBytes ); var assembly = ReflectionUtilities.Load(assemblyBytes); var value = CreateDkmClrValue(assembly.GetType("NotMangled").Instantiate()); var root = FormatResult("o", value); Verify( GetChildren(root), EvalResult("x (<>Mangled)", "0", "int", null), EvalResult("x", "0", "int", "o.x", DkmEvaluationResultFlags.CanFavorite) ); }
public void MangledNames_ArrayElement() { var il = @" .class public auto ansi beforefieldinit '<>Mangled' extends [mscorlib]System.Object { .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ldarg.0 call instance void [mscorlib]System.Object::.ctor() ret } } .class public auto ansi beforefieldinit NotMangled extends [mscorlib]System.Object { .field public class [mscorlib]System.Collections.Generic.IEnumerable`1<class '<>Mangled'> 'array' .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ldarg.0 ldc.i4.1 newarr '<>Mangled' stfld class [mscorlib]System.Collections.Generic.IEnumerable`1<class '<>Mangled'> NotMangled::'array' ldarg.0 call instance void [mscorlib]System.Object::.ctor() ret } } "; ImmutableArray <byte> assemblyBytes; ImmutableArray <byte> pdbBytes; CSharpTestBase.EmitILToArray(il, appendDefaultHeader: true, includePdb: false, assemblyBytes: out assemblyBytes, pdbBytes: out pdbBytes); var assembly = ReflectionUtilities.Load(assemblyBytes); var value = CreateDkmClrValue(assembly.GetType("NotMangled").Instantiate()); var root = FormatResult("o", value); var children = GetChildren(root); Verify(children, EvalResult("array", "{<>Mangled[1]}", "System.Collections.Generic.IEnumerable<<>Mangled> {<>Mangled[]}", "o.array", DkmEvaluationResultFlags.Expandable)); Verify(GetChildren(children.Single()), EvalResult("[0]", "null", "<>Mangled", null)); }
public void BackTick_FirstCharacter() { var il = @" .class public auto ansi beforefieldinit '`1'<T> extends [mscorlib]System.Object { .field public static int32 'x' .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ldarg.0 call instance void [mscorlib]System.Object::.ctor() ret } } "; ImmutableArray <byte> assemblyBytes; ImmutableArray <byte> pdbBytes; CSharpTestBase.EmitILToArray( il, appendDefaultHeader: true, includePdb: false, assemblyBytes: out assemblyBytes, pdbBytes: out pdbBytes ); var assembly = ReflectionUtilities.Load(assemblyBytes); var value = CreateDkmClrValue( assembly.GetType("`1").MakeGenericType(typeof(int)).Instantiate() ); var root = FormatResult("o", value); var children = GetChildren(root); Verify( children, EvalResult( "Static members", null, "", null, DkmEvaluationResultFlags.Expandable | DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Class ) ); Verify(GetChildren(children.Single()), EvalResult("x", "0", "int", fullName: null)); }
public void BackTick_Member() { // IL doesn't support using generic methods as property accessors so // there's no way to test a "legitimate" backtick in a member name. var il = @" .class public auto ansi beforefieldinit C extends [mscorlib]System.Object { .field public static int32 'x`1' .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ldarg.0 call instance void [mscorlib]System.Object::.ctor() ret } } "; ImmutableArray <byte> assemblyBytes; ImmutableArray <byte> pdbBytes; CSharpTestBase.EmitILToArray( il, appendDefaultHeader: true, includePdb: false, assemblyBytes: out assemblyBytes, pdbBytes: out pdbBytes ); var assembly = ReflectionUtilities.Load(assemblyBytes); var value = CreateDkmClrValue(assembly.GetType("C").Instantiate()); var root = FormatResult("o", value); var children = GetChildren(root); Verify( children, EvalResult( "Static members", null, "", "C", DkmEvaluationResultFlags.Expandable | DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Class ) ); Verify(GetChildren(children.Single()), EvalResult("x`1", "0", "int", fullName: null)); }
public void MangledNames_PointerDereference() { var il = @" .class public auto ansi beforefieldinit '<>Mangled' extends [mscorlib]System.Object { .field private static int32* p .method assembly hidebysig specialname rtspecialname instance void .ctor(int64 arg) cil managed { IL_0000: ldarg.0 IL_0001: call instance void [mscorlib]System.Object::.ctor() IL_0008: ldarg.1 IL_0009: conv.u IL_000a: stsfld int32* '<>Mangled'::p IL_0010: ret } } // end of class '<>Mangled' "; ImmutableArray <byte> assemblyBytes; ImmutableArray <byte> pdbBytes; CSharpTestBase.EmitILToArray(il, appendDefaultHeader: true, includePdb: false, assemblyBytes: out assemblyBytes, pdbBytes: out pdbBytes); var assembly = ReflectionUtilities.Load(assemblyBytes); unsafe { int i = 4; long p = (long)&i; var type = assembly.GetType("<>Mangled"); var rootExpr = "m"; var value = CreateDkmClrValue(type.Instantiate(p)); var evalResult = FormatResult(rootExpr, value); Verify(evalResult, EvalResult(rootExpr, "{<>Mangled}", "<>Mangled", rootExpr, DkmEvaluationResultFlags.Expandable)); var children = GetChildren(evalResult); Verify(children, EvalResult("Static members", null, "", null, DkmEvaluationResultFlags.Expandable | DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Class)); children = GetChildren(children.Single()); Verify(children, EvalResult("p", PointerToString(new IntPtr(p)), "int*", null, DkmEvaluationResultFlags.Expandable)); children = GetChildren(children.Single()); Verify(children, EvalResult("*p", "4", "int", null)); } }
public void MangledNames_ExplicitInterfaceImplementation() { var il = @" .class interface public abstract auto ansi 'I<>Mangled' { .method public hidebysig newslot specialname abstract virtual instance int32 get_P() cil managed { } .property instance int32 P() { .get instance int32 'I<>Mangled'::get_P() } } // end of class 'I<>Mangled' .class public auto ansi beforefieldinit C extends [mscorlib]System.Object implements 'I<>Mangled' { .method private hidebysig newslot specialname virtual final instance int32 'I<>Mangled.get_P'() cil managed { .override 'I<>Mangled'::get_P ldc.i4.1 ret } .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ldarg.0 call instance void [mscorlib]System.Object::.ctor() ret } .property instance int32 'I<>Mangled.P'() { .get instance int32 C::'I<>Mangled.get_P'() } .property instance int32 P() { .get instance int32 C::'I<>Mangled.get_P'() } } // end of class C "; ImmutableArray <byte> assemblyBytes; ImmutableArray <byte> pdbBytes; CSharpTestBase.EmitILToArray(il, appendDefaultHeader: true, includePdb: false, assemblyBytes: out assemblyBytes, pdbBytes: out pdbBytes); var assembly = ReflectionUtilities.Load(assemblyBytes); var value = CreateDkmClrValue(assembly.GetType("C").Instantiate()); var root = FormatResult("instance", value); Verify(GetChildren(root), EvalResult("I<>Mangled.P", "1", "int", null, DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Property, DkmEvaluationResultAccessType.Private), EvalResult("P", "1", "int", "instance.P", DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Property, DkmEvaluationResultAccessType.Private)); }
public void MangledNames_DebuggerTypeProxy() { var il = @" .class public auto ansi beforefieldinit Type extends [mscorlib]System.Object { .custom instance void [mscorlib]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [mscorlib]System.Type) = {type('<>Mangled')} .field public bool x .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ldarg.0 ldc.i4.0 stfld bool Type::x ldarg.0 call instance void [mscorlib]System.Object::.ctor() ret } // end of method Type::.ctor } // end of class Type .class public auto ansi beforefieldinit '<>Mangled' extends [mscorlib]System.Object { .field public bool y .method public hidebysig specialname rtspecialname instance void .ctor(class Type s) cil managed { ldarg.0 ldc.i4.1 stfld bool '<>Mangled'::y ldarg.0 call instance void [mscorlib]System.Object::.ctor() ret } // end of method '<>Mangled'::.ctor } // end of class '<>Mangled' "; ImmutableArray <byte> assemblyBytes; ImmutableArray <byte> pdbBytes; CSharpTestBase.EmitILToArray( il, appendDefaultHeader: true, includePdb: false, assemblyBytes: out assemblyBytes, pdbBytes: out pdbBytes ); var assembly = ReflectionUtilities.Load(assemblyBytes); var value = CreateDkmClrValue(assembly.GetType("Type").Instantiate()); var root = FormatResult("o", value); var children = GetChildren(root); Verify( children, EvalResult( "y", "true", "bool", null, DkmEvaluationResultFlags.Boolean | DkmEvaluationResultFlags.BooleanTrue ), EvalResult( "Raw View", null, "", "o, raw", DkmEvaluationResultFlags.Expandable | DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Data ) ); var grandChildren = GetChildren(children.Last()); Verify( grandChildren, EvalResult("x", "false", "bool", "o.x", DkmEvaluationResultFlags.Boolean) ); }
public void TypeVariables() { var source0 = @"class A { } class B : A { internal static object F = 1; }"; var assembly0 = GetAssembly(source0); var type0 = assembly0.GetType("B"); var source1 = @".class private abstract sealed beforefieldinit specialname '<>c__TypeVariables'<T,U> { .method public hidebysig specialname rtspecialname instance void .ctor() { ret } }"; ImmutableArray <byte> assemblyBytes; ImmutableArray <byte> pdbBytes; CSharpTestBase.EmitILToArray( source1, appendDefaultHeader: true, includePdb: false, assemblyBytes: out assemblyBytes, pdbBytes: out pdbBytes ); var assembly1 = ReflectionUtilities.Load(assemblyBytes); var type1 = assembly1 .GetType(ExpressionCompilerConstants.TypeVariablesClassName) .MakeGenericType(new[] { typeof(int), type0 }); var value = CreateDkmClrValue( value: null, type: type1, valueFlags: DkmClrValueFlags.Synthetic ); var evalResult = FormatResult("typevars", value); Verify( evalResult, EvalResult( "Type variables", "", "", null, DkmEvaluationResultFlags.Expandable | DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Data ) ); var children = GetChildren(evalResult); Verify( children, EvalResult( "T", "int", "int", null, DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Data ), EvalResult( "U", "B", "B", null, DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Data ) ); }