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 MangledTypeParameterName()
{
var il = @"
.class public auto ansi beforefieldinit Type`1<'<>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
}
}
";
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 type = assembly.GetType("Type`1");
var typeName = type.GetTypeName();
Assert.Equal("Type<<>Mangled>", typeName);
}
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 PdbFileNotFound()
{
var dir = Temp.CreateDirectory();
var dllFile = dir.CreateFile("lib.dll");
var source = @"class C { public static void Main() { int x = 1; } }";
var compilation = CSharpTestBase.CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll, assemblyName: "lib");
var pdbStream = new MemoryStream();
var debugDirPdbPath = Path.Combine(dir.Path, "nonexistent.pdb");
var peImage = compilation.EmitToArray(new EmitOptions(debugInformationFormat: DebugInformationFormat.PortablePdb, pdbFilePath: debugDirPdbPath), pdbStream: pdbStream);
pdbStream.Position = 0;
dllFile.WriteAllBytes(peImage);
var outputs = new CompilationOutputFilesWithImplicitPdbPath(dllFile.Path);
Assert.Null(outputs.OpenPdb());
using (var metadata = outputs.OpenAssemblyMetadata(prefetch: false))
{
var mdReader = metadata.GetMetadataReader();
Assert.Equal("lib", mdReader.GetString(mdReader.GetAssemblyDefinition().Name));
}
// make sure all files are closed and can be deleted
Directory.Delete(dir.Path, recursive: true);
}
public void RemoveDocCommentNode()
{
var oldSource =
@"
/// <see cref='C'/>
class C { }
";
var expectedNewSource =
@"
///
class C { }
";
var oldTree = CSharpTestBase.Parse(
oldSource,
options: TestOptions.RegularWithDocumentationComments
);
var oldRoot = oldTree.GetRoot();
var xmlNode = oldRoot
.DescendantNodes(descendIntoTrivia: true)
.OfType <XmlEmptyElementSyntax>()
.Single();
var newRoot = oldRoot.RemoveNode(xmlNode, SyntaxRemoveOptions.KeepDirectives);
Assert.Equal(expectedNewSource, newRoot.ToFullString());
}
public void IsTupleCompatible_InvalidName()
{
var source =
@".class sealed System.ValueTuple`3<T1, T2> extends [mscorlib]System.ValueType
{
.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(source, appendDefaultHeader: true, includePdb: false, assemblyBytes: out assemblyBytes, pdbBytes: out pdbBytes);
var runtime = new DkmClrRuntimeInstance(ReflectionUtilities.GetMscorlib(ReflectionUtilities.Load(assemblyBytes)));
using (runtime.Load())
{
var type = runtime.GetType("System.ValueTuple`3", typeof(object), typeof(int));
int cardinality;
Assert.False(type.GetLmrType().IsTupleCompatible(out cardinality));
Assert.Equal(0, cardinality);
var value = type.Instantiate();
var evalResult = FormatResult("o", value);
Verify(evalResult,
EvalResult("o", "{System.ValueTuple<object, int>}", "System.ValueTuple<object, int>", "o"));
}
}
public void AssemblyAndPdb()
{
var source = @"class C { public static void Main() { int x = 1; } }";
var compilation = CSharpTestBase.CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll, assemblyName: "lib");
var pdbStream = new MemoryStream();
var peImage = compilation.EmitToArray(new EmitOptions(debugInformationFormat: DebugInformationFormat.PortablePdb), pdbStream: pdbStream);
pdbStream.Position = 0;
var dir = Temp.CreateDirectory();
var dllFile = dir.CreateFile("a.dll").WriteAllBytes(peImage);
var pdbFile = dir.CreateFile("a.pdb").WriteAllBytes(pdbStream.ToArray());
var outputs = new CompilationOutputFiles(dllFile.Path, pdbFile.Path);
using (var pdb = outputs.OpenPdb())
{
var encReader = pdb.CreateEditAndContinueMethodDebugInfoReader();
Assert.True(encReader.IsPortable);
var localSig = encReader.GetLocalSignature(MetadataTokens.MethodDefinitionHandle(1));
Assert.Equal(MetadataTokens.StandaloneSignatureHandle(1), localSig);
}
using (var metadata = outputs.OpenAssemblyMetadata(prefetch: false))
{
var mdReader = metadata.GetMetadataReader();
Assert.Equal("lib", mdReader.GetString(mdReader.GetAssemblyDefinition().Name));
}
// make sure all files are closed and can be deleted
Directory.Delete(dir.Path, recursive: true);
}
public static void TestDiagnostics(string source, params string[] diagStrings)
{
var comp = CSharpTestBase.CreateCompilation(source);
var diagnostics = comp.GetDiagnostics();
CompilingTestBase.TestDiagnostics(diagnostics, diagStrings);
}
protected override SyntaxTree ParseSyntaxTree(string content, string fileName, SourceHashAlgorithm hashAlgorithm, CSharpParseOptions?parseOptions) =>
CSharpTestBase.Parse(
content,
filename: fileName,
checksumAlgorithm: hashAlgorithm,
encoding: Encoding.UTF8,
options: parseOptions);
public void AddedSources_Are_Deterministic()
{
// a few manual simple ones
AdditionalSourcesCollection asc = new AdditionalSourcesCollection(".cs");
asc.Add("file3.cs", SourceText.From("", Encoding.UTF8));
asc.Add("file1.cs", SourceText.From("", Encoding.UTF8));
asc.Add("file2.cs", SourceText.From("", Encoding.UTF8));
asc.Add("file5.cs", SourceText.From("", Encoding.UTF8));
asc.Add("file4.cs", SourceText.From("", Encoding.UTF8));
var sources = asc.ToImmutableAndFree();
var hintNames = sources.Select(s => s.HintName).ToArray();
Assert.Equal(
new[] { "file3.cs", "file1.cs", "file2.cs", "file5.cs", "file4.cs" },
hintNames
);
// generate a long random list, remembering the order we added them
Random r = new Random();
string[] names = new string[1000];
asc = new AdditionalSourcesCollection(".cs");
for (int i = 0; i < 1000; i++)
{
names[i] = CSharpTestBase.GetUniqueName() + ".cs";
asc.Add(names[i], SourceText.From("", Encoding.UTF8));
}
sources = asc.ToImmutableAndFree();
hintNames = sources.Select(s => s.HintName).ToArray();
Assert.Equal(names, hintNames);
}
public void MangledTypeParameterName()
{
var il = @"
.class public auto ansi beforefieldinit Type`1<'<>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
}
}
";
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 type = assembly.GetType("Type`1");
bool sawInvalidIdentifier;
var typeName = CSharpFormatter.Instance.GetTypeName(new TypeAndCustomInfo((TypeImpl)type), escapeKeywordIdentifiers: true, sawInvalidIdentifier: out sawInvalidIdentifier);
Assert.True(sawInvalidIdentifier);
Assert.Equal("Type<<>Mangled>", typeName);
}
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));
}
public void DebugInfo(DebugInformationFormat format, bool useSymReader)
{
var source = @"
using System;
delegate void D();
class C
{
public static void Main()
{
int x = 1;
D d = () => Console.Write(x);
d();
}
}
";
var compilation = CSharpTestBase.CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll, sourceFileName: "/a/c.cs");
var pdbStream = new MemoryStream();
compilation.EmitToArray(new EmitOptions(debugInformationFormat: format), pdbStream: pdbStream);
pdbStream.Position = 0;
DebugInformationReaderProvider provider;
EditAndContinueMethodDebugInfoReader reader;
if (format == DebugInformationFormat.PortablePdb && useSymReader)
{
var pdbStreamCom = SymUnmanagedStreamFactory.CreateStream(pdbStream);
var metadataImportProvider = new DummyMetadataImportProvider();
Assert.Equal(0, new SymBinder().GetReaderFromPdbStream(metadataImportProvider, pdbStreamCom, out var symReader));
reader = EditAndContinueMethodDebugInfoReader.Create((ISymUnmanagedReader5)symReader, version: 1);
}
else
{
provider = DebugInformationReaderProvider.CreateFromStream(pdbStream);
reader = provider.CreateEditAndContinueMethodDebugInfoReader();
}
// Main method
var debugInfo = reader.GetDebugInfo(MetadataTokens.MethodDefinitionHandle(5));
Assert.Equal(0, debugInfo.GetMethodOrdinal());
AssertEx.Equal(new[] { "Offset=0 Ordinal=0 Kind=LambdaDisplayClass", "Offset=33 Ordinal=0 Kind=UserDefined" }, debugInfo.InspectLocalSlots());
AssertEx.Equal(new[] { "Offset=43 Id=0#0 Closure=0" }, debugInfo.InspectLambdas());
AssertEx.Equal(new[] { "Offset=0 Id=0#0" }, debugInfo.InspectClosures());
var localSig = reader.GetLocalSignature(MetadataTokens.MethodDefinitionHandle(5));
Assert.Equal(MetadataTokens.StandaloneSignatureHandle(1), localSig);
// method without debug information:
debugInfo = reader.GetDebugInfo(MetadataTokens.MethodDefinitionHandle(1));
Assert.Equal(-1, debugInfo.GetMethodOrdinal());
Assert.Null(debugInfo.InspectLocalSlots());
Assert.Null(debugInfo.InspectLambdas());
Assert.Null(debugInfo.InspectClosures());
localSig = reader.GetLocalSignature(MetadataTokens.MethodDefinitionHandle(1));
Assert.Equal(default, localSig);
public static void TestDiagnosticsExact(string source, params string[] diagStrings)
{
var comp = CSharpTestBase.CreateCompilation(source);
var diagnostics = comp.GetDiagnostics();
Assert.Equal(diagStrings.Length, diagnostics.Length);
CompilingTestBase.TestDiagnostics(diagnostics, diagStrings);
}
/// <summary>
/// OBSOLETE: Use VerifyDiagnostics from Roslyn.Compilers.CSharp.Test.Utilities instead.
/// </summary>
internal protected static CSharpCompilation VerifyErrorsAndGetCompilationWithMscorlib(string[] srcs, params ErrorDescription[] expectedErrorDesp)
{
var comp = CSharpTestBase.CreateCompilation(srcs);
var actualErrors = comp.GetDiagnostics();
VerifyErrorCodes(actualErrors, expectedErrorDesp);
return(comp);
}
public static Assembly GetUnsafeAssembly(string source)
{
var comp = CSharpTestBase.CreateCompilationWithMscorlib45AndCSharp(
source,
options: TestOptions.UnsafeReleaseDll
);
return(ReflectionUtilities.Load(comp.EmitToArray()));
}
// This method should be removed once the lambda discard parameters feature is slotted into a C# language version
public new static CSharpCompilation CreateCompilation(
CSharpTestSource source,
System.Collections.Generic.IEnumerable <MetadataReference> references = null,
CSharpCompilationOptions options = null,
CSharpParseOptions parseOptions = null,
Roslyn.Test.Utilities.TargetFramework targetFramework = Roslyn.Test.Utilities.TargetFramework.Standard,
string assemblyName = "",
string sourceFileName = "",
bool skipUsesIsNullable = false)
=> CSharpTestBase.CreateCompilation(source, references, options, parseOptions: parseOptions ?? TestOptions.RegularPreview, targetFramework, assemblyName, sourceFileName, skipUsesIsNullable);
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 static CSharpCompilation CreateStandardCompilation(
string text,
IEnumerable <MetadataReference> references = null,
CSharpCompilationOptions options = null,
CSharpParseOptions parseOptions = null,
string assemblyName = "",
string sourceFileName = "")
{
return(CreateStandardCompilation(
new[] { CSharpTestBase.Parse(text, sourceFileName, parseOptions) },
references: references,
options: options,
assemblyName: assemblyName));
}
internal static CompilationVerifier CompileAndVerifyOnWin8Only(
this CSharpTestBase testBase,
string source,
MetadataReference[] additionalRefs = null,
string expectedOutput = null)
{
var isWin8 = OSVersion.IsWin8;
return(testBase.CompileAndVerifyWithWinRt(
source,
references: additionalRefs,
expectedOutput: isWin8 ? expectedOutput : null,
verify: isWin8 ? Verification.Passes : Verification.Fails));
}
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 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));
}
}
internal static ImmutableArray <SynthesizedAttributeData> GetSynthesizedAttributes(this Symbol symbol, bool forReturnType = false)
{
var builder = CSharpTestBase.GetDefaultPEBuilder(symbol.DeclaringCompilation);
ArrayBuilder <SynthesizedAttributeData> attributes = null;
if (!forReturnType)
{
symbol.AddSynthesizedAttributes(builder, ref attributes);
}
else
{
Assert.True(symbol.Kind == SymbolKind.Method, "Incorrect usage of GetSynthesizedAttributes");
((MethodSymbol)symbol).AddSynthesizedReturnTypeAttributes(builder, ref attributes);
}
return(attributes != null?attributes.ToImmutableAndFree() : ImmutableArray.Create <SynthesizedAttributeData>());
}
public void ExplicitEmbeddedType()
{
var source =
@"using System.Runtime.InteropServices;
[TypeIdentifier]
[Guid(""863D5BC0-46A1-49AD-97AA-A5F0D441A9D8"")]
public interface I
{
object F();
}
class C
{
void M()
{
var o = (I)null;
}
static void Main()
{
(new C()).M();
}
}";
var compilation0 = CSharpTestBase.CreateCompilationWithMscorlib(
source,
options: TestOptions.DebugExe,
assemblyName: ExpressionCompilerUtilities.GenerateUniqueName());
var runtime = CreateRuntimeInstance(compilation0);
var context = CreateMethodContext(runtime, "C.M");
ResultProperties resultProperties;
string error;
var testData = new CompilationTestData();
var result = context.CompileExpression("this", out resultProperties, out error, testData);
Assert.Null(error);
testData.GetMethodData("<>x.<>m0").VerifyIL(
@"{
// Code size 2 (0x2)
.maxstack 1
.locals init (I V_0) //o
IL_0000: ldarg.0
IL_0001: ret
}");
}
public void AssemblyAndPdb(DebugInformationFormat format)
{
var source = @"class C { public static void Main() { int x = 1; } }";
var compilation = CSharpTestBase.CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll, assemblyName: "lib");
var pdbStream = (format != DebugInformationFormat.Embedded) ? new MemoryStream() : null;
var peImage = compilation.EmitToArray(new EmitOptions(debugInformationFormat: format), pdbStream: pdbStream);
Stream currentPEStream = null;
Stream currentPdbStream = null;
var outputs = new TestCompilationOutputs(
openAssemblyStream: () => currentPEStream = new MemoryStream(peImage.ToArray()),
openPdbStream: () =>
{
if (pdbStream == null)
{
return(null);
}
currentPdbStream = new MemoryStream();
pdbStream.Position = 0;
pdbStream.CopyTo(currentPdbStream);
currentPdbStream.Position = 0;
return(currentPdbStream);
});
using (var pdb = outputs.OpenPdb())
{
var encReader = pdb.CreateEditAndContinueMethodDebugInfoReader();
Assert.Equal(format != DebugInformationFormat.Pdb, encReader.IsPortable);
var localSig = encReader.GetLocalSignature(MetadataTokens.MethodDefinitionHandle(1));
Assert.Equal(MetadataTokens.StandaloneSignatureHandle(1), localSig);
}
if (format == DebugInformationFormat.Embedded)
{
Assert.Throws <ObjectDisposedException>(() => currentPEStream.Length);
}
else
{
Assert.Throws <ObjectDisposedException>(() => currentPdbStream.Length);
}
using (var metadata = outputs.OpenAssemblyMetadata(prefetch: false))
{
Assert.NotEqual(0, currentPEStream.Length);
var mdReader = metadata.GetMetadataReader();
Assert.Equal("lib", mdReader.GetString(mdReader.GetAssemblyDefinition().Name));
}
Assert.Throws <ObjectDisposedException>(() => currentPEStream.Length);
using (var metadata = outputs.OpenAssemblyMetadata(prefetch: true))
{
// the stream has been closed since we prefetched the metadata:
Assert.Throws <ObjectDisposedException>(() => currentPEStream.Length);
var mdReader = metadata.GetMetadataReader();
Assert.Equal("lib", mdReader.GetString(mdReader.GetAssemblyDefinition().Name));
}
Assert.NotEqual(Guid.Empty, outputs.ReadAssemblyModuleVersionId());
}
public void HideNonPublicMembersBaseClass()
{
var sourceA =
@"public class A
{
public object FA0;
internal object FA1;
protected internal object FA2;
protected object FA3;
private object FA4;
public object PA0 { get { return null; } }
internal object PA1 { get { return null; } }
protected internal object PA2 { get { return null; } }
protected object PA3 { get { return null; } }
private object PA4 { get { return null; } }
public object PA5 { set { } }
public object PA6 { internal get; set; }
public object PA7 { protected internal get; set; }
public object PA8 { protected get; set; }
public object PA9 { private get; set; }
internal object PAA { private get; set; }
protected internal object PAB { internal get; set; }
protected internal object PAC { protected get; set; }
protected object PAD { private get; set; }
public static object SFA0;
internal static object SFA1;
protected static internal object SPA2 { get { return null; } }
protected static object SPA3 { get { return null; } }
public static object SPA4 { private get { return null; } set { } }
}";
var sourceB =
@"public class B : A
{
public object FB0;
internal object FB1;
protected internal object FB2;
protected object FB3;
private object FB4;
public object PB0 { get { return null; } }
internal object PB1 { get { return null; } }
protected internal object PB2 { get { return null; } }
protected object PB3 { get { return null; } }
private object PB4 { get { return null; } }
public object PB5 { set { } }
public object PB6 { internal get; set; }
public object PB7 { protected internal get; set; }
public object PB8 { protected get; set; }
public object PB9 { private get; set; }
internal object PBA { private get; set; }
protected internal object PBB { internal get; set; }
protected internal object PBC { protected get; set; }
protected object PBD { private get; set; }
public static object SPB0 { get { return null; } }
public static object SPB1 { internal get { return null; } set { } }
protected static internal object SFB2;
protected static object SFB3;
private static object SFB4;
}
class C
{
A a = new B();
}";
// Derived class in assembly with PDB,
// base class in assembly without PDB.
var compilationA = CSharpTestBase.CreateCompilation(sourceA, options: TestOptions.ReleaseDll);
var bytesA = compilationA.EmitToArray();
var referenceA = MetadataReference.CreateFromImage(bytesA);
var compilationB = CSharpTestBase.CreateCompilation(sourceB, options: TestOptions.DebugDll, references: new MetadataReference[] { referenceA });
var bytesB = compilationB.EmitToArray();
var assemblyA = ReflectionUtilities.Load(bytesA);
var assemblyB = ReflectionUtilities.Load(bytesB);
DkmClrValue value;
using (ReflectionUtilities.LoadAssemblies(assemblyA, assemblyB))
{
var runtime = new DkmClrRuntimeInstance(new[] { assemblyB });
var type = assemblyB.GetType("C", throwOnError: true);
value = CreateDkmClrValue(
Activator.CreateInstance(type),
runtime.GetType((TypeImpl)type));
}
var rootExpr = "new C()";
var evalResult = FormatResult(rootExpr, value, inspectionContext: CreateDkmInspectionContext(DkmEvaluationFlags.HideNonPublicMembers));
Verify(evalResult,
EvalResult(rootExpr, "{C}", "C", rootExpr, DkmEvaluationResultFlags.Expandable));
var children = GetChildren(evalResult);
Verify(children,
EvalResult("a", "{B}", "A {B}", "(new C()).a", DkmEvaluationResultFlags.Expandable));
// The native EE includes properties where the setter is accessible but the getter is not.
// We treat those properties as non-public.
children = GetChildren(children[0]);
Verify(children,
EvalResult("FA0", "null", "object", "(new C()).a.FA0"),
EvalResult("FA2", "null", "object", "(new C()).a.FA2"),
EvalResult("FA3", "null", "object", "(new C()).a.FA3"),
EvalResult("FB0", "null", "object", "((B)(new C()).a).FB0"),
EvalResult("FB1", "null", "object", "((B)(new C()).a).FB1"),
EvalResult("FB2", "null", "object", "((B)(new C()).a).FB2"),
EvalResult("FB3", "null", "object", "((B)(new C()).a).FB3"),
EvalResult("FB4", "null", "object", "((B)(new C()).a).FB4"),
EvalResult("PA0", "null", "object", "(new C()).a.PA0", DkmEvaluationResultFlags.ReadOnly),
EvalResult("PA2", "null", "object", "(new C()).a.PA2", DkmEvaluationResultFlags.ReadOnly),
EvalResult("PA3", "null", "object", "(new C()).a.PA3", DkmEvaluationResultFlags.ReadOnly),
EvalResult("PA7", "null", "object", "(new C()).a.PA7"),
EvalResult("PA8", "null", "object", "(new C()).a.PA8"),
EvalResult("PAC", "null", "object", "(new C()).a.PAC"),
EvalResult("PB0", "null", "object", "((B)(new C()).a).PB0", DkmEvaluationResultFlags.ReadOnly),
EvalResult("PB1", "null", "object", "((B)(new C()).a).PB1", DkmEvaluationResultFlags.ReadOnly),
EvalResult("PB2", "null", "object", "((B)(new C()).a).PB2", DkmEvaluationResultFlags.ReadOnly),
EvalResult("PB3", "null", "object", "((B)(new C()).a).PB3", DkmEvaluationResultFlags.ReadOnly),
EvalResult("PB4", "null", "object", "((B)(new C()).a).PB4", DkmEvaluationResultFlags.ReadOnly),
EvalResult("PB6", "null", "object", "((B)(new C()).a).PB6"),
EvalResult("PB7", "null", "object", "((B)(new C()).a).PB7"),
EvalResult("PB8", "null", "object", "((B)(new C()).a).PB8"),
EvalResult("PB9", "null", "object", "((B)(new C()).a).PB9"),
EvalResult("PBA", "null", "object", "((B)(new C()).a).PBA"),
EvalResult("PBB", "null", "object", "((B)(new C()).a).PBB"),
EvalResult("PBC", "null", "object", "((B)(new C()).a).PBC"),
EvalResult("PBD", "null", "object", "((B)(new C()).a).PBD"),
EvalResult("Static members", null, "", "B", DkmEvaluationResultFlags.Expandable | DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Class),
EvalResult("Non-Public members", null, "", "(new C()).a, hidden", DkmEvaluationResultFlags.Expandable | DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Data));
// Static members
var more = GetChildren(children[children.Length - 2]);
Verify(more,
EvalResult("SFA0", "null", "object", "A.SFA0"),
EvalResult("SFB2", "null", "object", "B.SFB2"),
EvalResult("SFB3", "null", "object", "B.SFB3"),
EvalResult("SFB4", "null", "object", "B.SFB4"),
EvalResult("SPA2", "null", "object", "A.SPA2", DkmEvaluationResultFlags.ReadOnly),
EvalResult("SPA3", "null", "object", "A.SPA3", DkmEvaluationResultFlags.ReadOnly),
EvalResult("SPB0", "null", "object", "B.SPB0", DkmEvaluationResultFlags.ReadOnly),
EvalResult("SPB1", "null", "object", "B.SPB1"),
EvalResult("Non-Public members", null, "", "B, hidden", DkmEvaluationResultFlags.Expandable | DkmEvaluationResultFlags.ReadOnly, DkmEvaluationResultCategory.Data));
// Non-Public static members
more = GetChildren(more[more.Length - 1]);
Verify(more,
EvalResult("SFA1", "null", "object", "A.SFA1"),
EvalResult("SPA4", "null", "object", "A.SPA4"));
// Non-Public members
more = GetChildren(children[children.Length - 1]);
Verify(more,
EvalResult("FA1", "null", "object", "(new C()).a.FA1"),
EvalResult("FA4", "null", "object", "(new C()).a.FA4"),
EvalResult("PA1", "null", "object", "(new C()).a.PA1", DkmEvaluationResultFlags.ReadOnly),
EvalResult("PA4", "null", "object", "(new C()).a.PA4", DkmEvaluationResultFlags.ReadOnly),
EvalResult("PA6", "null", "object", "(new C()).a.PA6"),
EvalResult("PA9", "null", "object", "(new C()).a.PA9"),
EvalResult("PAA", "null", "object", "(new C()).a.PAA"),
EvalResult("PAB", "null", "object", "(new C()).a.PAB"),
EvalResult("PAD", "null", "object", "(new C()).a.PAD"));
}
internal static CSharpCompilation WithSource(this CSharpCompilation compilation, string newSource)
{
return(compilation.RemoveAllSyntaxTrees().AddSyntaxTrees(CSharpTestBase.Parse(newSource)));
}
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));
}
