public TagReader(AXmlParser tagSoupParser, SourceText input, bool collapseProperlyNestedElements) : base(input)
 {
     this.tagSoupParser = tagSoupParser;
     if (collapseProperlyNestedElements)
     {
         elementNameStack = new Stack <string>();
     }
 }
        static XmlDocumentationElement Create(string documentationComment, ISymbol declaringEntity)
        {
            var doc = new AXmlParser().Parse(SourceText.From(documentationComment));

            return(new XmlDocumentationElement(doc, declaringEntity));
        }
        static List <XmlDocumentationElement> CreateElements(IEnumerable <AXmlObject> childObjects, ISymbol declaringEntity, int nestingLevel)
        {
            List <XmlDocumentationElement> list = new List <XmlDocumentationElement>();

            foreach (var child in childObjects)
            {
                var childText    = child as AXmlText;
                var childTag     = child as AXmlTag;
                var childElement = child as AXmlElement;
                if (childText != null)
                {
                    list.Add(new XmlDocumentationElement(childText.Value, declaringEntity));
                }
                else if (childTag != null && childTag.IsCData)
                {
                    foreach (var text in childTag.Children.OfType <AXmlText>())
                    {
                        list.Add(new XmlDocumentationElement(text.Value, declaringEntity));
                    }
                }
                else if (childElement != null)
                {
                    if (nestingLevel < 5 && childElement.Name == "inheritdoc")
                    {
                        string  cref                   = childElement.GetAttributeValue("cref");
                        ISymbol inheritedFrom          = null;
                        string  inheritedDocumentation = null;
                        if (cref != null)
                        {
                            //inheritedFrom = crefResolver(cref);
                            //if (inheritedFrom != null)
                            //    inheritedDocumentation = inheritedFrom.GetDocumentationCommentXml();
                        }
                        else
                        {
                            //                     foreach (var baseMember in InheritanceHelper.GetBaseMembers((IMember)declaringEntity, includeImplementedInterfaces: true)) {
                            //	inheritedDocumentation = baseMember.Documentation;
                            //	if (inheritedDocumentation != null) {
                            //		inheritedFrom = baseMember;
                            //		break;
                            //	}
                            //}
                        }

                        if (inheritedDocumentation != null)
                        {
                            var doc = new AXmlParser().Parse(SourceText.From(inheritedDocumentation));

                            // XPath filter not yet implemented
                            if (childElement.Parent is AXmlDocument && childElement.GetAttributeValue("select") == null)
                            {
                                // Inheriting documentation at the root level
                                List <string> doNotInherit = new List <string>();
                                doNotInherit.Add("overloads");
                                doNotInherit.AddRange(childObjects.OfType <AXmlElement>().Select(e => e.Name).Intersect(
                                                          doNotInheritIfAlreadyPresent));

                                var inheritedChildren = doc.Children.Where(
                                    inheritedObject => {
                                    AXmlElement inheritedElement = inheritedObject as AXmlElement;
                                    return(!(inheritedElement != null && doNotInherit.Contains(inheritedElement.Name)));
                                });

                                list.AddRange(CreateElements(inheritedChildren, inheritedFrom, nestingLevel + 1));
                            }
                        }
                    }
                    else
                    {
                        list.Add(new XmlDocumentationElement(childElement, declaringEntity)
                        {
                            nestingLevel = nestingLevel
                        });
                    }
                }
            }
            if (list.Count > 0 && list[0].IsTextNode)
            {
                if (string.IsNullOrWhiteSpace(list[0].textContent))
                {
                    list.RemoveAt(0);
                }
                else
                {
                    list[0].textContent = list[0].textContent.TrimStart();
                }
            }
            if (list.Count > 0 && list[list.Count - 1].IsTextNode)
            {
                if (string.IsNullOrWhiteSpace(list[list.Count - 1].textContent))
                {
                    list.RemoveAt(list.Count - 1);
                }
                else
                {
                    list[list.Count - 1].textContent = list[list.Count - 1].textContent.TrimEnd();
                }
            }
            return(list);
        }
            void CheckXmlDocForErrors(SyntaxNode node, ISymbol member)
            {
                context.CancellationToken.ThrowIfCancellationRequested();

                foreach (var triva in node.GetLeadingTrivia())
                {
                    if (triva.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia))
                    {
                        storedXmlComment.Add((DocumentationCommentTriviaSyntax)triva.GetStructure());
                        new CRefVisistor(this).Visit(triva.GetStructure ());
                    }
                }

                if (storedXmlComment.Count == 0)
                    return;

                xml.Clear();
                xml.Append(firstline);
                var OffsetTable = new List<int>();
                foreach (var cmt in storedXmlComment)
                {
                    OffsetTable.Add(xml.Length - firstline.Length);
                    xml.Append(cmt.Content + "\n");
                }
                xml.Append("</root>\n");

                var doc = new AXmlParser().Parse(SourceText.From(xml.ToString()));

                var stack = new Stack<AXmlObject>();
                stack.Push(doc);
                foreach (var err in doc.SyntaxErrors)
                {
                    AddXmlIssue(CalculateRealStartOffset(OffsetTable, err.StartOffset), err.EndOffset - err.StartOffset, err.Description);
                }

                while (stack.Count > 0) {
                    var cur = stack.Pop();
                    var el = cur as AXmlElement;
                    if (el != null) {
                        switch (el.Name)
                        {
                            case "typeparam":
                            case "typeparamref":
                                var name = el.Attributes.FirstOrDefault(attr => attr.Name == "name");
                                if (name == null || name.ValueSegment.Length < 2)
                                    break;
                                if (member != null && member.IsKind(SymbolKind.NamedType))
                                {
                                    var type = (INamedTypeSymbol)member;
                                    if (!type.TypeArguments.Any(arg => arg.Name == name.Value))
                                    {
                                        AddXmlIssue(CalculateRealStartOffset(OffsetTable, name.ValueSegment.Start + 1), name.ValueSegment.Length - 2, string.Format(GettextCatalog.GetString("Type parameter '{0}' not found"), name.Value));
                                    }
                                }
                                break;
                            case "param":
                            case "paramref":
                                name = el.Attributes.FirstOrDefault(attr => attr.Name == "name");
                                if (name == null || name.ValueSegment.Length < 2)
                                    break;
                                var m = member as IMethodSymbol;
                                if (m != null)
                                {
                                    if (m.Parameters.Any(p => p.Name == name.Value))
                                        break;
                                    AddXmlIssue(CalculateRealStartOffset(OffsetTable, name.ValueSegment.Start + 1), name.ValueSegment.Length - 2, string.Format(GettextCatalog.GetString("Parameter '{0}' not found"), name.Value));
                                    break;
                                }
                                var prop = member as IPropertySymbol;
                                if (prop != null)
                                {
                                    if (prop.Parameters.Any(p => p.Name == name.Value))
                                        break;
                                    if (name.Value == "value")
                                        break;
                                    AddXmlIssue(CalculateRealStartOffset(OffsetTable, name.ValueSegment.Start + 1), name.ValueSegment.Length - 2, string.Format(GettextCatalog.GetString("Parameter '{0}' not found"), name.Value));
                                    break;
                                }
                                var evt = member as IEventSymbol;
                                if (evt != null)
                                {
                                    if (name.Value == "value")
                                        break;
                                    AddXmlIssue(CalculateRealStartOffset(OffsetTable, name.ValueSegment.Start + 1), name.ValueSegment.Length - 2, string.Format(GettextCatalog.GetString("Parameter '{0}' not found"), name.Value));
                                    break;
                                }
                                var named = member as INamedTypeSymbol;
                                if (named != null)
                                {
                                    if (named.DelegateInvokeMethod == null)
                                        break;
                                    if (named.DelegateInvokeMethod.Parameters.Any(p => p.Name == name.Value))
                                        break;
                                    AddXmlIssue(CalculateRealStartOffset(OffsetTable, name.ValueSegment.Start + 1), name.ValueSegment.Length - 2, string.Format(GettextCatalog.GetString("Parameter '{0}' not found"), name.Value));
                                    break;
                                }
                                AddXmlIssue(CalculateRealStartOffset(OffsetTable, name.ValueSegment.Start + 1), name.ValueSegment.Length - 2, string.Format(GettextCatalog.GetString("Parameter '{0}' not found"), name.Value));
                                break;
                        }
                    }
                    foreach (var child in cur.Children)
                        stack.Push(child);
                }


                storedXmlComment.Clear();
            }
        public TagReader(AXmlParser tagSoupParser, SourceText input, bool collapseProperlyNestedElements) : base(input)
		{
			this.tagSoupParser = tagSoupParser;
			if (collapseProperlyNestedElements)
				elementNameStack = new Stack<string>();
		}
        static XmlDocumentationElement Create(string documentationComment, ISymbol declaringEntity)
		{
            var doc = new AXmlParser().Parse(SourceText.From(documentationComment));
            return new XmlDocumentationElement(doc, declaringEntity);
		}
		static List<XmlDocumentationElement> CreateElements(IEnumerable<AXmlObject> childObjects, ISymbol declaringEntity, int nestingLevel)
		{
			List<XmlDocumentationElement> list = new List<XmlDocumentationElement>();
			foreach (var child in childObjects) {
				var childText = child as AXmlText;
				var childTag = child as AXmlTag;
				var childElement = child as AXmlElement;
				if (childText != null) {
					list.Add(new XmlDocumentationElement(childText.Value, declaringEntity));
				} else if (childTag != null && childTag.IsCData) {
					foreach (var text in childTag.Children.OfType<AXmlText>())
						list.Add(new XmlDocumentationElement(text.Value, declaringEntity));
				} else if (childElement != null) {
					if (nestingLevel < 5 && childElement.Name == "inheritdoc") {
						string cref = childElement.GetAttributeValue("cref");
						ISymbol inheritedFrom = null;
                        string inheritedDocumentation = null;
						if (cref != null) {
							//inheritedFrom = crefResolver(cref);
							//if (inheritedFrom != null)
                            //    inheritedDocumentation = inheritedFrom.GetDocumentationCommentXml();
						} else {
       //                     foreach (var baseMember in InheritanceHelper.GetBaseMembers((IMember)declaringEntity, includeImplementedInterfaces: true)) {
							//	inheritedDocumentation = baseMember.Documentation;
							//	if (inheritedDocumentation != null) {
							//		inheritedFrom = baseMember;
							//		break;
							//	}
							//}
						}
						
                        if (inheritedDocumentation != null) {
                            var doc = new AXmlParser().Parse(SourceText.From (inheritedDocumentation));
							
							// XPath filter not yet implemented
							if (childElement.Parent is AXmlDocument && childElement.GetAttributeValue("select") == null) {
								// Inheriting documentation at the root level
								List<string> doNotInherit = new List<string>();
								doNotInherit.Add("overloads");
								doNotInherit.AddRange(childObjects.OfType<AXmlElement>().Select(e => e.Name).Intersect(
									doNotInheritIfAlreadyPresent));
								
								var inheritedChildren = doc.Children.Where(
									inheritedObject => {
										AXmlElement inheritedElement = inheritedObject as AXmlElement;
										return !(inheritedElement != null && doNotInherit.Contains(inheritedElement.Name));
									});
								
								list.AddRange(CreateElements(inheritedChildren, inheritedFrom, nestingLevel + 1));
							}
						}
					} else {
						list.Add(new XmlDocumentationElement(childElement, declaringEntity) { nestingLevel = nestingLevel });
					}
				}
			}
			if (list.Count > 0 && list[0].IsTextNode) {
				if (string.IsNullOrWhiteSpace(list[0].textContent))
					list.RemoveAt(0);
				else
					list[0].textContent = list[0].textContent.TrimStart();
			}
			if (list.Count > 0 && list[list.Count - 1].IsTextNode) {
				if (string.IsNullOrWhiteSpace(list[list.Count - 1].textContent))
					list.RemoveAt(list.Count - 1);
				else
					list[list.Count - 1].textContent = list[list.Count - 1].textContent.TrimEnd();
			}
			return list;
		}