protected void AddAssemblyLink(IAssemblySymbol assemblySymbol)
        {
            var name = assemblySymbol.Identity.Name;
            var navInfo = _libraryManager.LibraryService.NavInfoFactory.CreateForAssembly(assemblySymbol);

            _description.AddDescriptionText3(name, VSOBDESCRIPTIONSECTION.OBDS_TYPE, navInfo);
        }

        protected void AddAssemblyLink(IAssemblySymbol assemblySymbol)
        {
            var name = assemblySymbol.Identity.Name;
            var navInfo = _libraryManager.GetAssemblyNavInfo(assemblySymbol);

            _description.AddDescriptionText3(name, VSOBDESCRIPTIONSECTION.OBDS_TYPE, navInfo);
        }

 public static string GetAssemblyInfo(IAssemblySymbol assemblySymbol)
 {
     return string.Format(
         "{0} {1}",
         FeaturesResources.Assembly,
         assemblySymbol.Identity.GetDisplayName());
 }

 public static bool IsSameAssemblyOrHasFriendAccessTo(this IAssemblySymbol assembly, IAssemblySymbol toAssembly)
 {
     return
         Equals(assembly, toAssembly) ||
         (assembly.IsInteractive && toAssembly.IsInteractive) ||
         toAssembly.GivesAccessTo(assembly);
 }

 /// <summary>
 /// Checks if 'symbol' is accessible from within assembly 'within'.
 /// </summary>
 public static bool IsAccessibleWithin(
     this ISymbol symbol,
     IAssemblySymbol within,
     ITypeSymbol throughTypeOpt = null)
 {
     return IsSymbolAccessibleCore(symbol, within, throughTypeOpt, out var failedThroughTypeCheck);
 }

 public static IEnumerable<TypeDiff> CompareTo(this IAssemblySymbol assembly, IAssemblySymbol comparedTo)
 {
     var types = assembly.GlobalNamespace.GetTypes();
     var comparedToTypes = comparedTo.GlobalNamespace.GetTypes();
     var result = types.FullOuterJoin(comparedToTypes, NamespaceOrTypeSymbolComparer.Instance, (a, b) => a.CompareTo(b));
     return result;
 }

        private static bool ShouldCreateFromScratch(
            Solution solution,
            IAssemblySymbol assembly,
            string filePath,
            out string prefix,
            out VersionStamp version,
            CancellationToken cancellationToken)
        {
            prefix = null;
            version = default(VersionStamp);

            var service = solution.Workspace.Services.GetService<IAssemblySerializationInfoService>();
            if (service == null)
            {
                return true;
            }

            // check whether the assembly that belong to a solution is something we can serialize
            if (!service.Serializable(solution, filePath))
            {
                return true;
            }

            if (!service.TryGetSerializationPrefixAndVersion(solution, filePath, out prefix, out version))
            {
                return true;
            }

            return false;
        }

        /// <summary>
        /// this is for a metadata reference in a solution
        /// </summary>
        private static async Task<SymbolTreeInfo> LoadOrCreateAsync(Solution solution, IAssemblySymbol assembly, string filePath, CancellationToken cancellationToken)
        {
            // if assembly is not from a file, just create one on the fly
            if (filePath == null || !File.Exists(filePath) || !FilePathUtilities.PartOfFrameworkOrReferencePaths(filePath))
            {
                return Create(VersionStamp.Default, assembly, cancellationToken);
            }

            // if solution is not from a disk, just create one.
            if (solution.FilePath == null || !File.Exists(solution.FilePath))
            {
                return Create(VersionStamp.Default, assembly, cancellationToken);
            }

            // okay, see whether we can get one from persistence service.
            var relativePath = FilePathUtilities.GetRelativePath(solution.FilePath, filePath);
            var version = VersionStamp.Create(File.GetLastWriteTimeUtc(filePath));

            var persistentStorageService = solution.Workspace.Services.GetService<IPersistentStorageService>();

            // attempt to load from persisted state. metadata reference is solution wise information
            SymbolTreeInfo info;
            using (var storage = persistentStorageService.GetStorage(solution))
            {
                var key = PrefixMetadataSymbolTreeInfo + relativePath;
                using (var stream = await storage.ReadStreamAsync(key, cancellationToken).ConfigureAwait(false))
                {
                    if (stream != null)
                    {
                        using (var reader = new ObjectReader(stream))
                        {
                            info = ReadFrom(reader);
                            if (info != null && VersionStamp.CanReusePersistedVersion(version, info.version))
                            {
                                return info;
                            }
                        }
                    }
                }

                cancellationToken.ThrowIfCancellationRequested();

                // compute it if we couldn't load it from cache
                info = Create(version, assembly, cancellationToken);
                if (info != null)
                {
                    using (var stream = SerializableBytes.CreateWritableStream())
                    using (var writer = new ObjectWriter(stream, cancellationToken: cancellationToken))
                    {
                        info.WriteTo(writer);
                        stream.Position = 0;

                        await storage.WriteStreamAsync(key, stream, cancellationToken).ConfigureAwait(false);
                    }
                }
            }

            return info;
        }

        public ExternAliasRecord(string alias, IAssemblySymbol targetAssembly)
        {
            Debug.Assert(alias != null);
            Debug.Assert(targetAssembly != null);

            Alias = alias;
            TargetAssembly = targetAssembly;
        }

 public static IEnumerable<string> GetAssemblyAttributes(IAssemblySymbol assemblySymbol)
 {
     var attributes = assemblySymbol.GetAttributes();
     foreach (var attribute in attributes)
     {
         yield return attribute.ToString();
     }
 }

 private static bool AssemblyHasPublicTypes(IAssemblySymbol assembly)
 {
     return assembly
             .GlobalNamespace
             .GetMembers()
             .OfType<INamedTypeSymbol>()
             .Where(s => s.DeclaredAccessibility == Accessibility.Public)
             .Any();
 }

        private static bool IsOrUsesAssemblyType(ITypeSymbol typeSymbol, IAssemblySymbol assemblySymbol)
        {
            if (typeSymbol.ContainingAssembly == assemblySymbol)
            {
                return true;
            }

            INamedTypeSymbol namedTypeSymbol = typeSymbol as INamedTypeSymbol;
            return namedTypeSymbol != null && namedTypeSymbol.IsGenericType
                && namedTypeSymbol.TypeArguments.Any(t => IsOrUsesAssemblyType(t, assemblySymbol));
        }

 public MetadataSearchScope(
     Solution solution,
     IAssemblySymbol assembly,
     PortableExecutableReference metadataReference,
     bool ignoreCase,
     CancellationToken cancellationToken)
     : base(ignoreCase, cancellationToken)
 {
     _solution = solution;
     _assembly = assembly;
     _metadataReference = metadataReference;
 }

 public static bool IsObjectMapperFrameworkAssembly(IAssemblySymbol assemblySymbol)
 {
     if (assemblySymbol.Name != "ObjectMapper.Framework")
     {
         return false;
     }
     if (!assemblySymbol.Identity.IsStrongName || !_publicKeyToken.SequenceEqual(assemblySymbol.Identity.PublicKeyToken))
     {
         return false;
     }
     return true;
 }

 public ImportRecord(
     ImportTargetKind targetKind,
     string alias = null,
     ITypeSymbol targetType = null,
     string targetString = null,
     IAssemblySymbol targetAssembly = null,
     string targetAssemblyAlias = null)
 {
     TargetKind = targetKind;
     Alias = alias;
     TargetType = targetType;
     TargetString = targetString;
     TargetAssembly = targetAssembly;
     TargetAssemblyAlias = targetAssemblyAlias;
 }

        internal static SymbolTreeInfo CreateSourceSymbolTreeInfo(
            Solution solution, VersionStamp version, IAssemblySymbol assembly,
            string filePath, CancellationToken cancellationToken)
        {
            if (assembly == null)
            {
                return null;
            }

            var unsortedNodes = new List<Node> { new Node(assembly.GlobalNamespace.Name, Node.RootNodeParentIndex) };

            GenerateSourceNodes(assembly.GlobalNamespace, unsortedNodes, s_getMembersNoPrivate);

            return CreateSymbolTreeInfo(solution, version, filePath, unsortedNodes);
        }

        /// <summary>
        /// Get all symbols that have a name matching the specified name.
        /// </summary>
        public IEnumerable<ISymbol> Find(
            IAssemblySymbol assembly,
            string name,
            bool ignoreCase,
            CancellationToken cancellationToken)
        {
            var comparer = GetComparer(ignoreCase);

            foreach (var node in FindNodes(name, comparer))
            {
                foreach (var symbol in Bind(node, assembly.GlobalNamespace, cancellationToken))
                {
                    yield return symbol;
                }
            }
        }

 public IEnumerable<ISymbol> Find(IAssemblySymbol assembly, Func<string, bool> predicate, CancellationToken cancellationToken)
 {
     for (int i = 0, n = _nodes.Count; i < n; i++)
     {
         cancellationToken.ThrowIfCancellationRequested();
         var node = _nodes[i];
         if (predicate(node.Name))
         {
             foreach (var symbol in Bind(i, assembly.GlobalNamespace, cancellationToken))
             {
                 cancellationToken.ThrowIfCancellationRequested();
                 yield return symbol;
             }
         }
     }
 }

        internal static SymbolTreeInfo CreateSourceSymbolTreeInfo(
            Solution solution, VersionStamp version, IAssemblySymbol assembly,
            string filePath, CancellationToken cancellationToken)
        {
            if (assembly == null)
            {
                return null;
            }

            var unsortedNodes = ArrayBuilder<BuilderNode>.GetInstance();
            unsortedNodes.Add(new BuilderNode(assembly.GlobalNamespace.Name, RootNodeParentIndex));

            GenerateSourceNodes(assembly.GlobalNamespace, unsortedNodes, s_getMembersNoPrivate);

            return CreateSymbolTreeInfo(
                solution, version, filePath, unsortedNodes.ToImmutableAndFree(), 
                inheritanceMap: new OrderPreservingMultiDictionary<string, string>());
        }

        public static string GetAssemblyDisplay(Compilation compilation, IAssemblySymbol assemblySymbol)
        {
            // This method is only used to generate a comment at the top of Metadata-as-Source documents and
            // previous submissions are never viewed as metadata (i.e. we always have compilations) so there's no
            // need to consume compilation.ScriptCompilationInfo.PreviousScriptCompilation.

            // TODO (https://github.com/dotnet/roslyn/issues/6859): compilation.GetMetadataReference(assemblySymbol)?
            var assemblyReference = compilation.References.Where(r =>
            {
                var referencedSymbol = compilation.GetAssemblyOrModuleSymbol(r) as IAssemblySymbol;
                return
                    referencedSymbol != null &&
                    referencedSymbol.MetadataName == assemblySymbol.MetadataName;
            })
            .FirstOrDefault();

            return assemblyReference?.Display ?? FeaturesResources.location_unknown;
        }