internal virtual RazorSyntaxTree ParseDocument(RazorLanguageVersion version, string document, IEnumerable <DirectiveDescriptor> directives, bool designTime = false, RazorParserFeatureFlags featureFlags = null, string fileKind = null)
{
directives ??= Array.Empty <DirectiveDescriptor>();
var source = TestRazorSourceDocument.Create(document, filePath: null, relativePath: null, normalizeNewLines: true);
var options = CreateParserOptions(version, directives, designTime, featureFlags, fileKind);
var context = new ParserContext(source, options);
var codeParser = new CSharpCodeParser(directives, context);
var markupParser = new HtmlMarkupParser(context);
codeParser.HtmlParser = markupParser;
markupParser.CodeParser = codeParser;
var root = markupParser.ParseDocument().CreateRed();
var diagnostics = context.ErrorSink.Errors;
var codeDocument = RazorCodeDocument.Create(source);
var syntaxTree = RazorSyntaxTree.Create(root, source, diagnostics, options);
codeDocument.SetSyntaxTree(syntaxTree);
var defaultDirectivePass = new DefaultDirectiveSyntaxTreePass();
syntaxTree = defaultDirectivePass.Execute(codeDocument, syntaxTree);
return(syntaxTree);
}
internal virtual RazorSyntaxTree ParseDocument(string document, IEnumerable <DirectiveDescriptor> directives, bool designTime = false)
{
directives = directives ?? Array.Empty <DirectiveDescriptor>();
var source = TestRazorSourceDocument.Create(document, fileName: null);
var options = CreateParserOptions(directives, designTime);
var context = new ParserContext(source, options);
var codeParser = new CSharpCodeParser(directives, context);
var markupParser = new HtmlMarkupParser(context);
codeParser.HtmlParser = markupParser;
markupParser.CodeParser = codeParser;
markupParser.ParseDocument();
var root = context.Builder.Build();
var diagnostics = context.ErrorSink.Errors?.Select(error => RazorDiagnostic.Create(error));
var codeDocument = RazorCodeDocument.Create(source);
var syntaxTree = RazorSyntaxTree.Create(root, source, diagnostics, options);
codeDocument.SetSyntaxTree(syntaxTree);
var defaultDirectivePass = new DefaultDirectiveSyntaxTreePass();
syntaxTree = defaultDirectivePass.Execute(codeDocument, syntaxTree);
return(syntaxTree);
}
internal virtual RazorSyntaxTree ParseCodeBlock(
RazorLanguageVersion version,
string document,
IEnumerable <DirectiveDescriptor> directives,
bool designTime)
{
directives = directives ?? Array.Empty <DirectiveDescriptor>();
var source = TestRazorSourceDocument.Create(document, filePath: null, relativePath: null, normalizeNewLines: true);
var options = CreateParserOptions(version, directives, designTime);
var context = new ParserContext(source, options);
var codeParser = new CSharpCodeParser(directives, context);
var markupParser = new HtmlMarkupParser(context);
codeParser.HtmlParser = markupParser;
markupParser.CodeParser = codeParser;
var root = codeParser.ParseBlock().CreateRed();
var diagnostics = context.ErrorSink.Errors;
var syntaxTree = RazorSyntaxTree.Create(root, source, diagnostics, options);
return(syntaxTree);
}
public virtual RazorSyntaxTree Parse(RazorSourceDocument source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
var context = new ParserContext(source, Options);
var codeParser = new CSharpCodeParser(Options.Directives, context);
var markupParser = new HtmlMarkupParser(context);
codeParser.HtmlParser = markupParser;
markupParser.CodeParser = codeParser;
var diagnostics = context.ErrorSink.Errors;
var root = markupParser.ParseDocument().CreateRed();
return(RazorSyntaxTree.Create(root, source, diagnostics, Options));
}
internal virtual RazorSyntaxTree ParseHtmlBlock(string document, IEnumerable <DirectiveDescriptor> directives, bool designTime = false)
{
directives = directives ?? Array.Empty <DirectiveDescriptor>();
var source = TestRazorSourceDocument.Create(document, fileName: null);
var options = CreateParserOptions(directives, designTime);
var context = new ParserContext(source, options);
var parser = new HtmlMarkupParser(context);
parser.CodeParser = new CSharpCodeParser(directives, context)
{
HtmlParser = parser,
};
parser.ParseBlock();
var root = context.Builder.Build();
var diagnostics = context.ErrorSink.Errors?.Select(error => RazorDiagnostic.Create(error));
return(RazorSyntaxTree.Create(root, source, diagnostics, options));
}
public virtual RazorSyntaxTree Parse(RazorSourceDocument source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
var context = new ParserContext(source, Options);
var codeParser = new CSharpCodeParser(Options.Directives, context);
var markupParser = new HtmlMarkupParser(context);
codeParser.HtmlParser = markupParser;
markupParser.CodeParser = codeParser;
markupParser.ParseDocument();
var root = context.Builder.Build();
// Temporary code while we're still using legacy diagnostics in the SyntaxTree.
var diagnostics = context.ErrorSink.Errors.Select(error => RazorDiagnostic.Create(error));
return(RazorSyntaxTree.Create(root, source, diagnostics, Options));
}
private static TryParseResult TryParseBlock(
string tagName,
Block block,
IEnumerable <TagHelperDescriptor> descriptors,
ErrorSink errorSink,
HashSet <string> processedBoundAttributeNames)
{
// TODO: Accept more than just spans: https://github.com/aspnet/Razor/issues/96.
// The first child will only ever NOT be a Span if a user is doing something like:
// <input @checked />
var childSpan = block.Children.First() as Span;
if (childSpan == null || childSpan.Kind != SpanKindInternal.Markup)
{
errorSink.OnError(
block.Start,
LegacyResources.FormatTagHelpers_CannotHaveCSharpInTagDeclaration(tagName),
block.Length);
return(null);
}
var builder = new BlockBuilder(block);
// If there's only 1 child it means that it's plain text inside of the attribute.
// i.e. <div class="plain text in attribute">
if (builder.Children.Count == 1)
{
return(TryParseSpan(childSpan, descriptors, errorSink, processedBoundAttributeNames));
}
var nameSymbols = childSpan
.Symbols
.OfType <HtmlSymbol>()
.SkipWhile(symbol => !HtmlMarkupParser.IsValidAttributeNameSymbol(symbol)) // Skip prefix
.TakeWhile(nameSymbol => HtmlMarkupParser.IsValidAttributeNameSymbol(nameSymbol))
.Select(nameSymbol => nameSymbol.Content);
var name = string.Concat(nameSymbols);
if (string.IsNullOrEmpty(name))
{
errorSink.OnError(
childSpan.Start,
LegacyResources.FormatTagHelpers_AttributesMustHaveAName(tagName),
childSpan.Length);
return(null);
}
// Have a name now. Able to determine correct isBoundNonStringAttribute value.
var result = CreateTryParseResult(name, descriptors, processedBoundAttributeNames);
var firstChild = builder.Children[0] as Span;
if (firstChild != null && firstChild.Symbols[0] is HtmlSymbol)
{
var htmlSymbol = firstChild.Symbols[firstChild.Symbols.Count - 1] as HtmlSymbol;
switch (htmlSymbol.Type)
{
case HtmlSymbolType.Equals:
if (builder.Children.Count == 2 &&
builder.Children[1] is Span value &&
value.Kind == SpanKindInternal.Markup)
{
// Attribute value is a string literal. Eg: <tag my-attribute=foo />.
result.AttributeStructure = AttributeStructure.NoQuotes;
}
else
{
// Could be an expression, treat NoQuotes and DoubleQuotes equivalently. We purposefully do not persist NoQuotes
// ValueStyles at code generation time to protect users from rendering dynamic content with spaces
// that can break attributes.
// Ex: <tag my-attribute=@value /> where @value results in the test "hello world".
// This way, the above code would render <tag my-attribute="hello world" />.
result.AttributeStructure = AttributeStructure.DoubleQuotes;
}
break;
// This method handles cases when the attribute is a simple span attribute such as
// class="something moresomething". This does not handle complex attributes such as
// class="@myclass". Therefore the span.Content is equivalent to the entire attribute.
private static TryParseResult TryParseSpan(
Span span,
IEnumerable <TagHelperDescriptor> descriptors,
ErrorSink errorSink,
HashSet <string> processedBoundAttributeNames)
{
var afterEquals = false;
var builder = new SpanBuilder(span.Start)
{
ChunkGenerator = span.ChunkGenerator,
EditHandler = span.EditHandler,
Kind = span.Kind
};
// Will contain symbols that represent a single attribute value: <input| class="btn"| />
var htmlSymbols = span.Symbols.OfType <HtmlSymbol>().ToArray();
var capturedAttributeValueStart = false;
var attributeValueStartLocation = span.Start;
// Default to DoubleQuotes. We purposefully do not persist NoQuotes ValueStyle to stay consistent with the
// TryParseBlock() variation of attribute parsing.
var attributeValueStyle = AttributeStructure.DoubleQuotes;
// The symbolOffset is initialized to 0 to expect worst case: "class=". If a quote is found later on for
// the attribute value the symbolOffset is adjusted accordingly.
var symbolOffset = 0;
string name = null;
// Iterate down through the symbols to find the name and the start of the value.
// We subtract the symbolOffset so we don't accept an ending quote of a span.
for (var i = 0; i < htmlSymbols.Length - symbolOffset; i++)
{
var symbol = htmlSymbols[i];
if (afterEquals)
{
// We've captured all leading whitespace, the attribute name, and an equals with an optional
// quote/double quote. We're now at: " asp-for='|...'" or " asp-for=|..."
// The goal here is to capture all symbols until the end of the attribute. Note this will not
// consume an ending quote due to the symbolOffset.
// When symbols are accepted into SpanBuilders, their locations get altered to be offset by the
// parent which is why we need to mark our start location prior to adding the symbol.
// This is needed to know the location of the attribute value start within the document.
if (!capturedAttributeValueStart)
{
capturedAttributeValueStart = true;
attributeValueStartLocation = symbol.Start;
}
builder.Accept(symbol);
}
else if (name == null && HtmlMarkupParser.IsValidAttributeNameSymbol(symbol))
{
// We've captured all leading whitespace prior to the attribute name.
// We're now at: " |asp-for='...'" or " |asp-for=..."
// The goal here is to capture the attribute name.
var nameBuilder = new StringBuilder();
// Move the indexer past the attribute name symbols.
for (var j = i; j < htmlSymbols.Length; j++)
{
var nameSymbol = htmlSymbols[j];
if (!HtmlMarkupParser.IsValidAttributeNameSymbol(nameSymbol))
{
break;
}
nameBuilder.Append(nameSymbol.Content);
i++;
}
i--;
name = nameBuilder.ToString();
attributeValueStartLocation = SourceLocationTracker.Advance(attributeValueStartLocation, name);
}
else if (symbol.Type == HtmlSymbolType.Equals)
{
// We've captured all leading whitespace and the attribute name.
// We're now at: " asp-for|='...'" or " asp-for|=..."
// The goal here is to consume the equal sign and the optional single/double-quote.
// The coming symbols will either be a quote or value (in the case that the value is unquoted).
SourceLocation symbolStartLocation;
// Skip the whitespace preceding the start of the attribute value.
do
{
i++; // Start from the symbol after '='.
} while (i < htmlSymbols.Length &&
(htmlSymbols[i].Type == HtmlSymbolType.WhiteSpace ||
htmlSymbols[i].Type == HtmlSymbolType.NewLine));
// Check for attribute start values, aka single or double quote
if (i < htmlSymbols.Length && IsQuote(htmlSymbols[i]))
{
if (htmlSymbols[i].Type == HtmlSymbolType.SingleQuote)
{
attributeValueStyle = AttributeStructure.SingleQuotes;
}
symbolStartLocation = htmlSymbols[i].Start;
// If there's a start quote then there must be an end quote to be valid, skip it.
symbolOffset = 1;
}
else
{
// We are at the symbol after equals. Go back to equals to ensure we don't skip past that symbol.
i--;
symbolStartLocation = symbol.Start;
}
attributeValueStartLocation = new SourceLocation(
symbolStartLocation.FilePath,
symbolStartLocation.AbsoluteIndex + 1,
symbolStartLocation.LineIndex,
symbolStartLocation.CharacterIndex + 1);
afterEquals = true;
}
else if (symbol.Type == HtmlSymbolType.WhiteSpace)
{
// We're at the start of the attribute, this branch may be hit on the first iterations of
// the loop since the parser separates attributes with their spaces included as symbols.
// We're at: "| asp-for='...'" or "| asp-for=..."
// Note: This will not be hit even for situations like asp-for ="..." because the core Razor
// parser currently does not know how to handle attributes in that format. This will be addressed
// by https://github.com/aspnet/Razor/issues/123.
attributeValueStartLocation = SourceLocationTracker.Advance(attributeValueStartLocation, symbol.Content);
}
}
// After all symbols have been added we need to set the builders start position so we do not indirectly
// modify the span's start location.
builder.Start = attributeValueStartLocation;
if (name == null)
{
// We couldn't find a name, if the original span content was whitespace it ultimately means the tag
// that owns this "attribute" is malformed and is expecting a user to type a new attribute.
// ex: <myTH class="btn"| |
if (!string.IsNullOrWhiteSpace(span.Content))
{
errorSink.OnError(
span.Start,
LegacyResources.TagHelperBlockRewriter_TagHelperAttributeListMustBeWellFormed,
span.Content.Length);
}
return(null);
}
var result = CreateTryParseResult(name, descriptors, processedBoundAttributeNames);
// If we're not after an equal then we should treat the value as if it were a minimized attribute.
Span attributeValue = null;
if (afterEquals)
{
attributeValue = CreateMarkupAttribute(builder, result);
}
else
{
attributeValueStyle = AttributeStructure.Minimized;
}
result.AttributeValueNode = attributeValue;
result.AttributeStructure = attributeValueStyle;
return(result);
}