public override void VisitMarkupTextLiteral(MarkupTextLiteralSyntax node)
{
if (!node.ContainsOnlyWhitespace())
{
AddSemanticRange(node, RazorSemanticTokensLegend.MarkupTextLiteral);
}
}
private static MarkupMinimizedTagHelperDirectiveAttributeSyntax RewriteToMinimizedDirectiveAttribute(
MarkupMinimizedAttributeBlockSyntax attributeBlock,
TryParseResult result)
{
//
// Consider, <Foo @bind:param />
// We're now going to rewrite @bind:param from a regular MarkupAttributeBlock to a MarkupTagHelperDirectiveAttribute.
// We need to split the name "@bind:param" into four parts,
// @ - Transition (MetaCode)
// bind - Name (Text)
// : - Colon (MetaCode)
// param - ParameterName (Text)
//
var attributeName = result.AttributeName;
var attributeNameSyntax = attributeBlock.Name;
var transition = SyntaxFactory.RazorMetaCode(
new SyntaxList <SyntaxToken>(SyntaxFactory.MissingToken(SyntaxKind.Transition)));
RazorMetaCodeSyntax colon = null;
MarkupTextLiteralSyntax parameterName = null;
if (attributeName.StartsWith("@", StringComparison.Ordinal))
{
attributeName = attributeName.Substring(1);
var attributeNameToken = SyntaxFactory.Token(SyntaxKind.Text, attributeName);
attributeNameSyntax = SyntaxFactory.MarkupTextLiteral().AddLiteralTokens(attributeNameToken);
var transitionToken = SyntaxFactory.Token(SyntaxKind.Transition, "@");
transition = SyntaxFactory.RazorMetaCode(new SyntaxList <SyntaxToken>(transitionToken));
}
if (attributeName.IndexOf(':') != -1)
{
var segments = attributeName.Split(new[] { ':' }, 2);
var attributeNameToken = SyntaxFactory.Token(SyntaxKind.Text, segments[0]);
attributeNameSyntax = SyntaxFactory.MarkupTextLiteral().AddLiteralTokens(attributeNameToken);
var colonToken = SyntaxFactory.Token(SyntaxKind.Colon, ":");
colon = SyntaxFactory.RazorMetaCode(new SyntaxList <SyntaxToken>(colonToken));
var parameterNameToken = SyntaxFactory.Token(SyntaxKind.Text, segments[1]);
parameterName = SyntaxFactory.MarkupTextLiteral().AddLiteralTokens(parameterNameToken);
}
var rewritten = SyntaxFactory.MarkupMinimizedTagHelperDirectiveAttribute(
attributeBlock.NamePrefix,
transition,
attributeNameSyntax,
colon,
parameterName);
rewritten = rewritten.WithTagHelperAttributeInfo(
new TagHelperAttributeInfo(result.AttributeName, parameterName?.GetContent(), result.AttributeStructure, result.IsBoundAttribute, isDirectiveAttribute: true));
return(rewritten);
}
public override void VisitMarkupTextLiteral(MarkupTextLiteralSyntax node)
{
if (node.Parent is MarkupLiteralAttributeValueSyntax)
{
base.VisitMarkupTextLiteral(node);
return;
}
WriteSpan(node, FormattingSpanKind.Markup);
base.VisitMarkupTextLiteral(node);
}
public override SyntaxNode VisitMarkupTextLiteral(MarkupTextLiteralSyntax node)
{
var tagParent = node.FirstAncestorOrSelf <SyntaxNode>(n => n is MarkupStartTagSyntax || n is MarkupEndTagSyntax);
var isPartofTagBlock = tagParent != null;
if (!isPartofTagBlock)
{
ValidateParentAllowsContent(node);
}
return(base.VisitMarkupTextLiteral(node));
}
public override SyntaxNode VisitMarkupTextLiteral(MarkupTextLiteralSyntax node)
{
if (!_tryParseResult.IsBoundNonStringAttribute)
{
return(base.VisitMarkupTextLiteral(node));
}
_rewriteAsMarkup = true;
node = (MarkupTextLiteralSyntax)ConfigureNonStringAttribute(node);
var tokens = new SyntaxList <SyntaxToken>(node.LiteralTokens);
var value = SyntaxFactory.CSharpExpressionLiteral(tokens);
return(value.WithSpanContext(node.GetSpanContext()));
}
public override void VisitMarkupTextLiteral(MarkupTextLiteralSyntax node)
{
WriteNode(node, isHtml: true, base.VisitMarkupTextLiteral);
}
public override void VisitMarkupTextLiteral(MarkupTextLiteralSyntax node)
{
// Don't return anything for MarkupTextLiterals. It translates to "text" on the VS side, which is the default color anyway
}
public override void VisitMarkupTextLiteral(MarkupTextLiteralSyntax node)
{
var context = node.GetSpanContext();
if (context != null && context.ChunkGenerator == SpanChunkGenerator.Null)
{
base.VisitMarkupTextLiteral(node);
return;
}
if (node.LiteralTokens.Count == 1)
{
var token = node.LiteralTokens[0];
if (token != null &&
token.Kind == SyntaxKind.Marker &&
token.Content.Length == 0)
{
// We don't want to create IR nodes for marker tokens.
base.VisitMarkupTextLiteral(node);
return;
}
}
var source = BuildSourceSpanFromNode(node);
var currentChildren = _builder.Current.Children;
if (currentChildren.Count > 0 && currentChildren[currentChildren.Count - 1] is HtmlContentIntermediateNode)
{
var existingHtmlContent = (HtmlContentIntermediateNode)currentChildren[currentChildren.Count - 1];
if (existingHtmlContent.Source == null && source == null)
{
Combine(existingHtmlContent, node);
base.VisitMarkupTextLiteral(node);
return;
}
if (source != null &&
existingHtmlContent.Source != null &&
existingHtmlContent.Source.Value.FilePath == source.Value.FilePath &&
existingHtmlContent.Source.Value.AbsoluteIndex + existingHtmlContent.Source.Value.Length == source.Value.AbsoluteIndex)
{
Combine(existingHtmlContent, node);
base.VisitMarkupTextLiteral(node);
return;
}
}
var contentNode = new HtmlContentIntermediateNode()
{
Source = source
};
_builder.Push(contentNode);
_builder.Add(new IntermediateToken()
{
Content = node.GetContent(),
Kind = TokenKind.Html,
Source = source,
});
_builder.Pop();
base.VisitMarkupTextLiteral(node);
}
public override void VisitMarkupTextLiteral(MarkupTextLiteralSyntax node)
{
AddSemanticRange(node, RazorSemanticTokensLegend.MarkupTextLiteral);
}
