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)); }
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); }
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); }