internal PEAssemblySymbol(PEAssembly assembly, DocumentationProvider documentationProvider, bool isLinked, MetadataImportOptions importOptions)
        {
            Debug.Assert(assembly != null);
            Debug.Assert(documentationProvider != null);
            _assembly = assembly;
            _documentationProvider = documentationProvider;

            var modules = new ModuleSymbol[assembly.Modules.Length];

            for (int i = 0; i < assembly.Modules.Length; i++)
            {
                modules[i] = new PEModuleSymbol(this, assembly.Modules[i], importOptions, i);
            }

            _modules = modules.AsImmutableOrNull();
            _isLinked = isLinked;
        }
            public SerializedMetadataReference(
                MetadataReferenceProperties properties, string fullPath,
                Metadata metadata, ImmutableArray<ITemporaryStreamStorage> storagesOpt, DocumentationProvider initialDocumentation) :
                base(properties, fullPath, initialDocumentation)
            {
                // TODO: doc comment provider is a bit wierd.
                _metadata = metadata;
                _storagesOpt = storagesOpt;

                _provider = initialDocumentation;
            }
        /// <summary>
        /// Creates a reference to a single-module assembly or a standalone module stored in memory
        /// from a hex-encoded byte stream representing a gzipped assembly image.
        /// </summary>
        /// <param name="image">
        /// A string containing a hex-encoded byte stream representing a gzipped assembly image. 
        /// Hex digits are case-insensitive and can be separated by spaces or newlines.
        /// Cannot be null.
        /// </param>
        /// <param name="properties">Reference properties (extern aliases, type embedding, <see cref="MetadataImageKind"/>).</param>
        /// <param name="documentation">Provides XML documentation for symbol found in the reference.</param>
        /// <param name="filePath">Optional path that describes the location of the metadata. The file doesn't need to exist on disk. The path is opaque to the compiler.</param>
        protected internal PortableExecutableReference CreateMetadataReferenceFromHexGZipImage(
            string image,
            MetadataReferenceProperties properties = default(MetadataReferenceProperties),
            DocumentationProvider documentation = null,
            string filePath = null)
        {
            if (image == null)
            {
                throw new ArgumentNullException(nameof(image));
            }

            using (var compressed = new MemoryStream(SoapHexBinary.Parse(image).Value))
            using (var gzipStream = new GZipStream(compressed, CompressionMode.Decompress))
            using (var uncompressed = new MemoryStream())
            {
                gzipStream.CopyTo(uncompressed);
                uncompressed.Position = 0;
                return MetadataReference.CreateFromStream(uncompressed, properties, documentation, filePath);
            }
        }
 public MissingMetadataReference(
     MetadataReferenceProperties properties, string fullPath, DocumentationProvider initialDocumentation) :
     base(properties, fullPath, initialDocumentation)
 {
     // TODO: doc comment provider is a bit wierd.
     _provider = initialDocumentation;
 }
Example #5
0
 /// <summary>
 /// Creates a reference to a single-module assembly or a standalone module stored in memory
 /// from a hex-encoded byte stream representing a gzipped assembly image.
 /// </summary>
 /// <param name="image">
 /// A string containing a hex-encoded byte stream representing a gzipped assembly image. 
 /// Hex digits are case-insensitive and can be separated by spaces or newlines.
 /// Cannot be null.
 /// </param>
 /// <param name="properties">Reference properties (extern aliases, type embedding, <see cref="MetadataImageKind"/>).</param>
 /// <param name="documentation">Provides XML documentation for symbol found in the reference.</param>
 /// <param name="filePath">Optional path that describes the location of the metadata. The file doesn't need to exist on disk. The path is opaque to the compiler.</param>
 protected internal PortableExecutableReference CreateMetadataReferenceFromHexGZipImage(
     string image,
     MetadataReferenceProperties properties = default(MetadataReferenceProperties),
     DocumentationProvider documentation = null,
     string filePath = null)
 {
     return null;
 }
        private void WriteDocumentationCommentToolTip(XElement element)
        {
            using (IEnumerator <XNode> en = element.Nodes().GetEnumerator())
            {
                if (en.MoveNext())
                {
                    XNode node;
                    bool  isFirst = true;
                    bool  isLast;

                    do
                    {
                        node = en.Current;

                        isLast = !en.MoveNext();

                        if (node is XText t)
                        {
                            string value = t.Value;
                            value = TextUtility.RemoveLeadingTrailingNewLine(value, isFirst, isLast);
                            Write(value);
                        }
                        else if (node is XElement e)
                        {
                            switch (XmlTagMapper.GetTagOrDefault(e.Name.LocalName))
                            {
                            case XmlTag.C:
                            {
                                string value = e.Value;
                                value = TextUtility.ToSingleLine(value);
                                Write(value);
                                break;
                            }

                            case XmlTag.Para:
                            {
                                WriteLine();
                                WriteLine();
                                WriteDocumentationCommentToolTip(e);
                                WriteLine();
                                WriteLine();
                                break;
                            }

                            case XmlTag.ParamRef:
                            {
                                string parameterName = e.Attribute("name")?.Value;

                                if (parameterName != null)
                                {
                                    Write(parameterName);
                                }

                                break;
                            }

                            case XmlTag.See:
                            {
                                string commentId = e.Attribute("cref")?.Value;

                                if (commentId != null)
                                {
                                    ISymbol symbol = DocumentationProvider.GetFirstSymbolForDeclarationId(commentId);

                                    if (symbol != null)
                                    {
                                        Write(symbol.ToDisplayParts(Format.GetFormat()));
                                    }
                                    else
                                    {
                                        Write(TextUtility.RemovePrefixFromDocumentationCommentId(commentId));
                                    }
                                }

                                break;
                            }

                            case XmlTag.TypeParamRef:
                            {
                                string typeParameterName = e.Attribute("name")?.Value;

                                if (typeParameterName != null)
                                {
                                    Write(typeParameterName);
                                }

                                break;
                            }
                            }
                        }
                        else
                        {
                            Debug.Fail(node.NodeType.ToString());
                        }

                        isFirst = false;
                    } while (!isLast);
                }
            }
        }
        private void WriteDocumentationCommentToolTip(ISymbol symbol)
        {
            Debug.Assert(DocumentationDisplayMode == DocumentationDisplayMode.ToolTip, DocumentationDisplayMode.ToString());

            SymbolXmlDocumentation xmlDocumentation = DocumentationProvider?.GetXmlDocumentation(symbol);

            if (xmlDocumentation == null)
            {
                return;
            }

            XElement summaryElement = xmlDocumentation.Element(WellKnownXmlTags.Summary);

            if (summaryElement != null)
            {
                WriteStartAttribute("title");
                WriteDocumentationCommentToolTip(summaryElement);
            }

            bool hasExceptions = false;

            using (IEnumerator <XElement> en = xmlDocumentation.Elements(WellKnownXmlTags.Exception).GetEnumerator())
            {
                if (en.MoveNext())
                {
                    hasExceptions = true;

                    if (summaryElement != null)
                    {
                        Write("\n\n");
                    }
                    else
                    {
                        WriteStartAttribute("title");
                    }

                    Write("Exceptions:");

                    do
                    {
                        Write("\n  ");

                        string commentId = en.Current.Attribute("cref").Value;

                        if (commentId != null)
                        {
                            ISymbol exceptionSymbol = DocumentationProvider.GetFirstSymbolForDeclarationId(commentId);

                            if (exceptionSymbol != null)
                            {
                                Write(exceptionSymbol.ToDisplayParts(Format.GetFormat()));
                            }
                            else
                            {
                                Write(TextUtility.RemovePrefixFromDocumentationCommentId(commentId));
                            }
                        }
                    } while (en.MoveNext());
                }
            }

            if (summaryElement != null ||
                hasExceptions)
            {
                WriteEndAttribute();
            }
        }
        public override void WriteDocumentationComment(ISymbol symbol)
        {
            Debug.Assert(DocumentationDisplayMode == DocumentationDisplayMode.Xml, DocumentationDisplayMode.ToString());

            IEnumerable <string> elementsText = DocumentationProvider?.GetXmlDocumentation(symbol)?.GetElementsAsText(skipEmptyElement: true, makeSingleLine: true);

            if (elementsText == null)
            {
                return;
            }

            foreach (string elementText in elementsText)
            {
                XElement element = XElement.Parse(elementText, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo);

                Dictionary <int, List <XElement> > elementsByLine = null;

                foreach (XElement e in element.Descendants())
                {
                    switch (XmlTagMapper.GetTagOrDefault(e.Name.LocalName))
                    {
                    case XmlTag.See:
                    case XmlTag.ParamRef:
                    case XmlTag.TypeParamRef:
                    {
                        int lineNumber = ((IXmlLineInfo)e).LineNumber;

                        if (elementsByLine == null)
                        {
                            elementsByLine = new Dictionary <int, List <XElement> >();
                        }

                        if (elementsByLine.ContainsKey(lineNumber))
                        {
                            elementsByLine[lineNumber].Add(e);
                        }
                        else
                        {
                            elementsByLine.Add(lineNumber, new List <XElement>()
                                {
                                    e
                                });
                        }

                        break;
                    }
                    }
                }

                using (var sr = new StringReader(elementText))
                {
                    int lineNumber = 1;

                    string line = null;

                    while ((line = sr.ReadLine()) != null)
                    {
                        Write("/// ");

                        if (elementsByLine != null &&
                            elementsByLine.TryGetValue(lineNumber, out List <XElement> elements))
                        {
                            int lastPos = 0;

                            foreach (XElement e in elements.OrderBy(e => ((IXmlLineInfo)e).LinePosition))
                            {
                                int linePos = ((IXmlLineInfo)e).LinePosition - 2;

                                switch (XmlTagMapper.GetTagOrDefault(e.Name.LocalName))
                                {
                                case XmlTag.ParamRef:
                                case XmlTag.TypeParamRef:
                                {
                                    string name = e.Attribute("name")?.Value;

                                    if (name != null)
                                    {
                                        Write(line.Substring(lastPos, linePos - lastPos));
                                        Write(name);
                                    }

                                    lastPos = linePos + e.ToString().Length;
                                    break;
                                }

                                case XmlTag.See:
                                {
                                    string commentId = e.Attribute("cref")?.Value;

                                    if (commentId != null)
                                    {
                                        Write(line.Substring(lastPos, linePos - lastPos));

                                        ISymbol s = DocumentationProvider.GetFirstSymbolForDeclarationId(commentId)?.OriginalDefinition;

                                        if (s != null)
                                        {
                                            if (s.Kind == SymbolKind.Field &&
                                                s.ContainingType.TypeKind == TypeKind.Enum)
                                            {
                                                WriteSymbol(s.ContainingType);
                                                Write(".");
                                                Write(s.Name);
                                            }
                                            else
                                            {
                                                WriteParts(s, s.ToDisplayParts(TypeSymbolDisplayFormats.Name_ContainingTypes_Namespaces_GlobalNamespace_TypeParameters));
                                                WriteSymbol(s);
                                            }
                                        }
                                        else
                                        {
                                            Debug.Fail(commentId);
                                            Write(TextUtility.RemovePrefixFromDocumentationCommentId(commentId));
                                        }
                                    }
                                    else
                                    {
                                        string langword = e.Attribute("langword")?.Value;

                                        if (langword != null)
                                        {
                                            Write(line.Substring(lastPos, linePos - lastPos));
                                            Write(langword);
                                        }
                                    }

                                    lastPos = linePos + e.ToString().Length;
                                    break;
                                }
                                }
                            }

                            WriteLine(line.Substring(lastPos));
                        }
                        else
                        {
                            WriteLine(line);
                        }

                        WriteIndentation();

                        lineNumber++;
                    }
                }
            }
        }
Example #9
0
            public SerializedMetadataReference(
                MetadataReferenceProperties properties, string fullPath,
                Metadata metadata, ImmutableArray <ITemporaryStreamStorage> storagesOpt, DocumentationProvider initialDocumentation) :
                base(properties, fullPath, initialDocumentation)
            {
                // TODO: doc comment provider is a bit wierd.
                _metadata    = metadata;
                _storagesOpt = storagesOpt;

                _provider = initialDocumentation;
            }