public static XmlElementSyntax MultiLineElement(XmlNameSyntax name, string newLineText, SyntaxList<XmlNodeSyntax> content)
{
return SyntaxFactory.XmlElement(
SyntaxFactory.XmlElementStartTag(name),
content.Insert(0, NewLine(newLineText)).Add(NewLine(newLineText)),
SyntaxFactory.XmlElementEndTag(name));
}
public static XmlElementSyntax Element(XmlNameSyntax name, SyntaxList<XmlNodeSyntax> content)
{
return SyntaxFactory.XmlElement(
SyntaxFactory.XmlElementStartTag(name),
content,
SyntaxFactory.XmlElementEndTag(name));
}
public XmlAttributeSyntax(XmlNameSyntax name, PunctuationSyntax equals, XmlNodeSyntax value)
: base(SyntaxKind.XmlAttribute)
{
this.NameNode = name;
this.Equals = equals;
this.ValueNode = value;
SlotCount = 3;
}
public static XmlTextAttributeSyntax TextAttribute(XmlNameSyntax name, SyntaxKind quoteKind, SyntaxTokenList textTokens)
{
return SyntaxFactory.XmlTextAttribute(
name,
SyntaxFactory.Token(quoteKind),
textTokens,
SyntaxFactory.Token(quoteKind))
.WithLeadingTrivia(SyntaxFactory.Whitespace(" "));
}
private static void HandleElement(SyntaxNodeAnalysisContext context, XmlNodeSyntax element, XmlNameSyntax name, Location alternativeDiagnosticLocation)
{
if (string.Equals(name.ToString(), XmlCommentHelper.ParamXmlTag))
{
var nameAttribute = XmlCommentHelper.GetFirstAttributeOrDefault<XmlNameAttributeSyntax>(element);
if (string.IsNullOrWhiteSpace(nameAttribute?.Identifier?.Identifier.ValueText))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, nameAttribute?.GetLocation() ?? alternativeDiagnosticLocation));
}
}
}
public override void VisitXmlName(XmlNameSyntax node)
{
throw new NotImplementedException();
}
public override void VisitXmlName(XmlNameSyntax node)
{
Debug.Fail(node.ToString());
base.VisitXmlName(node);
}
private static void HandleElement(SyntaxNodeAnalysisContext context, XmlNodeSyntax element, XmlNameSyntax name, Location alternativeDiagnosticLocation)
{
if (string.Equals(name.ToString(), XmlCommentHelper.ParamXmlTag))
{
var nameAttribute = XmlCommentHelper.GetFirstAttributeOrDefault <XmlNameAttributeSyntax>(element);
if (string.IsNullOrWhiteSpace(nameAttribute?.Identifier?.Identifier.ValueText))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, nameAttribute?.GetLocation() ?? alternativeDiagnosticLocation));
}
}
}
public override SyntaxNode VisitXmlName(XmlNameSyntax node)
{
node = (XmlNameSyntax)base.VisitXmlName(node);
Classes.Add(node);
return(node);
}
private static XmlElementSyntax EndTag(XmlNameSyntax name) => XmlElement(s_missingStartTag, XmlElementEndTag(name));
public override void VisitXmlName(XmlNameSyntax node)
{
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitXmlName(XmlNameSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitXmlName(node);
}
private static void HandleElement(SyntaxNodeAnalysisContext context, XmlNodeSyntax element, XmlNameSyntax name, Location alternativeDiagnosticLocation)
{
if (string.Equals(name.ToString(), XmlCommentHelper.ParamTag))
{
var nameAttribute = XmlCommentHelper.GetFirstAttributeOrDefault <XmlNameAttributeSyntax>(element);
// Make sure we ignore violations that should be reported by SA1613 instead.
if (!string.IsNullOrWhiteSpace(nameAttribute?.Identifier?.Identifier.ValueText) && ParentElementHasParameter(element, nameAttribute.Identifier.Identifier.ValueText) == false)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, nameAttribute?.Identifier?.GetLocation() ?? alternativeDiagnosticLocation));
}
}
}
public override void VisitXmlName(XmlNameSyntax node)
{
node.Prefix?.Accept(this);
base.VisitXmlName(node);
}
private XmlNameSyntax ConvertToReturns(XmlNameSyntax name)
=> name.ReplaceToken(name.LocalName, SyntaxFactory.Identifier("returns"));
public override void VisitXmlName(XmlNameSyntax node)
{
base.VisitXmlName(node);
}
public TameXmlNameSyntax(XmlNameSyntax node)
{
Node = node;
AddChildren();
}
public override Evaluation VisitXmlName(XmlNameSyntax node)
{
node.Prefix?.Accept <Evaluation>(this);
return(base.VisitXmlName(node));
}
private void ClassifyXmlName(XmlNameSyntax node)
{
string classificationType;
if (node.Parent is XmlAttributeSyntax)
{
classificationType = ClassificationTypeNames.XmlDocCommentAttributeName;
}
else if (node.Parent is XmlProcessingInstructionSyntax)
{
classificationType = ClassificationTypeNames.XmlDocCommentProcessingInstruction;
}
else
{
classificationType = ClassificationTypeNames.XmlDocCommentName;
}
var prefix = node.Prefix;
if (prefix != null)
{
AddXmlClassification(prefix.Prefix, classificationType);
AddXmlClassification(prefix.ColonToken, classificationType);
}
AddXmlClassification(node.LocalName, classificationType);
}
// // Summary: // Called when the visitor visits a XmlNameSyntax node. public virtual void VisitXmlName(XmlNameSyntax node);
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitXmlName(XmlNameSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitXmlName(node);
}
public override void DefaultVisit(SyntaxNode node)
{
SyntaxKind nodeKind = node.Kind();
bool diagnose = node.SyntaxTree.ReportDocumentationCommentDiagnostics();
if (nodeKind == SyntaxKind.XmlCrefAttribute)
{
XmlCrefAttributeSyntax crefAttr = (XmlCrefAttributeSyntax)node;
CrefSyntax cref = crefAttr.Cref;
BinderFactory factory = _compilation.GetBinderFactory(cref.SyntaxTree);
Binder binder = factory.GetBinder(cref);
// Do this for the diagnostics, even if it won't be written.
DiagnosticBag crefDiagnostics = DiagnosticBag.GetInstance();
string docCommentId = GetDocumentationCommentId(cref, binder, crefDiagnostics);
if (diagnose)
{
_diagnostics.AddRange(crefDiagnostics);
}
crefDiagnostics.Free();
if (_writer != null)
{
Visit(crefAttr.Name);
VisitToken(crefAttr.EqualsToken);
// Not going to visit normally, because we want to skip trivia within
// the attribute value.
crefAttr.StartQuoteToken.WriteTo(_writer, leading: true, trailing: false);
// We're not going to visit the cref because we want to bind it
// and write a doc comment ID in its place.
_writer.Write(docCommentId);
// Not going to visit normally, because we want to skip trivia within
// the attribute value.
crefAttr.EndQuoteToken.WriteTo(_writer, leading: false, trailing: true);
}
// Don't descend - we've already written out everything necessary.
return;
}
else if (diagnose && nodeKind == SyntaxKind.XmlNameAttribute)
{
XmlNameAttributeSyntax nameAttr = (XmlNameAttributeSyntax)node;
BinderFactory factory = _compilation.GetBinderFactory(nameAttr.SyntaxTree);
Binder binder = factory.GetBinder(nameAttr, nameAttr.Identifier.SpanStart);
// Do this for diagnostics, even if we aren't writing.
BindName(nameAttr, binder, _memberSymbol, ref _documentedParameters, ref _documentedTypeParameters, _diagnostics);
// Do descend - we still need to write out the tokens of the attribute.
}
// NOTE: if we're recording any include element nodes (i.e. if includeElementsNodes is non-null),
// then we want to record all of them, because we won't be able to distinguish in the XML DOM.
if (_includeElementNodes != null)
{
XmlNameSyntax nameSyntax = null;
if (nodeKind == SyntaxKind.XmlEmptyElement)
{
nameSyntax = ((XmlEmptyElementSyntax)node).Name;
}
else if (nodeKind == SyntaxKind.XmlElementStartTag)
{
nameSyntax = ((XmlElementStartTagSyntax)node).Name;
}
if (nameSyntax != null && nameSyntax.Prefix == null &&
DocumentationCommentXmlNames.ElementEquals(nameSyntax.LocalName.ValueText, DocumentationCommentXmlNames.IncludeElementName))
{
_includeElementNodes.Add((CSharpSyntaxNode)node);
}
}
base.DefaultVisit(node);
}
/// <summary> /// Used by the documentation comment rewriters to identify top-level <c><value></c> nodes. /// </summary> private static bool IsValueName(XmlNameSyntax name) => name.Prefix == null && name.LocalName.ValueText == "value";
private static XmlElementSyntax StartTag(XmlNameSyntax name, SyntaxList <XmlAttributeSyntax> attrs = default) => XmlElement(XmlElementStartTag(name, attrs), s_missingEndTag);
private XmlNameSyntax ConvertToParam(XmlNameSyntax name)
=> name.ReplaceToken(name.LocalName, SyntaxFactory.Identifier("param"));
public override void VisitXmlName(XmlNameSyntax node)
{
throw new NotSupportedException();
}
