internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints = null, string source = null)
{
Dictionary <int, string> markers = null;
if (sequencePoints != null)
{
var actualPdbXml = PdbToXmlConverter.ToXml(
pdbStream: new MemoryStream(EmittedAssemblyPdb.ToArray()),
peStream: new MemoryStream(EmittedAssemblyData.ToArray()),
options: PdbToXmlOptions.ResolveTokens |
PdbToXmlOptions.ThrowOnError |
PdbToXmlOptions.ExcludeDocuments |
PdbToXmlOptions.ExcludeCustomDebugInformation |
PdbToXmlOptions.ExcludeScopes,
methodName: sequencePoints);
markers = ILValidation.GetSequencePointMarkers(actualPdbXml, source);
}
if (!realIL)
{
return(ILBuilderVisualizer.ILBuilderToString(methodData.ILBuilder, markers: markers));
}
if (_lazyModuleSymbol == null)
{
var targetReference = LoadTestEmittedExecutableForSymbolValidation(EmittedAssemblyData, _compilation.Options.OutputKind, display: _compilation.AssemblyName);
_lazyModuleSymbol = GetSymbolFromMetadata(targetReference, MetadataImportOptions.All);
}
return(_lazyModuleSymbol != null?_visualizeRealIL(_lazyModuleSymbol, methodData, markers) : null);
}
internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints = null)
{
Dictionary <int, string> markers = null;
if (sequencePoints != null)
{
var actualPdbXml = PdbToXmlConverter.ToXml(
pdbStream: new MemoryStream(EmittedAssemblyPdb.ToArray()),
peStream: new MemoryStream(EmittedAssemblyData.ToArray()),
options: PdbToXmlOptions.ResolveTokens |
PdbToXmlOptions.ThrowOnError |
PdbToXmlOptions.ExcludeDocuments |
PdbToXmlOptions.ExcludeCustomDebugInformation |
PdbToXmlOptions.ExcludeScopes,
methodName: sequencePoints);
markers = PdbValidation.GetMarkers(actualPdbXml);
}
if (!realIL)
{
return(ILBuilderVisualizer.ILBuilderToString(methodData.ILBuilder, markers: markers));
}
if (_lazyModuleSymbol == null)
{
_lazyModuleSymbol = GetModuleSymbolForEmittedImage(EmittedAssemblyData, MetadataImportOptions.All);
}
return(_lazyModuleSymbol != null?_test.VisualizeRealIL(_lazyModuleSymbol, methodData, markers) : null);
}
internal static void VerifyIL(
this CompilationTestData.MethodData method,
string expectedIL,
[CallerLineNumber] int expectedValueSourceLine = 0,
[CallerFilePath] string expectedValueSourcePath = null
)
{
const string moduleNamePlaceholder = "{#Module#}";
string actualIL = GetMethodIL(method);
if (expectedIL.IndexOf(moduleNamePlaceholder) >= 0)
{
var module = method.Method.ContainingModule;
var moduleName = Path.GetFileNameWithoutExtension(module.Name);
expectedIL = expectedIL.Replace(moduleNamePlaceholder, moduleName);
}
AssertEx.AssertEqualToleratingWhitespaceDifferences(
expectedIL,
actualIL,
escapeQuotes: true,
expectedValueSourcePath: expectedValueSourcePath,
expectedValueSourceLine: expectedValueSourceLine
);
}
private static void VerifyMethodData(CompilationTestData.MethodData methodData, string expectedType, string expectedIL)
{
methodData.VerifyIL(expectedIL);
var method = (MethodSymbol)methodData.Method;
VerifyTypeParameters(method);
Assert.Equal(expectedType, method.ReturnType.ToTestDisplayString());
}
internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints = null, string source = null)
{
Dictionary <int, string> markers = null;
if (sequencePoints != null)
{
if (EmittedAssemblyPdb == null)
{
throw new InvalidOperationException($"{nameof(EmittedAssemblyPdb)} is not set");
}
if (EmittedAssemblyData == null)
{
throw new InvalidOperationException($"{nameof(EmittedAssemblyData)} is not set");
}
var actualPdbXml = PdbToXmlConverter.ToXml(
pdbStream: new MemoryStream(EmittedAssemblyPdb.ToArray()),
peStream: new MemoryStream(EmittedAssemblyData.ToArray()),
options: PdbToXmlOptions.ResolveTokens |
PdbToXmlOptions.ThrowOnError |
PdbToXmlOptions.ExcludeDocuments |
PdbToXmlOptions.ExcludeCustomDebugInformation |
PdbToXmlOptions.ExcludeScopes,
methodName: sequencePoints);
if (actualPdbXml.StartsWith("<error>"))
{
throw new Exception($"Failed to extract PDB information for method '{sequencePoints}'. PdbToXmlConverter returned:\r\n{actualPdbXml}");
}
markers = ILValidation.GetSequencePointMarkers(actualPdbXml, source);
}
if (!realIL)
{
return(ILBuilderVisualizer.ILBuilderToString(methodData.ILBuilder, markers: markers));
}
if (_lazyModuleSymbol == null)
{
var targetReference = LoadTestEmittedExecutableForSymbolValidation(EmittedAssemblyData, _compilation.Options.OutputKind, display: _compilation.AssemblyName);
_lazyModuleSymbol = GetSymbolFromMetadata(targetReference, MetadataImportOptions.All);
}
if (_lazyModuleSymbol != null)
{
if (_visualizeRealIL == null)
{
throw new InvalidOperationException("IL visualization function is not set");
}
return(_visualizeRealIL(_lazyModuleSymbol, methodData, markers, _testData.Module.GetMethodBody(methodData.Method).AreLocalsZeroed));
}
return(null);
}
internal static EditAndContinueMethodDebugInformation GetEncDebugInfo(this CompilationTestData.MethodData methodData)
{
// TODO:
return(new EditAndContinueMethodDebugInformation(
0,
Cci.MetadataWriter.GetLocalSlotDebugInfos(methodData.ILBuilder.LocalSlotManager.LocalsInOrder()),
closures: ImmutableArray <ClosureDebugInfo> .Empty,
lambdas: ImmutableArray <LambdaDebugInfo> .Empty));
}
internal static void VerifyIL(
this CompilationTestData.MethodData method,
string expectedIL,
[CallerLineNumber] int expectedValueSourceLine = 0,
[CallerFilePath] string expectedValueSourcePath = null)
{
string actualIL = GetMethodIL(method);
AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes: true, expectedValueSourcePath: expectedValueSourcePath, expectedValueSourceLine: expectedValueSourceLine);
}
private string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, bool useRefEmitter)
{
if (!realIL)
{
return(ILBuilderVisualizer.ILBuilderToString(methodData.ILBuilder));
}
var module = this.GetModuleSymbolForEmittedImage();
return(module != null?test.VisualizeRealIL(module, methodData) : null);
}
/// <summary>
/// Returns a string representation of IL read from metadata.
/// </summary>
/// <remarks>
/// Currently unsupported IL decoding:
/// - multidimensional arrays
/// - vararg calls
/// - winmd
/// - global methods
/// </remarks>
internal unsafe static string VisualizeRealIL(PEModuleSymbol peModule, CompilationTestData.MethodData methodData, IReadOnlyDictionary <int, string> markers)
{
var typeName = GetContainingTypeMetadataName(methodData.Method);
// TODO (tomat): global methods (typeName == null)
var type = peModule.ContainingAssembly.GetTypeByMetadataName(typeName);
// TODO (tomat): overloaded methods
var method = (PEMethodSymbol)type.GetMembers(methodData.Method.MetadataName).Single();
var bodyBlock = peModule.Module.GetMethodBodyOrThrow(method.Handle);
Assert.NotNull(bodyBlock);
var moduleDecoder = new MetadataDecoder(peModule);
var peMethod = (PEMethodSymbol)moduleDecoder.GetSymbolForILToken(method.Handle);
StringBuilder sb = new StringBuilder();
var ilBytes = bodyBlock.GetILContent();
var ehHandlerRegions = ILVisualizer.GetHandlerSpans(bodyBlock.ExceptionRegions);
var methodDecoder = new MetadataDecoder(peModule, peMethod);
ImmutableArray <ILVisualizer.LocalInfo> localDefinitions;
if (!bodyBlock.LocalSignature.IsNil)
{
var signature = peModule.Module.MetadataReader.GetStandaloneSignature(bodyBlock.LocalSignature).Signature;
var signatureReader = peModule.Module.GetMemoryReaderOrThrow(signature);
var localInfos = methodDecoder.DecodeLocalSignatureOrThrow(ref signatureReader);
localDefinitions = ToLocalDefinitions(localInfos, methodData.ILBuilder);
}
else
{
localDefinitions = ImmutableArray.Create <ILVisualizer.LocalInfo>();
}
// TODO (tomat): the .maxstack in IL can't be less than 8, but many tests expect .maxstack < 8
int maxStack = (bodyBlock.MaxStack == 8 && methodData.ILBuilder.MaxStack < 8) ? methodData.ILBuilder.MaxStack : bodyBlock.MaxStack;
var visualizer = new Visualizer(new MetadataDecoder(peModule, peMethod));
visualizer.DumpMethod(sb, maxStack, ilBytes, localDefinitions, ehHandlerRegions, markers);
return(sb.ToString());
}
private string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints, bool useRefEmitter)
{
Dictionary <int, string> markers = null;
if (sequencePoints != null)
{
var actualPdbXml = PdbToXmlConverter.ToXml(
pdbStream: new MemoryStream(EmittedAssemblyPdb.ToArray()),
peStream: new MemoryStream(EmittedAssemblyData.ToArray()),
options: PdbToXmlOptions.ResolveTokens | PdbToXmlOptions.ThrowOnError,
methodName: sequencePoints);
markers = GetMarkers(actualPdbXml);
}
if (!realIL)
{
return(ILBuilderVisualizer.ILBuilderToString(methodData.ILBuilder, markers: markers));
}
var module = this.GetModuleSymbolForEmittedImage();
return(module != null?_test.VisualizeRealIL(module, methodData, markers) : null);
}
internal override string VisualizeRealIL(IModuleSymbol peModule, CompilationTestData.MethodData methodData, IReadOnlyDictionary <int, string> markers)
{
return(VisualizeRealIL((PEModuleSymbol)peModule, methodData, markers));
}
internal static Func <MethodDefinitionHandle, EditAndContinueMethodDebugInformation> EncDebugInfoProvider(this CompilationTestData.MethodData methodData)
{
return(_ => methodData.GetEncDebugInfo());
}
internal static string GetMethodIL(this CompilationTestData.MethodData method)
{
return(ILBuilderVisualizer.ILBuilderToString(method.ILBuilder));
}
internal override string VisualizeRealIL(
IModuleSymbol peModule,
CompilationTestData.MethodData methodData,
IReadOnlyDictionary <int, string> markers,
bool areLocalsZeroed
) => throw new NotImplementedException();
internal static EditAndContinueMethodDebugInformation GetEncDebugInfo(this CompilationTestData.MethodData methodData)
{
return(Cci.CustomDebugInfoWriter.GetEncDebugInfoForLocals(methodData.ILBuilder.LocalSlotManager.LocalsInOrder()));
}
internal static void VerifyIL(this CompilationTestData.MethodData method, string expectedIL)
{
string actualIL = GetMethodIL(method);
AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL);
}
internal abstract string VisualizeRealIL(IModuleSymbol peModule, CompilationTestData.MethodData methodData);
internal static ImmutableArray <string> GetLocalNames(CompilationTestData.MethodData methodData)
{
var locals = methodData.ILBuilder.LocalSlotManager.LocalsInOrder();
return(locals.SelectAsArray(l => l.Name));
}
private static bool TryGetMethodData(ImmutableDictionary <string, CompilationTestData.MethodData> map, string qualifiedMethodName, out CompilationTestData.MethodData methodData)
{
if (map.TryGetValue(qualifiedMethodName, out methodData))
{
return(true);
}
// caller may not have specified parameter list, so try to match parameterless method
if (map.TryGetValue(qualifiedMethodName + "()", out methodData))
{
return(true);
}
// now try to match single method with any parameter list
var keys = map.Keys.Where(k => k.StartsWith(qualifiedMethodName + "(", StringComparison.Ordinal));
if (keys.Count() == 1)
{
methodData = map[keys.First()];
return(true);
}
else if (keys.Count() > 1)
{
throw new AmbiguousMatchException(
"Could not determine best match for method named: " + qualifiedMethodName + Environment.NewLine +
string.Join(Environment.NewLine, keys.Select(s => " " + s)) + Environment.NewLine);
}
else
{
return(false);
}
}
internal abstract string VisualizeRealIL(IModuleSymbol peModule, CompilationTestData.MethodData methodData, IReadOnlyDictionary <int, string> markers);
internal static bool TryGetMethodData(this CompilationTestData data, string qualifiedMethodName, out CompilationTestData.MethodData methodData)
{
var map = data.GetMethodsByName();
return(TryGetMethodData(map, qualifiedMethodName, out methodData));
}
internal override string VisualizeRealIL(IModuleSymbol peModule, CompilationTestData.MethodData methodData)
{
return(VisualizeRealIL((PEModuleSymbol)peModule, methodData));
}
> EncDebugInfoProvider(this CompilationTestData.MethodData methodData)
{
return(_ => methodData.GetEncDebugInfo());
}
