private int CombineHashCodes(IModuleSymbol x, int currentHash)
{
// TODO(cyrusn): what's the right thing to do here?
return(symbolEquivalenceComparer.assembliesCanDiffer
? Hash.Combine(typeof(IModuleSymbol), currentHash)
: Hash.Combine(x.Name, currentHash));
}
public override void VisitModule(IModuleSymbol symbol)
{
foreach (var namespaceOrTypeSymbol in symbol.GlobalNamespace.GetMembers())
{
namespaceOrTypeSymbol.Accept(this);
}
}
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 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);
}
public override void VisitModule(IModuleSymbol symbol)
{
_output.AppendLine(new string(' ', 2 * _indent) + symbol.GetType().Name + " " + symbol.Name);
_indent++;
VisitChildren(symbol.GlobalNamespace);
_indent--;
}
public virtual TResult VisitModule(IModuleSymbol symbol)
{
#pragma warning disable CS8717 // A member returning a [MaybeNull] value introduces a null value when 'TResult' is a non-nullable reference type.
return(DefaultVisit(symbol));
#pragma warning restore CS8717 // A member returning a [MaybeNull] value introduces a null value when 'TResult' is a non-nullable reference type.
}
public static bool IsLocallyPublic(this ISymbol symbol, IModuleSymbol currentSymbol) =>
symbol.DeclaredAccessibility == Accessibility.Public
||
(
symbol.Locations.Any(l => SymbolEqualityComparer.Default.Equals(l.MetadataModule, currentSymbol)) &&
symbol.DeclaredAccessibility == Accessibility.Internal
);
/// <summary>
/// Returns true if the symbol can be accessed from the current module
/// </summary>
/// <param name="symbol"></param>
/// <returns></returns>
public static bool IsLocallyPublic(this ISymbol symbol, IModuleSymbol currentSymbol) =>
symbol.DeclaredAccessibility == Accessibility.Public
||
(
symbol.Locations.Any(l => l.MetadataModule == currentSymbol) &&
symbol.DeclaredAccessibility == Accessibility.Internal
);
public override int VisitModule(IModuleSymbol symbol, StringBuilder argument)
{
argument.AppendLine(new string(' ', 2 * _indent) + symbol.GetType().Name + " " + symbol.Name);
_indent++;
VisitChildren(new[] { symbol.GlobalNamespace }, argument);
_indent--;
return(_indent);
}
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);
}
public void Execute(GeneratorExecutionContext context)
{
try
{
var validPlatform = PlatformHelper.IsValidPlatform(context);
var isDesignTime = DesignTimeHelper.IsDesignTime(context);
var isApplication = IsApplication(context);
if (validPlatform &&
!isDesignTime)
{
if (isApplication)
{
_defaultNamespace = context.GetMSBuildPropertyValue("RootNamespace");
_namedSymbolsLookup = context.Compilation.GetSymbolNameLookup();
_bindableAttributeSymbol = FindBindableAttributes(context);
_dependencyPropertySymbol = context.Compilation.GetTypeByMetadataName(XamlConstants.Types.DependencyProperty);
_objectSymbol = context.Compilation.GetTypeByMetadataName("System.Object");
_javaObjectSymbol = context.Compilation.GetTypeByMetadataName("Java.Lang.Object");
_nsObjectSymbol = context.Compilation.GetTypeByMetadataName("Foundation.NSObject");
_stringSymbol = context.Compilation.GetTypeByMetadataName("System.String");
_nonBindableSymbol = context.Compilation.GetTypeByMetadataName("Windows.UI.Xaml.Data.NonBindableAttribute");
_resourceDictionarySymbol = context.Compilation.GetTypeByMetadataName("Windows.UI.Xaml.ResourceDictionary");
_currentModule = context.Compilation.SourceModule;
AnalyzerSuppressions = new string[0];
var modules = from ext in context.Compilation.ExternalReferences
let sym = context.Compilation.GetAssemblyOrModuleSymbol(ext) as IAssemblySymbol
where sym != null
from module in sym.Modules
select module;
modules = modules.Concat(context.Compilation.SourceModule);
context.AddSource("BindableMetadata", GenerateTypeProviders(modules));
}
else
{
context.AddSource("BindableMetadata", $"// validPlatform: {validPlatform} designTime:{isDesignTime} isApplication:{isApplication}");
}
}
}
catch (Exception e)
{
var message = e.Message + e.StackTrace;
if (e is AggregateException)
{
message = (e as AggregateException).InnerExceptions.Select(ex => ex.Message + e.StackTrace).JoinBy("\r\n");
}
this.Log().Error("Failed to generate type providers.", new Exception("Failed to generate type providers." + message, e));
}
}
internal PENetModuleBuilder(
PhpCompilation compilation,
IModuleSymbol sourceModule,
EmitOptions emitOptions,
Microsoft.Cci.ModulePropertiesForSerialization serializationProperties,
IEnumerable<ResourceDescription> manifestResources)
: base(compilation, (Symbols.SourceModuleSymbol)sourceModule, serializationProperties, manifestResources, OutputKind.NetModule, emitOptions)
{
}
internal override string VisualizeRealIL(
IModuleSymbol peModule,
MethodData methodData,
IReadOnlyDictionary <int, string> markers,
bool areLocalsZeroed
)
{
throw new NotImplementedException();
}
internal PENetModuleBuilder(
PhpCompilation compilation,
IModuleSymbol sourceModule,
EmitOptions emitOptions,
Cci.ModulePropertiesForSerialization serializationProperties,
IEnumerable <ResourceDescription> manifestResources)
: base(compilation, (Symbols.SourceModuleSymbol)sourceModule, serializationProperties, manifestResources, OutputKind.NetModule, emitOptions)
{
}
public HtmlElementInfo GenerateHyperlink(
string symbolId,
ISymbol symbol,
IModuleSymbol moduleSymbol,
bool isLargeFile,
out string destinationAssemblyName)
{
destinationAssemblyName = GetAssemblyFromSymbol(symbol);
return(GenerateHyperlink(symbolId, destinationAssemblyName, isLargeFile));
}
public static IEnumerable <ITypeSymbol> EnumAllTypes(this IModuleSymbol module)
{
foreach (var metadataTypeAdapter in module.GlobalNamespace.EnumAllNamespaces().SelectMany(n => n.GetTypeMembers()))
{
yield return(metadataTypeAdapter);
foreach (var nestedType in metadataTypeAdapter.EnumAllNestedTypes())
{
yield return(nestedType);
}
}
}
private static IEnumerable <INamedTypeSymbol> GetNamespaceTypes(IModuleSymbol module)
{
foreach (var type in module.GlobalNamespace.GetNamespaceTypes())
{
yield return(type);
foreach (var inner in type.GetTypeMembers())
{
yield return(inner);
}
}
}
public override Node VisitModule(IModuleSymbol symbol)
{
var node = this._graph.AddNode(GetId(symbol));
node.LabelText = symbol.Name;
node.Label.FontColor = Color.White;
node.Attr.FillColor = Color.DarkOrange;
var child = this.Visit(symbol.GlobalNamespace);
this._graph.AddEdge(node.Id, child.Id);
return(node);
}
public override void Execute(SourceGeneratorContext context)
{
try
{
if (PlatformHelper.IsValidPlatform(context))
{
var project = context.GetProjectInstance();
if (IsApplication(project))
{
_defaultNamespace = project.GetPropertyValue("RootNamespace");
_bindableAttributeSymbol = FindBindableAttributes(context);
_dependencyPropertySymbol = context.Compilation.GetTypeByMetadataName(XamlConstants.Types.DependencyProperty);
_objectSymbol = context.Compilation.GetTypeByMetadataName("System.Object");
_javaObjectSymbol = context.Compilation.GetTypeByMetadataName("Java.Lang.Object");
_nsObjectSymbol = context.Compilation.GetTypeByMetadataName("Foundation.NSObject");
_stringSymbol = context.Compilation.GetTypeByMetadataName("System.String");
_nonBindableSymbol = context.Compilation.GetTypeByMetadataName("Windows.UI.Xaml.Data.NonBindableAttribute");
_currentModule = context.Compilation.SourceModule;
AnalyzerSuppressions = new string[0];
var modules = from ext in context.Compilation.ExternalReferences
let sym = context.Compilation.GetAssemblyOrModuleSymbol(ext) as IAssemblySymbol
where sym != null
from module in sym.Modules
select module;
modules = modules.Concat(context.Compilation.SourceModule);
context.AddCompilationUnit("BindableMetadata", GenerateTypeProviders(modules));
}
}
}
catch (Exception e)
{
var message = e.Message + e.StackTrace;
if (e is AggregateException)
{
message = (e as AggregateException).InnerExceptions.Select(ex => ex.Message + e.StackTrace).JoinBy("\r\n");
}
this.Log().Error("Failed to generate type providers.", new Exception("Failed to generate type providers." + message, e));
}
}
private static INamedTypeSymbol FindTypeByMetadataName(IModuleSymbol module, string metadataName)
{
var components = metadataName.Split('.');
INamespaceSymbol ns = module.GlobalNamespace;
List <string> unmatched = new List <string>();
for (int i = 0; i < components.Length - 1; ++i)
{
unmatched.Add(components[i]);
string search = String.Join(".", unmatched);
var child = ns.GetNamespaceMembers().FirstOrDefault(n => n.Name == search);
if (child != null)
{
ns = child;
unmatched.Clear();
}
}
return(ns.GetMembers(components.Last()).OfType <INamedTypeSymbol>().FirstOrDefault());
}
private IModuleSymbol GetModuleSymbolForEmittedImage(ref IModuleSymbol moduleSymbol, ImmutableArray <byte> peImage)
{
if (peImage.IsDefault)
{
return(null);
}
if (moduleSymbol == null)
{
Debug.Assert(!peImage.IsDefault);
var targetReference = LoadTestEmittedExecutableForSymbolValidation(peImage, _compilation.Options.OutputKind, display: _compilation.AssemblyName);
var references = _compilation.References.Concat(new[] { targetReference });
var assemblies = _test.ReferencesToModuleSymbols(references, _compilation.Options.MetadataImportOptions);
var module = assemblies.Last();
moduleSymbol = module;
}
return(moduleSymbol);
}
public sealed override void VisitModule(IModuleSymbol symbol)
{
throw ExceptionUtilities.UnexpectedValue(symbol.Kind);
}
public virtual TResult?VisitModule(IModuleSymbol symbol)
{
return(DefaultVisit(symbol));
}
internal override string VisualizeRealIL(IModuleSymbol peModule, CodeAnalysis.CodeGen.CompilationTestData.MethodData methodData, IReadOnlyDictionary<int, string> markers)
{
throw new NotImplementedException();
}
public override void VisitModule(IModuleSymbol symbol)
{
}
private int CombineHashCodes(IModuleSymbol x, int currentHash) => CombineHashCodes(x.ContainingAssembly, Hash.Combine(x.Name, currentHash));
public override void VisitModule(IModuleSymbol symbol)
{
Visit(symbol.GlobalNamespace);
base.VisitModule(symbol);
}
private bool ModulesAreEquivalent(IModuleSymbol x, IModuleSymbol y)
{
return AssembliesAreEquivalent(x.ContainingAssembly, y.ContainingAssembly) && x.Name == y.Name;
}
public override void VisitModule(IModuleSymbol symbol)
{
builder.Add(CreatePart(SymbolDisplayPartKind.ModuleName, symbol, symbol.Name));
}
public sealed override void VisitModule(IModuleSymbol symbol)
{
throw ExceptionUtilities.UnexpectedValue(symbol.Kind);
}
internal override string VisualizeRealIL(IModuleSymbol peModule, CompilationTestData.MethodData methodData)
{
return(VisualizeRealIL((PEModuleSymbol)peModule, methodData));
}
public HtmlElementInfo GenerateHyperlink(
string symbolId,
ISymbol symbol,
IModuleSymbol moduleSymbol,
bool isLargeFile,
out string destinationAssemblyName)
{
destinationAssemblyName = GetAssemblyFromSymbol(symbol);
return GenerateHyperlink(symbolId, destinationAssemblyName, isLargeFile);
}
public static void Create(IModuleSymbol symbol, SymbolKeyWriter visitor) => visitor.WriteSymbolKey(symbol.ContainingSymbol);
private bool ModulesAreEquivalent(IModuleSymbol x, IModuleSymbol y)
{
// TODO(cyrusn): What's the right thing to do here?
return _symbolEquivalenceComparer._assembliesCanDiffer || x.Name == y.Name;
}
internal abstract string VisualizeRealIL(IModuleSymbol peModule, CompilationTestData.MethodData methodData, IReadOnlyDictionary <int, string> markers);
internal abstract string VisualizeRealIL(IModuleSymbol peModule, CompilationTestData.MethodData methodData, IReadOnlyDictionary<int, string> markers);
public static void Create(IModuleSymbol symbol, SymbolKeyWriter visitor)
{
visitor.WriteSymbolKey(symbol.ContainingSymbol);
}
private IModuleSymbol GetModuleSymbolForEmittedImage(ref IModuleSymbol moduleSymbol, ImmutableArray<byte> peImage)
{
if (peImage.IsDefault)
{
return null;
}
if (moduleSymbol == null)
{
Debug.Assert(!peImage.IsDefault);
var targetReference = LoadTestEmittedExecutableForSymbolValidation(peImage, compilation.Options.OutputKind, display: compilation.AssemblyName);
var references = compilation.References.Concat(new[] { targetReference });
var assemblies = test.ReferencesToModuleSymbols(references, compilation.Options.MetadataImportOptions);
var module = assemblies.Last();
moduleSymbol = module;
}
return moduleSymbol;
}
internal ModuleSymbolKey(IModuleSymbol symbol, Visitor visitor)
{
this.containerKey = GetOrCreate(symbol.ContainingSymbol, visitor);
this.metadataName = symbol.MetadataName;
}
public override object VisitModule(IModuleSymbol moduleSymbol)
{
WriteType(SymbolKeyType.Module);
ModuleSymbolKey.Create(moduleSymbol, this);
return(null);
}
public override void VisitModule(IModuleSymbol symbol)
{
VisitNamespace(symbol.GlobalNamespace);
}
public override void VisitModule(IModuleSymbol symbol)
{
builder.Add(CreatePart(SymbolDisplayPartKind.ModuleName, symbol, symbol.Name));
}
internal override string VisualizeRealIL(IModuleSymbol peModule, CodeAnalysis.CodeGen.CompilationTestData.MethodData methodData)
{
throw new NotImplementedException();
}
public override void VisitModule(IModuleSymbol symbol)
{
base.VisitModule(symbol);
}
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 |
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;
}
public virtual void VisitModule(IModuleSymbol symbol)
{
DefaultVisit(symbol);
}
