diff --git a/src/Microsoft.AspNetCore.Razor.Language/Legacy/CSharpLanguageCharacteristics.cs b/src/Microsoft.AspNetCore.Razor.Language/Legacy/CSharpLanguageCharacteristics.cs index f0d38acfd6..e8144cbc0e 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Legacy/CSharpLanguageCharacteristics.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Legacy/CSharpLanguageCharacteristics.cs @@ -136,7 +136,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy case KnownTokenType.CommentStar: return SyntaxKind.RazorCommentStar; case KnownTokenType.CommentBody: - return SyntaxKind.RazorComment; + return SyntaxKind.RazorCommentLiteral; default: return SyntaxKind.Unknown; } diff --git a/src/Microsoft.AspNetCore.Razor.Language/Legacy/CSharpTokenizer.cs b/src/Microsoft.AspNetCore.Razor.Language/Legacy/CSharpTokenizer.cs index af20a51dfe..8d29ab0fea 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Legacy/CSharpTokenizer.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Legacy/CSharpTokenizer.cs @@ -133,7 +133,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy private new CSharpTokenizerState? CurrentState => (CSharpTokenizerState?)base.CurrentState; - public override SyntaxKind RazorCommentKind => SyntaxKind.RazorComment; + public override SyntaxKind RazorCommentKind => SyntaxKind.RazorCommentLiteral; public override SyntaxKind RazorCommentTransitionKind => SyntaxKind.RazorCommentTransition; diff --git a/src/Microsoft.AspNetCore.Razor.Language/Legacy/DirectiveCSharpTokenizer.cs b/src/Microsoft.AspNetCore.Razor.Language/Legacy/DirectiveCSharpTokenizer.cs index 4b63b47a03..59224e709f 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Legacy/DirectiveCSharpTokenizer.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Legacy/DirectiveCSharpTokenizer.cs @@ -54,7 +54,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy return kind != SyntaxKind.Whitespace && kind != SyntaxKind.NewLine && kind != SyntaxKind.CSharpComment && - kind != SyntaxKind.RazorComment && + kind != SyntaxKind.RazorCommentLiteral && kind != SyntaxKind.RazorCommentStar && kind != SyntaxKind.RazorCommentTransition && kind != SyntaxKind.Transition; diff --git a/src/Microsoft.AspNetCore.Razor.Language/Legacy/DirectiveHtmlTokenizer.cs b/src/Microsoft.AspNetCore.Razor.Language/Legacy/DirectiveHtmlTokenizer.cs index 7d39ebbe0a..4921c8aa1e 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Legacy/DirectiveHtmlTokenizer.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Legacy/DirectiveHtmlTokenizer.cs @@ -48,7 +48,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy { return kind != SyntaxKind.Whitespace && kind != SyntaxKind.NewLine && - kind != SyntaxKind.RazorComment && + kind != SyntaxKind.RazorCommentLiteral && kind != SyntaxKind.RazorCommentStar && kind != SyntaxKind.RazorCommentTransition && kind != SyntaxKind.Transition; diff --git a/src/Microsoft.AspNetCore.Razor.Language/Legacy/HtmlLanguageCharacteristics.cs b/src/Microsoft.AspNetCore.Razor.Language/Legacy/HtmlLanguageCharacteristics.cs index 40a1dd9b39..076df4c173 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Legacy/HtmlLanguageCharacteristics.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Legacy/HtmlLanguageCharacteristics.cs @@ -56,7 +56,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy return "@"; case SyntaxKind.Colon: return ":"; - case SyntaxKind.RazorComment: + case SyntaxKind.RazorCommentLiteral: return Resources.HtmlToken_RazorComment; case SyntaxKind.RazorCommentStar: return "*"; @@ -104,7 +104,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy case KnownTokenType.CommentStar: return SyntaxKind.RazorCommentStar; case KnownTokenType.CommentBody: - return SyntaxKind.RazorComment; + return SyntaxKind.RazorCommentLiteral; case KnownTokenType.Identifier: return SyntaxKind.HtmlTextLiteral; case KnownTokenType.Keyword: diff --git a/src/Microsoft.AspNetCore.Razor.Language/Legacy/HtmlTokenizer.cs b/src/Microsoft.AspNetCore.Razor.Language/Legacy/HtmlTokenizer.cs index e804eb3114..7ff2b50855 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Legacy/HtmlTokenizer.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Legacy/HtmlTokenizer.cs @@ -24,7 +24,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy public override SyntaxKind RazorCommentKind { - get { return SyntaxKind.RazorComment; } + get { return SyntaxKind.RazorCommentLiteral; } } public override SyntaxKind RazorCommentTransitionKind diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/Generated/Syntax.xml.Internal.Generated.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/Generated/Syntax.xml.Internal.Generated.cs new file mode 100644 index 0000000000..40ff62465d --- /dev/null +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/Generated/Syntax.xml.Internal.Generated.cs @@ -0,0 +1,1406 @@ +// + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using System.Threading; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax +{ + internal abstract partial class RazorSyntaxNode : GreenNode + { + internal RazorSyntaxNode(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + } + internal RazorSyntaxNode(SyntaxKind kind) + : base(kind) + { + } + } + + internal sealed partial class RazorCommentBlockSyntax : RazorSyntaxNode + { + private readonly SyntaxToken _startCommentTransition; + private readonly SyntaxToken _startCommentStar; + private readonly SyntaxToken _comment; + private readonly SyntaxToken _endCommentStar; + private readonly SyntaxToken _endCommentTransition; + + internal RazorCommentBlockSyntax(SyntaxKind kind, SyntaxToken startCommentTransition, SyntaxToken startCommentStar, SyntaxToken comment, SyntaxToken endCommentStar, SyntaxToken endCommentTransition, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + SlotCount = 5; + AdjustFlagsAndWidth(startCommentTransition); + _startCommentTransition = startCommentTransition; + AdjustFlagsAndWidth(startCommentStar); + _startCommentStar = startCommentStar; + if (comment != null) + { + AdjustFlagsAndWidth(comment); + _comment = comment; + } + AdjustFlagsAndWidth(endCommentStar); + _endCommentStar = endCommentStar; + AdjustFlagsAndWidth(endCommentTransition); + _endCommentTransition = endCommentTransition; + } + + + internal RazorCommentBlockSyntax(SyntaxKind kind, SyntaxToken startCommentTransition, SyntaxToken startCommentStar, SyntaxToken comment, SyntaxToken endCommentStar, SyntaxToken endCommentTransition) + : base(kind) + { + SlotCount = 5; + AdjustFlagsAndWidth(startCommentTransition); + _startCommentTransition = startCommentTransition; + AdjustFlagsAndWidth(startCommentStar); + _startCommentStar = startCommentStar; + if (comment != null) + { + AdjustFlagsAndWidth(comment); + _comment = comment; + } + AdjustFlagsAndWidth(endCommentStar); + _endCommentStar = endCommentStar; + AdjustFlagsAndWidth(endCommentTransition); + _endCommentTransition = endCommentTransition; + } + + public SyntaxToken StartCommentTransition { get { return _startCommentTransition; } } + public SyntaxToken StartCommentStar { get { return _startCommentStar; } } + public SyntaxToken Comment { get { return _comment; } } + public SyntaxToken EndCommentStar { get { return _endCommentStar; } } + public SyntaxToken EndCommentTransition { get { return _endCommentTransition; } } + + internal override GreenNode GetSlot(int index) + { + switch (index) + { + case 0: return _startCommentTransition; + case 1: return _startCommentStar; + case 2: return _comment; + case 3: return _endCommentStar; + case 4: return _endCommentTransition; + default: return null; + } + } + + internal override SyntaxNode CreateRed(SyntaxNode parent, int position) + { + return new Syntax.RazorCommentBlockSyntax(this, parent, position); + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitRazorCommentBlock(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitRazorCommentBlock(this); + } + + public RazorCommentBlockSyntax Update(SyntaxToken startCommentTransition, SyntaxToken startCommentStar, SyntaxToken comment, SyntaxToken endCommentStar, SyntaxToken endCommentTransition) + { + if (startCommentTransition != StartCommentTransition || startCommentStar != StartCommentStar || comment != Comment || endCommentStar != EndCommentStar || endCommentTransition != EndCommentTransition) + { + var newNode = SyntaxFactory.RazorCommentBlock(startCommentTransition, startCommentStar, comment, endCommentStar, endCommentTransition); + var diags = GetDiagnostics(); + if (diags != null && diags.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) + { + return new RazorCommentBlockSyntax(Kind, _startCommentTransition, _startCommentStar, _comment, _endCommentStar, _endCommentTransition, diagnostics, GetAnnotations()); + } + + internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) + { + return new RazorCommentBlockSyntax(Kind, _startCommentTransition, _startCommentStar, _comment, _endCommentStar, _endCommentTransition, GetDiagnostics(), annotations); + } + } + + internal abstract partial class HtmlSyntaxNode : RazorSyntaxNode + { + internal HtmlSyntaxNode(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + } + internal HtmlSyntaxNode(SyntaxKind kind) + : base(kind) + { + } + } + + internal sealed partial class HtmlTextSyntax : HtmlSyntaxNode + { + private readonly GreenNode _textTokens; + + internal HtmlTextSyntax(SyntaxKind kind, GreenNode textTokens, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + SlotCount = 1; + if (textTokens != null) + { + AdjustFlagsAndWidth(textTokens); + _textTokens = textTokens; + } + } + + + internal HtmlTextSyntax(SyntaxKind kind, GreenNode textTokens) + : base(kind) + { + SlotCount = 1; + if (textTokens != null) + { + AdjustFlagsAndWidth(textTokens); + _textTokens = textTokens; + } + } + + public SyntaxList TextTokens { get { return new SyntaxList(_textTokens); } } + + internal override GreenNode GetSlot(int index) + { + switch (index) + { + case 0: return _textTokens; + default: return null; + } + } + + internal override SyntaxNode CreateRed(SyntaxNode parent, int position) + { + return new Syntax.HtmlTextSyntax(this, parent, position); + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitHtmlText(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitHtmlText(this); + } + + public HtmlTextSyntax Update(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList textTokens) + { + if (textTokens != TextTokens) + { + var newNode = SyntaxFactory.HtmlText(textTokens); + var diags = GetDiagnostics(); + if (diags != null && diags.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) + { + return new HtmlTextSyntax(Kind, _textTokens, diagnostics, GetAnnotations()); + } + + internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) + { + return new HtmlTextSyntax(Kind, _textTokens, GetDiagnostics(), annotations); + } + } + + internal abstract partial class CSharpSyntaxNode : RazorSyntaxNode + { + internal CSharpSyntaxNode(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + } + internal CSharpSyntaxNode(SyntaxKind kind) + : base(kind) + { + } + } + + internal sealed partial class CSharpTransitionSyntax : CSharpSyntaxNode + { + private readonly SyntaxToken _transition; + + internal CSharpTransitionSyntax(SyntaxKind kind, SyntaxToken transition, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + SlotCount = 1; + AdjustFlagsAndWidth(transition); + _transition = transition; + } + + + internal CSharpTransitionSyntax(SyntaxKind kind, SyntaxToken transition) + : base(kind) + { + SlotCount = 1; + AdjustFlagsAndWidth(transition); + _transition = transition; + } + + public SyntaxToken Transition { get { return _transition; } } + + internal override GreenNode GetSlot(int index) + { + switch (index) + { + case 0: return _transition; + default: return null; + } + } + + internal override SyntaxNode CreateRed(SyntaxNode parent, int position) + { + return new Syntax.CSharpTransitionSyntax(this, parent, position); + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpTransition(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpTransition(this); + } + + public CSharpTransitionSyntax Update(SyntaxToken transition) + { + if (transition != Transition) + { + var newNode = SyntaxFactory.CSharpTransition(transition); + var diags = GetDiagnostics(); + if (diags != null && diags.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) + { + return new CSharpTransitionSyntax(Kind, _transition, diagnostics, GetAnnotations()); + } + + internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) + { + return new CSharpTransitionSyntax(Kind, _transition, GetDiagnostics(), annotations); + } + } + + internal sealed partial class CSharpMetaCodeSyntax : CSharpSyntaxNode + { + private readonly GreenNode _metaCode; + + internal CSharpMetaCodeSyntax(SyntaxKind kind, GreenNode metaCode, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + SlotCount = 1; + if (metaCode != null) + { + AdjustFlagsAndWidth(metaCode); + _metaCode = metaCode; + } + } + + + internal CSharpMetaCodeSyntax(SyntaxKind kind, GreenNode metaCode) + : base(kind) + { + SlotCount = 1; + if (metaCode != null) + { + AdjustFlagsAndWidth(metaCode); + _metaCode = metaCode; + } + } + + public SyntaxList MetaCode { get { return new SyntaxList(_metaCode); } } + + internal override GreenNode GetSlot(int index) + { + switch (index) + { + case 0: return _metaCode; + default: return null; + } + } + + internal override SyntaxNode CreateRed(SyntaxNode parent, int position) + { + return new Syntax.CSharpMetaCodeSyntax(this, parent, position); + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpMetaCode(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpMetaCode(this); + } + + public CSharpMetaCodeSyntax Update(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList metaCode) + { + if (metaCode != MetaCode) + { + var newNode = SyntaxFactory.CSharpMetaCode(metaCode); + var diags = GetDiagnostics(); + if (diags != null && diags.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) + { + return new CSharpMetaCodeSyntax(Kind, _metaCode, diagnostics, GetAnnotations()); + } + + internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) + { + return new CSharpMetaCodeSyntax(Kind, _metaCode, GetDiagnostics(), annotations); + } + } + + internal sealed partial class CSharpCodeLiteralSyntax : CSharpSyntaxNode + { + private readonly GreenNode _cSharpTokens; + + internal CSharpCodeLiteralSyntax(SyntaxKind kind, GreenNode cSharpTokens, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + SlotCount = 1; + if (cSharpTokens != null) + { + AdjustFlagsAndWidth(cSharpTokens); + _cSharpTokens = cSharpTokens; + } + } + + + internal CSharpCodeLiteralSyntax(SyntaxKind kind, GreenNode cSharpTokens) + : base(kind) + { + SlotCount = 1; + if (cSharpTokens != null) + { + AdjustFlagsAndWidth(cSharpTokens); + _cSharpTokens = cSharpTokens; + } + } + + public SyntaxList CSharpTokens { get { return new SyntaxList(_cSharpTokens); } } + + internal override GreenNode GetSlot(int index) + { + switch (index) + { + case 0: return _cSharpTokens; + default: return null; + } + } + + internal override SyntaxNode CreateRed(SyntaxNode parent, int position) + { + return new Syntax.CSharpCodeLiteralSyntax(this, parent, position); + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpCodeLiteral(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpCodeLiteral(this); + } + + public CSharpCodeLiteralSyntax Update(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList cSharpTokens) + { + if (cSharpTokens != CSharpTokens) + { + var newNode = SyntaxFactory.CSharpCodeLiteral(cSharpTokens); + var diags = GetDiagnostics(); + if (diags != null && diags.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) + { + return new CSharpCodeLiteralSyntax(Kind, _cSharpTokens, diagnostics, GetAnnotations()); + } + + internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) + { + return new CSharpCodeLiteralSyntax(Kind, _cSharpTokens, GetDiagnostics(), annotations); + } + } + + internal sealed partial class CSharpCodeBlockSyntax : CSharpSyntaxNode + { + private readonly GreenNode _children; + + internal CSharpCodeBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + SlotCount = 1; + if (children != null) + { + AdjustFlagsAndWidth(children); + _children = children; + } + } + + + internal CSharpCodeBlockSyntax(SyntaxKind kind, GreenNode children) + : base(kind) + { + SlotCount = 1; + if (children != null) + { + AdjustFlagsAndWidth(children); + _children = children; + } + } + + public SyntaxList Children { get { return new SyntaxList(_children); } } + + internal override GreenNode GetSlot(int index) + { + switch (index) + { + case 0: return _children; + default: return null; + } + } + + internal override SyntaxNode CreateRed(SyntaxNode parent, int position) + { + return new Syntax.CSharpCodeBlockSyntax(this, parent, position); + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpCodeBlock(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpCodeBlock(this); + } + + public CSharpCodeBlockSyntax Update(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList children) + { + if (children != Children) + { + var newNode = SyntaxFactory.CSharpCodeBlock(children); + var diags = GetDiagnostics(); + if (diags != null && diags.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) + { + return new CSharpCodeBlockSyntax(Kind, _children, diagnostics, GetAnnotations()); + } + + internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) + { + return new CSharpCodeBlockSyntax(Kind, _children, GetDiagnostics(), annotations); + } + } + + internal abstract partial class CSharpBlockSyntax : CSharpSyntaxNode + { + internal CSharpBlockSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + } + internal CSharpBlockSyntax(SyntaxKind kind) + : base(kind) + { + } + + public abstract CSharpTransitionSyntax Transition { get; } + + public abstract CSharpSyntaxNode Body { get; } + } + + internal sealed partial class CSharpStatement : CSharpBlockSyntax + { + private readonly CSharpTransitionSyntax _transition; + private readonly CSharpSyntaxNode _body; + + internal CSharpStatement(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + SlotCount = 2; + AdjustFlagsAndWidth(transition); + _transition = transition; + AdjustFlagsAndWidth(body); + _body = body; + } + + + internal CSharpStatement(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body) + : base(kind) + { + SlotCount = 2; + AdjustFlagsAndWidth(transition); + _transition = transition; + AdjustFlagsAndWidth(body); + _body = body; + } + + public override CSharpTransitionSyntax Transition { get { return _transition; } } + public override CSharpSyntaxNode Body { get { return _body; } } + + internal override GreenNode GetSlot(int index) + { + switch (index) + { + case 0: return _transition; + case 1: return _body; + default: return null; + } + } + + internal override SyntaxNode CreateRed(SyntaxNode parent, int position) + { + return new Syntax.CSharpStatement(this, parent, position); + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpStatement(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpStatement(this); + } + + public CSharpStatement Update(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + { + if (transition != Transition || body != Body) + { + var newNode = SyntaxFactory.CSharpStatement(transition, body); + var diags = GetDiagnostics(); + if (diags != null && diags.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) + { + return new CSharpStatement(Kind, _transition, _body, diagnostics, GetAnnotations()); + } + + internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) + { + return new CSharpStatement(Kind, _transition, _body, GetDiagnostics(), annotations); + } + } + + internal sealed partial class CSharpStatementBodySyntax : CSharpSyntaxNode + { + private readonly CSharpMetaCodeSyntax _openBrace; + private readonly CSharpCodeBlockSyntax _cSharpCode; + private readonly CSharpMetaCodeSyntax _closeBrace; + + internal CSharpStatementBodySyntax(SyntaxKind kind, CSharpMetaCodeSyntax openBrace, CSharpCodeBlockSyntax cSharpCode, CSharpMetaCodeSyntax closeBrace, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + SlotCount = 3; + AdjustFlagsAndWidth(openBrace); + _openBrace = openBrace; + AdjustFlagsAndWidth(cSharpCode); + _cSharpCode = cSharpCode; + AdjustFlagsAndWidth(closeBrace); + _closeBrace = closeBrace; + } + + + internal CSharpStatementBodySyntax(SyntaxKind kind, CSharpMetaCodeSyntax openBrace, CSharpCodeBlockSyntax cSharpCode, CSharpMetaCodeSyntax closeBrace) + : base(kind) + { + SlotCount = 3; + AdjustFlagsAndWidth(openBrace); + _openBrace = openBrace; + AdjustFlagsAndWidth(cSharpCode); + _cSharpCode = cSharpCode; + AdjustFlagsAndWidth(closeBrace); + _closeBrace = closeBrace; + } + + public CSharpMetaCodeSyntax OpenBrace { get { return _openBrace; } } + public CSharpCodeBlockSyntax CSharpCode { get { return _cSharpCode; } } + public CSharpMetaCodeSyntax CloseBrace { get { return _closeBrace; } } + + internal override GreenNode GetSlot(int index) + { + switch (index) + { + case 0: return _openBrace; + case 1: return _cSharpCode; + case 2: return _closeBrace; + default: return null; + } + } + + internal override SyntaxNode CreateRed(SyntaxNode parent, int position) + { + return new Syntax.CSharpStatementBodySyntax(this, parent, position); + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpStatementBody(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpStatementBody(this); + } + + public CSharpStatementBodySyntax Update(CSharpMetaCodeSyntax openBrace, CSharpCodeBlockSyntax cSharpCode, CSharpMetaCodeSyntax closeBrace) + { + if (openBrace != OpenBrace || cSharpCode != CSharpCode || closeBrace != CloseBrace) + { + var newNode = SyntaxFactory.CSharpStatementBody(openBrace, cSharpCode, closeBrace); + var diags = GetDiagnostics(); + if (diags != null && diags.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) + { + return new CSharpStatementBodySyntax(Kind, _openBrace, _cSharpCode, _closeBrace, diagnostics, GetAnnotations()); + } + + internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) + { + return new CSharpStatementBodySyntax(Kind, _openBrace, _cSharpCode, _closeBrace, GetDiagnostics(), annotations); + } + } + + internal sealed partial class CSharpExpression : CSharpBlockSyntax + { + private readonly CSharpTransitionSyntax _transition; + private readonly CSharpSyntaxNode _body; + + internal CSharpExpression(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + SlotCount = 2; + AdjustFlagsAndWidth(transition); + _transition = transition; + AdjustFlagsAndWidth(body); + _body = body; + } + + + internal CSharpExpression(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body) + : base(kind) + { + SlotCount = 2; + AdjustFlagsAndWidth(transition); + _transition = transition; + AdjustFlagsAndWidth(body); + _body = body; + } + + public override CSharpTransitionSyntax Transition { get { return _transition; } } + public override CSharpSyntaxNode Body { get { return _body; } } + + internal override GreenNode GetSlot(int index) + { + switch (index) + { + case 0: return _transition; + case 1: return _body; + default: return null; + } + } + + internal override SyntaxNode CreateRed(SyntaxNode parent, int position) + { + return new Syntax.CSharpExpression(this, parent, position); + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpExpression(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpExpression(this); + } + + public CSharpExpression Update(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + { + if (transition != Transition || body != Body) + { + var newNode = SyntaxFactory.CSharpExpression(transition, body); + var diags = GetDiagnostics(); + if (diags != null && diags.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) + { + return new CSharpExpression(Kind, _transition, _body, diagnostics, GetAnnotations()); + } + + internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) + { + return new CSharpExpression(Kind, _transition, _body, GetDiagnostics(), annotations); + } + } + + internal sealed partial class CSharpExpressionBodySyntax : CSharpSyntaxNode + { + private readonly CSharpMetaCodeSyntax _openParen; + private readonly CSharpCodeBlockSyntax _cSharpCode; + private readonly CSharpMetaCodeSyntax _closeParen; + + internal CSharpExpressionBodySyntax(SyntaxKind kind, CSharpMetaCodeSyntax openParen, CSharpCodeBlockSyntax cSharpCode, CSharpMetaCodeSyntax closeParen, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + SlotCount = 3; + if (openParen != null) + { + AdjustFlagsAndWidth(openParen); + _openParen = openParen; + } + AdjustFlagsAndWidth(cSharpCode); + _cSharpCode = cSharpCode; + if (closeParen != null) + { + AdjustFlagsAndWidth(closeParen); + _closeParen = closeParen; + } + } + + + internal CSharpExpressionBodySyntax(SyntaxKind kind, CSharpMetaCodeSyntax openParen, CSharpCodeBlockSyntax cSharpCode, CSharpMetaCodeSyntax closeParen) + : base(kind) + { + SlotCount = 3; + if (openParen != null) + { + AdjustFlagsAndWidth(openParen); + _openParen = openParen; + } + AdjustFlagsAndWidth(cSharpCode); + _cSharpCode = cSharpCode; + if (closeParen != null) + { + AdjustFlagsAndWidth(closeParen); + _closeParen = closeParen; + } + } + + public CSharpMetaCodeSyntax OpenParen { get { return _openParen; } } + public CSharpCodeBlockSyntax CSharpCode { get { return _cSharpCode; } } + public CSharpMetaCodeSyntax CloseParen { get { return _closeParen; } } + + internal override GreenNode GetSlot(int index) + { + switch (index) + { + case 0: return _openParen; + case 1: return _cSharpCode; + case 2: return _closeParen; + default: return null; + } + } + + internal override SyntaxNode CreateRed(SyntaxNode parent, int position) + { + return new Syntax.CSharpExpressionBodySyntax(this, parent, position); + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpExpressionBody(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpExpressionBody(this); + } + + public CSharpExpressionBodySyntax Update(CSharpMetaCodeSyntax openParen, CSharpCodeBlockSyntax cSharpCode, CSharpMetaCodeSyntax closeParen) + { + if (openParen != OpenParen || cSharpCode != CSharpCode || closeParen != CloseParen) + { + var newNode = SyntaxFactory.CSharpExpressionBody(openParen, cSharpCode, closeParen); + var diags = GetDiagnostics(); + if (diags != null && diags.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) + { + return new CSharpExpressionBodySyntax(Kind, _openParen, _cSharpCode, _closeParen, diagnostics, GetAnnotations()); + } + + internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) + { + return new CSharpExpressionBodySyntax(Kind, _openParen, _cSharpCode, _closeParen, GetDiagnostics(), annotations); + } + } + + internal sealed partial class CSharpDirectiveSyntax : CSharpBlockSyntax + { + private readonly CSharpTransitionSyntax _transition; + private readonly CSharpSyntaxNode _body; + + internal CSharpDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + SlotCount = 2; + AdjustFlagsAndWidth(transition); + _transition = transition; + AdjustFlagsAndWidth(body); + _body = body; + } + + + internal CSharpDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body) + : base(kind) + { + SlotCount = 2; + AdjustFlagsAndWidth(transition); + _transition = transition; + AdjustFlagsAndWidth(body); + _body = body; + } + + public override CSharpTransitionSyntax Transition { get { return _transition; } } + public override CSharpSyntaxNode Body { get { return _body; } } + + internal override GreenNode GetSlot(int index) + { + switch (index) + { + case 0: return _transition; + case 1: return _body; + default: return null; + } + } + + internal override SyntaxNode CreateRed(SyntaxNode parent, int position) + { + return new Syntax.CSharpDirectiveSyntax(this, parent, position); + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpDirective(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpDirective(this); + } + + public CSharpDirectiveSyntax Update(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + { + if (transition != Transition || body != Body) + { + var newNode = SyntaxFactory.CSharpDirective(transition, body); + var diags = GetDiagnostics(); + if (diags != null && diags.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) + { + return new CSharpDirectiveSyntax(Kind, _transition, _body, diagnostics, GetAnnotations()); + } + + internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) + { + return new CSharpDirectiveSyntax(Kind, _transition, _body, GetDiagnostics(), annotations); + } + } + + internal sealed partial class CSharpDirectiveBodySyntax : CSharpSyntaxNode + { + private readonly CSharpMetaCodeSyntax _keyword; + private readonly CSharpCodeBlockSyntax _cSharpCode; + + internal CSharpDirectiveBodySyntax(SyntaxKind kind, CSharpMetaCodeSyntax keyword, CSharpCodeBlockSyntax cSharpCode, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) + : base(kind, diagnostics, annotations) + { + SlotCount = 2; + AdjustFlagsAndWidth(keyword); + _keyword = keyword; + AdjustFlagsAndWidth(cSharpCode); + _cSharpCode = cSharpCode; + } + + + internal CSharpDirectiveBodySyntax(SyntaxKind kind, CSharpMetaCodeSyntax keyword, CSharpCodeBlockSyntax cSharpCode) + : base(kind) + { + SlotCount = 2; + AdjustFlagsAndWidth(keyword); + _keyword = keyword; + AdjustFlagsAndWidth(cSharpCode); + _cSharpCode = cSharpCode; + } + + public CSharpMetaCodeSyntax Keyword { get { return _keyword; } } + public CSharpCodeBlockSyntax CSharpCode { get { return _cSharpCode; } } + + internal override GreenNode GetSlot(int index) + { + switch (index) + { + case 0: return _keyword; + case 1: return _cSharpCode; + default: return null; + } + } + + internal override SyntaxNode CreateRed(SyntaxNode parent, int position) + { + return new Syntax.CSharpDirectiveBodySyntax(this, parent, position); + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpDirectiveBody(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpDirectiveBody(this); + } + + public CSharpDirectiveBodySyntax Update(CSharpMetaCodeSyntax keyword, CSharpCodeBlockSyntax cSharpCode) + { + if (keyword != Keyword || cSharpCode != CSharpCode) + { + var newNode = SyntaxFactory.CSharpDirectiveBody(keyword, cSharpCode); + var diags = GetDiagnostics(); + if (diags != null && diags.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) + { + return new CSharpDirectiveBodySyntax(Kind, _keyword, _cSharpCode, diagnostics, GetAnnotations()); + } + + internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) + { + return new CSharpDirectiveBodySyntax(Kind, _keyword, _cSharpCode, GetDiagnostics(), annotations); + } + } + + internal partial class SyntaxVisitor + { + public virtual TResult VisitRazorCommentBlock(RazorCommentBlockSyntax node) + { + return DefaultVisit(node); + } + + public virtual TResult VisitHtmlText(HtmlTextSyntax node) + { + return DefaultVisit(node); + } + + public virtual TResult VisitCSharpTransition(CSharpTransitionSyntax node) + { + return DefaultVisit(node); + } + + public virtual TResult VisitCSharpMetaCode(CSharpMetaCodeSyntax node) + { + return DefaultVisit(node); + } + + public virtual TResult VisitCSharpCodeLiteral(CSharpCodeLiteralSyntax node) + { + return DefaultVisit(node); + } + + public virtual TResult VisitCSharpCodeBlock(CSharpCodeBlockSyntax node) + { + return DefaultVisit(node); + } + + public virtual TResult VisitCSharpStatement(CSharpStatement node) + { + return DefaultVisit(node); + } + + public virtual TResult VisitCSharpStatementBody(CSharpStatementBodySyntax node) + { + return DefaultVisit(node); + } + + public virtual TResult VisitCSharpExpression(CSharpExpression node) + { + return DefaultVisit(node); + } + + public virtual TResult VisitCSharpExpressionBody(CSharpExpressionBodySyntax node) + { + return DefaultVisit(node); + } + + public virtual TResult VisitCSharpDirective(CSharpDirectiveSyntax node) + { + return DefaultVisit(node); + } + + public virtual TResult VisitCSharpDirectiveBody(CSharpDirectiveBodySyntax node) + { + return DefaultVisit(node); + } + } + + + internal partial class SyntaxVisitor + { + public virtual void VisitRazorCommentBlock(RazorCommentBlockSyntax node) + { + DefaultVisit(node); + } + + public virtual void VisitHtmlText(HtmlTextSyntax node) + { + DefaultVisit(node); + } + + public virtual void VisitCSharpTransition(CSharpTransitionSyntax node) + { + DefaultVisit(node); + } + + public virtual void VisitCSharpMetaCode(CSharpMetaCodeSyntax node) + { + DefaultVisit(node); + } + + public virtual void VisitCSharpCodeLiteral(CSharpCodeLiteralSyntax node) + { + DefaultVisit(node); + } + + public virtual void VisitCSharpCodeBlock(CSharpCodeBlockSyntax node) + { + DefaultVisit(node); + } + + public virtual void VisitCSharpStatement(CSharpStatement node) + { + DefaultVisit(node); + } + + public virtual void VisitCSharpStatementBody(CSharpStatementBodySyntax node) + { + DefaultVisit(node); + } + + public virtual void VisitCSharpExpression(CSharpExpression node) + { + DefaultVisit(node); + } + + public virtual void VisitCSharpExpressionBody(CSharpExpressionBodySyntax node) + { + DefaultVisit(node); + } + + public virtual void VisitCSharpDirective(CSharpDirectiveSyntax node) + { + DefaultVisit(node); + } + + public virtual void VisitCSharpDirectiveBody(CSharpDirectiveBodySyntax node) + { + DefaultVisit(node); + } + } + + internal static partial class SyntaxFactory + { + public static RazorCommentBlockSyntax RazorCommentBlock(SyntaxToken startCommentTransition, SyntaxToken startCommentStar, SyntaxToken comment, SyntaxToken endCommentStar, SyntaxToken endCommentTransition) + { + if (startCommentTransition == null) + throw new ArgumentNullException(nameof(startCommentTransition)); + switch (startCommentTransition.Kind) + { + case SyntaxKind.RazorCommentTransition: + break; + default: + throw new ArgumentException("startCommentTransition"); + } + if (startCommentStar == null) + throw new ArgumentNullException(nameof(startCommentStar)); + switch (startCommentStar.Kind) + { + case SyntaxKind.RazorCommentStar: + break; + default: + throw new ArgumentException("startCommentStar"); + } + if (comment != null) + { + switch (comment.Kind) + { + case SyntaxKind.RazorComment: + case SyntaxKind.Unknown: + break; + default: + throw new ArgumentException("comment"); + } + } + if (endCommentStar == null) + throw new ArgumentNullException(nameof(endCommentStar)); + switch (endCommentStar.Kind) + { + case SyntaxKind.RazorCommentStar: + break; + default: + throw new ArgumentException("endCommentStar"); + } + if (endCommentTransition == null) + throw new ArgumentNullException(nameof(endCommentTransition)); + switch (endCommentTransition.Kind) + { + case SyntaxKind.RazorCommentTransition: + break; + default: + throw new ArgumentException("endCommentTransition"); + } + + return new RazorCommentBlockSyntax(SyntaxKind.RazorComment, startCommentTransition, startCommentStar, comment, endCommentStar, endCommentTransition); + } + + public static HtmlTextSyntax HtmlText(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList textTokens) + { + var result = new HtmlTextSyntax(SyntaxKind.HtmlText, textTokens.Node); + + return result; + } + + public static CSharpTransitionSyntax CSharpTransition(SyntaxToken transition) + { + if (transition == null) + throw new ArgumentNullException(nameof(transition)); + switch (transition.Kind) + { + case SyntaxKind.Transition: + break; + default: + throw new ArgumentException("transition"); + } + + var result = new CSharpTransitionSyntax(SyntaxKind.CSharpTransition, transition); + + return result; + } + + public static CSharpMetaCodeSyntax CSharpMetaCode(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList metaCode) + { + var result = new CSharpMetaCodeSyntax(SyntaxKind.CSharpMetaCode, metaCode.Node); + + return result; + } + + public static CSharpCodeLiteralSyntax CSharpCodeLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList cSharpTokens) + { + var result = new CSharpCodeLiteralSyntax(SyntaxKind.CSharpCodeLiteral, cSharpTokens.Node); + + return result; + } + + public static CSharpCodeBlockSyntax CSharpCodeBlock(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList children) + { + var result = new CSharpCodeBlockSyntax(SyntaxKind.CSharpCodeBlock, children.Node); + + return result; + } + + public static CSharpStatement CSharpStatement(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + { + if (transition == null) + throw new ArgumentNullException(nameof(transition)); + if (body == null) + throw new ArgumentNullException(nameof(body)); + + var result = new CSharpStatement(SyntaxKind.CSharpStatement, transition, body); + + return result; + } + + public static CSharpStatementBodySyntax CSharpStatementBody(CSharpMetaCodeSyntax openBrace, CSharpCodeBlockSyntax cSharpCode, CSharpMetaCodeSyntax closeBrace) + { + if (openBrace == null) + throw new ArgumentNullException(nameof(openBrace)); + if (cSharpCode == null) + throw new ArgumentNullException(nameof(cSharpCode)); + if (closeBrace == null) + throw new ArgumentNullException(nameof(closeBrace)); + + var result = new CSharpStatementBodySyntax(SyntaxKind.CSharpStatementBody, openBrace, cSharpCode, closeBrace); + + return result; + } + + public static CSharpExpression CSharpExpression(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + { + if (transition == null) + throw new ArgumentNullException(nameof(transition)); + if (body == null) + throw new ArgumentNullException(nameof(body)); + + var result = new CSharpExpression(SyntaxKind.CSharpExpression, transition, body); + + return result; + } + + public static CSharpExpressionBodySyntax CSharpExpressionBody(CSharpMetaCodeSyntax openParen, CSharpCodeBlockSyntax cSharpCode, CSharpMetaCodeSyntax closeParen) + { + if (cSharpCode == null) + throw new ArgumentNullException(nameof(cSharpCode)); + + var result = new CSharpExpressionBodySyntax(SyntaxKind.CSharpExpressionBody, openParen, cSharpCode, closeParen); + + return result; + } + + public static CSharpDirectiveSyntax CSharpDirective(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + { + if (transition == null) + throw new ArgumentNullException(nameof(transition)); + if (body == null) + throw new ArgumentNullException(nameof(body)); + + var result = new CSharpDirectiveSyntax(SyntaxKind.CSharpDirective, transition, body); + + return result; + } + + public static CSharpDirectiveBodySyntax CSharpDirectiveBody(CSharpMetaCodeSyntax keyword, CSharpCodeBlockSyntax cSharpCode) + { + if (keyword == null) + throw new ArgumentNullException(nameof(keyword)); + if (cSharpCode == null) + throw new ArgumentNullException(nameof(cSharpCode)); + + var result = new CSharpDirectiveBodySyntax(SyntaxKind.CSharpDirectiveBody, keyword, cSharpCode); + + return result; + } + + internal static IEnumerable GetNodeTypes() + { + return new Type[] { + typeof(RazorCommentBlockSyntax), + typeof(HtmlTextSyntax), + typeof(CSharpTransitionSyntax), + typeof(CSharpMetaCodeSyntax), + typeof(CSharpCodeLiteralSyntax), + typeof(CSharpCodeBlockSyntax), + typeof(CSharpStatement), + typeof(CSharpStatementBodySyntax), + typeof(CSharpExpression), + typeof(CSharpExpressionBodySyntax), + typeof(CSharpDirectiveSyntax), + typeof(CSharpDirectiveBodySyntax) + }; + } + } +} diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/Generated/Syntax.xml.Main.Generated.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/Generated/Syntax.xml.Main.Generated.cs new file mode 100644 index 0000000000..eff06d746b --- /dev/null +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/Generated/Syntax.xml.Main.Generated.cs @@ -0,0 +1,375 @@ +// + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using System.Threading; + + +namespace Microsoft.AspNetCore.Razor.Language.Syntax +{ + internal partial class SyntaxVisitor + { + /// Called when the visitor visits a RazorCommentBlockSyntax node. + public virtual TResult VisitRazorCommentBlock(RazorCommentBlockSyntax node) + { + return DefaultVisit(node); + } + + /// Called when the visitor visits a HtmlTextSyntax node. + public virtual TResult VisitHtmlText(HtmlTextSyntax node) + { + return DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpTransitionSyntax node. + public virtual TResult VisitCSharpTransition(CSharpTransitionSyntax node) + { + return DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpMetaCodeSyntax node. + public virtual TResult VisitCSharpMetaCode(CSharpMetaCodeSyntax node) + { + return DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpCodeLiteralSyntax node. + public virtual TResult VisitCSharpCodeLiteral(CSharpCodeLiteralSyntax node) + { + return DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpCodeBlockSyntax node. + public virtual TResult VisitCSharpCodeBlock(CSharpCodeBlockSyntax node) + { + return DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpStatement node. + public virtual TResult VisitCSharpStatement(CSharpStatement node) + { + return DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpStatementBodySyntax node. + public virtual TResult VisitCSharpStatementBody(CSharpStatementBodySyntax node) + { + return DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpExpression node. + public virtual TResult VisitCSharpExpression(CSharpExpression node) + { + return DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpExpressionBodySyntax node. + public virtual TResult VisitCSharpExpressionBody(CSharpExpressionBodySyntax node) + { + return DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpDirectiveSyntax node. + public virtual TResult VisitCSharpDirective(CSharpDirectiveSyntax node) + { + return DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpDirectiveBodySyntax node. + public virtual TResult VisitCSharpDirectiveBody(CSharpDirectiveBodySyntax node) + { + return DefaultVisit(node); + } + } + + internal partial class SyntaxVisitor + { + /// Called when the visitor visits a RazorCommentBlockSyntax node. + public virtual void VisitRazorCommentBlock(RazorCommentBlockSyntax node) + { + DefaultVisit(node); + } + + /// Called when the visitor visits a HtmlTextSyntax node. + public virtual void VisitHtmlText(HtmlTextSyntax node) + { + DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpTransitionSyntax node. + public virtual void VisitCSharpTransition(CSharpTransitionSyntax node) + { + DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpMetaCodeSyntax node. + public virtual void VisitCSharpMetaCode(CSharpMetaCodeSyntax node) + { + DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpCodeLiteralSyntax node. + public virtual void VisitCSharpCodeLiteral(CSharpCodeLiteralSyntax node) + { + DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpCodeBlockSyntax node. + public virtual void VisitCSharpCodeBlock(CSharpCodeBlockSyntax node) + { + DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpStatement node. + public virtual void VisitCSharpStatement(CSharpStatement node) + { + DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpStatementBodySyntax node. + public virtual void VisitCSharpStatementBody(CSharpStatementBodySyntax node) + { + DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpExpression node. + public virtual void VisitCSharpExpression(CSharpExpression node) + { + DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpExpressionBodySyntax node. + public virtual void VisitCSharpExpressionBody(CSharpExpressionBodySyntax node) + { + DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpDirectiveSyntax node. + public virtual void VisitCSharpDirective(CSharpDirectiveSyntax node) + { + DefaultVisit(node); + } + + /// Called when the visitor visits a CSharpDirectiveBodySyntax node. + public virtual void VisitCSharpDirectiveBody(CSharpDirectiveBodySyntax node) + { + DefaultVisit(node); + } + } + + internal static partial class SyntaxFactory + { + /// Creates a new RazorCommentBlockSyntax instance. + public static RazorCommentBlockSyntax RazorCommentBlock(SyntaxToken startCommentTransition, SyntaxToken startCommentStar, SyntaxToken comment, SyntaxToken endCommentStar, SyntaxToken endCommentTransition) + { + switch (startCommentTransition.Kind) + { + case SyntaxKind.RazorCommentTransition: + break; + default: + throw new ArgumentException("startCommentTransition"); + } + switch (startCommentStar.Kind) + { + case SyntaxKind.RazorCommentStar: + break; + default: + throw new ArgumentException("startCommentStar"); + } + switch (comment.Kind) + { + case SyntaxKind.RazorComment: + case SyntaxKind.Unknown: + break; + default: + throw new ArgumentException("comment"); + } + switch (endCommentStar.Kind) + { + case SyntaxKind.RazorCommentStar: + break; + default: + throw new ArgumentException("endCommentStar"); + } + switch (endCommentTransition.Kind) + { + case SyntaxKind.RazorCommentTransition: + break; + default: + throw new ArgumentException("endCommentTransition"); + } + return (RazorCommentBlockSyntax)InternalSyntax.SyntaxFactory.RazorCommentBlock((Syntax.InternalSyntax.SyntaxToken)startCommentTransition.Green, (Syntax.InternalSyntax.SyntaxToken)startCommentStar.Green, (Syntax.InternalSyntax.SyntaxToken)comment.Green, (Syntax.InternalSyntax.SyntaxToken)endCommentStar.Green, (Syntax.InternalSyntax.SyntaxToken)endCommentTransition.Green).CreateRed(); + } + + /// Creates a new RazorCommentBlockSyntax instance. + public static RazorCommentBlockSyntax RazorCommentBlock() + { + return SyntaxFactory.RazorCommentBlock(SyntaxFactory.Token(SyntaxKind.RazorCommentTransition), SyntaxFactory.Token(SyntaxKind.RazorCommentStar), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.RazorCommentStar), SyntaxFactory.Token(SyntaxKind.RazorCommentTransition)); + } + + /// Creates a new HtmlTextSyntax instance. + public static HtmlTextSyntax HtmlText(SyntaxList textTokens) + { + return (HtmlTextSyntax)InternalSyntax.SyntaxFactory.HtmlText(textTokens.Node.ToGreenList()).CreateRed(); + } + + /// Creates a new HtmlTextSyntax instance. + public static HtmlTextSyntax HtmlText() + { + return SyntaxFactory.HtmlText(default(SyntaxList)); + } + + /// Creates a new CSharpTransitionSyntax instance. + public static CSharpTransitionSyntax CSharpTransition(SyntaxToken transition) + { + switch (transition.Kind) + { + case SyntaxKind.Transition: + break; + default: + throw new ArgumentException("transition"); + } + return (CSharpTransitionSyntax)InternalSyntax.SyntaxFactory.CSharpTransition((Syntax.InternalSyntax.SyntaxToken)transition.Green).CreateRed(); + } + + /// Creates a new CSharpTransitionSyntax instance. + public static CSharpTransitionSyntax CSharpTransition() + { + return SyntaxFactory.CSharpTransition(SyntaxFactory.Token(SyntaxKind.Transition)); + } + + /// Creates a new CSharpMetaCodeSyntax instance. + public static CSharpMetaCodeSyntax CSharpMetaCode(SyntaxList metaCode) + { + return (CSharpMetaCodeSyntax)InternalSyntax.SyntaxFactory.CSharpMetaCode(metaCode.Node.ToGreenList()).CreateRed(); + } + + /// Creates a new CSharpMetaCodeSyntax instance. + public static CSharpMetaCodeSyntax CSharpMetaCode() + { + return SyntaxFactory.CSharpMetaCode(default(SyntaxList)); + } + + /// Creates a new CSharpCodeLiteralSyntax instance. + public static CSharpCodeLiteralSyntax CSharpCodeLiteral(SyntaxList cSharpTokens) + { + return (CSharpCodeLiteralSyntax)InternalSyntax.SyntaxFactory.CSharpCodeLiteral(cSharpTokens.Node.ToGreenList()).CreateRed(); + } + + /// Creates a new CSharpCodeLiteralSyntax instance. + public static CSharpCodeLiteralSyntax CSharpCodeLiteral() + { + return SyntaxFactory.CSharpCodeLiteral(default(SyntaxList)); + } + + /// Creates a new CSharpCodeBlockSyntax instance. + public static CSharpCodeBlockSyntax CSharpCodeBlock(SyntaxList children) + { + return (CSharpCodeBlockSyntax)InternalSyntax.SyntaxFactory.CSharpCodeBlock(children.Node.ToGreenList()).CreateRed(); + } + + /// Creates a new CSharpCodeBlockSyntax instance. + public static CSharpCodeBlockSyntax CSharpCodeBlock() + { + return SyntaxFactory.CSharpCodeBlock(default(SyntaxList)); + } + + /// Creates a new CSharpStatement instance. + public static CSharpStatement CSharpStatement(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + { + if (transition == null) + throw new ArgumentNullException(nameof(transition)); + if (body == null) + throw new ArgumentNullException(nameof(body)); + return (CSharpStatement)InternalSyntax.SyntaxFactory.CSharpStatement(transition == null ? null : (InternalSyntax.CSharpTransitionSyntax)transition.Green, body == null ? null : (InternalSyntax.CSharpSyntaxNode)body.Green).CreateRed(); + } + + /// Creates a new CSharpStatement instance. + public static CSharpStatement CSharpStatement(CSharpSyntaxNode body) + { + return SyntaxFactory.CSharpStatement(SyntaxFactory.CSharpTransition(), body); + } + + /// Creates a new CSharpStatementBodySyntax instance. + public static CSharpStatementBodySyntax CSharpStatementBody(CSharpMetaCodeSyntax openBrace, CSharpCodeBlockSyntax cSharpCode, CSharpMetaCodeSyntax closeBrace) + { + if (openBrace == null) + throw new ArgumentNullException(nameof(openBrace)); + if (cSharpCode == null) + throw new ArgumentNullException(nameof(cSharpCode)); + if (closeBrace == null) + throw new ArgumentNullException(nameof(closeBrace)); + return (CSharpStatementBodySyntax)InternalSyntax.SyntaxFactory.CSharpStatementBody(openBrace == null ? null : (InternalSyntax.CSharpMetaCodeSyntax)openBrace.Green, cSharpCode == null ? null : (InternalSyntax.CSharpCodeBlockSyntax)cSharpCode.Green, closeBrace == null ? null : (InternalSyntax.CSharpMetaCodeSyntax)closeBrace.Green).CreateRed(); + } + + /// Creates a new CSharpStatementBodySyntax instance. + public static CSharpStatementBodySyntax CSharpStatementBody() + { + return SyntaxFactory.CSharpStatementBody(SyntaxFactory.CSharpMetaCode(), SyntaxFactory.CSharpCodeBlock(), SyntaxFactory.CSharpMetaCode()); + } + + /// Creates a new CSharpExpression instance. + public static CSharpExpression CSharpExpression(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + { + if (transition == null) + throw new ArgumentNullException(nameof(transition)); + if (body == null) + throw new ArgumentNullException(nameof(body)); + return (CSharpExpression)InternalSyntax.SyntaxFactory.CSharpExpression(transition == null ? null : (InternalSyntax.CSharpTransitionSyntax)transition.Green, body == null ? null : (InternalSyntax.CSharpSyntaxNode)body.Green).CreateRed(); + } + + /// Creates a new CSharpExpression instance. + public static CSharpExpression CSharpExpression(CSharpSyntaxNode body) + { + return SyntaxFactory.CSharpExpression(SyntaxFactory.CSharpTransition(), body); + } + + /// Creates a new CSharpExpressionBodySyntax instance. + public static CSharpExpressionBodySyntax CSharpExpressionBody(CSharpMetaCodeSyntax openParen, CSharpCodeBlockSyntax cSharpCode, CSharpMetaCodeSyntax closeParen) + { + if (cSharpCode == null) + throw new ArgumentNullException(nameof(cSharpCode)); + return (CSharpExpressionBodySyntax)InternalSyntax.SyntaxFactory.CSharpExpressionBody(openParen == null ? null : (InternalSyntax.CSharpMetaCodeSyntax)openParen.Green, cSharpCode == null ? null : (InternalSyntax.CSharpCodeBlockSyntax)cSharpCode.Green, closeParen == null ? null : (InternalSyntax.CSharpMetaCodeSyntax)closeParen.Green).CreateRed(); + } + + /// Creates a new CSharpExpressionBodySyntax instance. + public static CSharpExpressionBodySyntax CSharpExpressionBody() + { + return SyntaxFactory.CSharpExpressionBody(default(CSharpMetaCodeSyntax), SyntaxFactory.CSharpCodeBlock(), default(CSharpMetaCodeSyntax)); + } + + /// Creates a new CSharpDirectiveSyntax instance. + public static CSharpDirectiveSyntax CSharpDirective(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + { + if (transition == null) + throw new ArgumentNullException(nameof(transition)); + if (body == null) + throw new ArgumentNullException(nameof(body)); + return (CSharpDirectiveSyntax)InternalSyntax.SyntaxFactory.CSharpDirective(transition == null ? null : (InternalSyntax.CSharpTransitionSyntax)transition.Green, body == null ? null : (InternalSyntax.CSharpSyntaxNode)body.Green).CreateRed(); + } + + /// Creates a new CSharpDirectiveSyntax instance. + public static CSharpDirectiveSyntax CSharpDirective(CSharpSyntaxNode body) + { + return SyntaxFactory.CSharpDirective(SyntaxFactory.CSharpTransition(), body); + } + + /// Creates a new CSharpDirectiveBodySyntax instance. + public static CSharpDirectiveBodySyntax CSharpDirectiveBody(CSharpMetaCodeSyntax keyword, CSharpCodeBlockSyntax cSharpCode) + { + if (keyword == null) + throw new ArgumentNullException(nameof(keyword)); + if (cSharpCode == null) + throw new ArgumentNullException(nameof(cSharpCode)); + return (CSharpDirectiveBodySyntax)InternalSyntax.SyntaxFactory.CSharpDirectiveBody(keyword == null ? null : (InternalSyntax.CSharpMetaCodeSyntax)keyword.Green, cSharpCode == null ? null : (InternalSyntax.CSharpCodeBlockSyntax)cSharpCode.Green).CreateRed(); + } + + /// Creates a new CSharpDirectiveBodySyntax instance. + public static CSharpDirectiveBodySyntax CSharpDirectiveBody() + { + return SyntaxFactory.CSharpDirectiveBody(SyntaxFactory.CSharpMetaCode(), SyntaxFactory.CSharpCodeBlock()); + } + } +} diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/Generated/Syntax.xml.Syntax.Generated.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/Generated/Syntax.xml.Syntax.Generated.cs new file mode 100644 index 0000000000..f3d3236c8d --- /dev/null +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/Generated/Syntax.xml.Syntax.Generated.cs @@ -0,0 +1,1079 @@ +// + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using System.Threading; + + +namespace Microsoft.AspNetCore.Razor.Language.Syntax +{ + internal abstract partial class RazorSyntaxNode : SyntaxNode + { + internal RazorSyntaxNode(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + } + + internal sealed partial class RazorCommentBlockSyntax : RazorSyntaxNode + { + private SyntaxToken _startCommentTransition; + private SyntaxToken _startCommentStar; + private SyntaxToken _comment; + private SyntaxToken _endCommentStar; + private SyntaxToken _endCommentTransition; + + internal RazorCommentBlockSyntax(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public SyntaxToken StartCommentTransition + { + get + { + return GetRedAtZero(ref _startCommentTransition); + } + } + + public SyntaxToken StartCommentStar + { + get + { + return GetRed(ref _startCommentStar, 1); + } + } + + public SyntaxToken Comment + { + get + { + return GetRed(ref _comment, 2); + } + } + + public SyntaxToken EndCommentStar + { + get + { + return GetRed(ref _endCommentStar, 3); + } + } + + public SyntaxToken EndCommentTransition + { + get + { + return GetRed(ref _endCommentTransition, 4); + } + } + + internal override SyntaxNode GetNodeSlot(int index) + { + switch (index) + { + case 0: return GetRedAtZero(ref _startCommentTransition); + case 1: return GetRed(ref _startCommentStar, 1); + case 2: return GetRed(ref _comment, 2); + case 3: return GetRed(ref _endCommentStar, 3); + case 4: return GetRed(ref _endCommentTransition, 4); + default: return null; + } + } + internal override SyntaxNode GetCachedSlot(int index) + { + switch (index) + { + case 0: return _startCommentTransition; + case 1: return _startCommentStar; + case 2: return _comment; + case 3: return _endCommentStar; + case 4: return _endCommentTransition; + default: return null; + } + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitRazorCommentBlock(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitRazorCommentBlock(this); + } + + public RazorCommentBlockSyntax Update(SyntaxToken startCommentTransition, SyntaxToken startCommentStar, SyntaxToken comment, SyntaxToken endCommentStar, SyntaxToken endCommentTransition) + { + if (startCommentTransition != StartCommentTransition || startCommentStar != StartCommentStar || comment != Comment || endCommentStar != EndCommentStar || endCommentTransition != EndCommentTransition) + { + var newNode = SyntaxFactory.RazorCommentBlock(startCommentTransition, startCommentStar, comment, endCommentStar, endCommentTransition); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + return newNode.WithAnnotations(annotations); + return newNode; + } + + return this; + } + + public RazorCommentBlockSyntax WithStartCommentTransition(SyntaxToken startCommentTransition) + { + return Update(startCommentTransition, _startCommentStar, _comment, _endCommentStar, _endCommentTransition); + } + + public RazorCommentBlockSyntax WithStartCommentStar(SyntaxToken startCommentStar) + { + return Update(_startCommentTransition, startCommentStar, _comment, _endCommentStar, _endCommentTransition); + } + + public RazorCommentBlockSyntax WithComment(SyntaxToken comment) + { + return Update(_startCommentTransition, _startCommentStar, comment, _endCommentStar, _endCommentTransition); + } + + public RazorCommentBlockSyntax WithEndCommentStar(SyntaxToken endCommentStar) + { + return Update(_startCommentTransition, _startCommentStar, _comment, endCommentStar, _endCommentTransition); + } + + public RazorCommentBlockSyntax WithEndCommentTransition(SyntaxToken endCommentTransition) + { + return Update(_startCommentTransition, _startCommentStar, _comment, _endCommentStar, endCommentTransition); + } + } + + internal abstract partial class HtmlSyntaxNode : RazorSyntaxNode + { + internal HtmlSyntaxNode(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + } + + internal sealed partial class HtmlTextSyntax : HtmlSyntaxNode + { + private SyntaxNode _textTokens; + + internal HtmlTextSyntax(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public SyntaxList TextTokens + { + get + { + return new SyntaxList(GetRed(ref _textTokens, 0)); + } + } + + internal override SyntaxNode GetNodeSlot(int index) + { + switch (index) + { + case 0: return GetRedAtZero(ref _textTokens); + default: return null; + } + } + internal override SyntaxNode GetCachedSlot(int index) + { + switch (index) + { + case 0: return _textTokens; + default: return null; + } + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitHtmlText(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitHtmlText(this); + } + + public HtmlTextSyntax Update(SyntaxList textTokens) + { + if (textTokens != TextTokens) + { + var newNode = SyntaxFactory.HtmlText(textTokens); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + return newNode.WithAnnotations(annotations); + return newNode; + } + + return this; + } + + public HtmlTextSyntax WithTextTokens(SyntaxList textTokens) + { + return Update(textTokens); + } + + public HtmlTextSyntax AddTextTokens(params SyntaxToken[] items) + { + return WithTextTokens(this.TextTokens.AddRange(items)); + } + } + + internal abstract partial class CSharpSyntaxNode : RazorSyntaxNode + { + internal CSharpSyntaxNode(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + } + + internal sealed partial class CSharpTransitionSyntax : CSharpSyntaxNode + { + private SyntaxToken _transition; + + internal CSharpTransitionSyntax(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public SyntaxToken Transition + { + get + { + return GetRedAtZero(ref _transition); + } + } + + internal override SyntaxNode GetNodeSlot(int index) + { + switch (index) + { + case 0: return GetRedAtZero(ref _transition); + default: return null; + } + } + internal override SyntaxNode GetCachedSlot(int index) + { + switch (index) + { + case 0: return _transition; + default: return null; + } + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpTransition(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpTransition(this); + } + + public CSharpTransitionSyntax Update(SyntaxToken transition) + { + if (transition != Transition) + { + var newNode = SyntaxFactory.CSharpTransition(transition); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + return newNode.WithAnnotations(annotations); + return newNode; + } + + return this; + } + + public CSharpTransitionSyntax WithTransition(SyntaxToken transition) + { + return Update(transition); + } + } + + internal sealed partial class CSharpMetaCodeSyntax : CSharpSyntaxNode + { + private SyntaxNode _metaCode; + + internal CSharpMetaCodeSyntax(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public SyntaxList MetaCode + { + get + { + return new SyntaxList(GetRed(ref _metaCode, 0)); + } + } + + internal override SyntaxNode GetNodeSlot(int index) + { + switch (index) + { + case 0: return GetRedAtZero(ref _metaCode); + default: return null; + } + } + internal override SyntaxNode GetCachedSlot(int index) + { + switch (index) + { + case 0: return _metaCode; + default: return null; + } + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpMetaCode(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpMetaCode(this); + } + + public CSharpMetaCodeSyntax Update(SyntaxList metaCode) + { + if (metaCode != MetaCode) + { + var newNode = SyntaxFactory.CSharpMetaCode(metaCode); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + return newNode.WithAnnotations(annotations); + return newNode; + } + + return this; + } + + public CSharpMetaCodeSyntax WithMetaCode(SyntaxList metaCode) + { + return Update(metaCode); + } + + public CSharpMetaCodeSyntax AddMetaCode(params SyntaxToken[] items) + { + return WithMetaCode(this.MetaCode.AddRange(items)); + } + } + + internal sealed partial class CSharpCodeLiteralSyntax : CSharpSyntaxNode + { + private SyntaxNode _cSharpTokens; + + internal CSharpCodeLiteralSyntax(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public SyntaxList CSharpTokens + { + get + { + return new SyntaxList(GetRed(ref _cSharpTokens, 0)); + } + } + + internal override SyntaxNode GetNodeSlot(int index) + { + switch (index) + { + case 0: return GetRedAtZero(ref _cSharpTokens); + default: return null; + } + } + internal override SyntaxNode GetCachedSlot(int index) + { + switch (index) + { + case 0: return _cSharpTokens; + default: return null; + } + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpCodeLiteral(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpCodeLiteral(this); + } + + public CSharpCodeLiteralSyntax Update(SyntaxList cSharpTokens) + { + if (cSharpTokens != CSharpTokens) + { + var newNode = SyntaxFactory.CSharpCodeLiteral(cSharpTokens); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + return newNode.WithAnnotations(annotations); + return newNode; + } + + return this; + } + + public CSharpCodeLiteralSyntax WithCSharpTokens(SyntaxList cSharpTokens) + { + return Update(cSharpTokens); + } + + public CSharpCodeLiteralSyntax AddCSharpTokens(params SyntaxToken[] items) + { + return WithCSharpTokens(this.CSharpTokens.AddRange(items)); + } + } + + internal sealed partial class CSharpCodeBlockSyntax : CSharpSyntaxNode + { + private SyntaxNode _children; + + internal CSharpCodeBlockSyntax(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public SyntaxList Children + { + get + { + return new SyntaxList(GetRed(ref _children, 0)); + } + } + + internal override SyntaxNode GetNodeSlot(int index) + { + switch (index) + { + case 0: return GetRedAtZero(ref _children); + default: return null; + } + } + internal override SyntaxNode GetCachedSlot(int index) + { + switch (index) + { + case 0: return _children; + default: return null; + } + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpCodeBlock(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpCodeBlock(this); + } + + public CSharpCodeBlockSyntax Update(SyntaxList children) + { + if (children != Children) + { + var newNode = SyntaxFactory.CSharpCodeBlock(children); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + return newNode.WithAnnotations(annotations); + return newNode; + } + + return this; + } + + public CSharpCodeBlockSyntax WithChildren(SyntaxList children) + { + return Update(children); + } + + public CSharpCodeBlockSyntax AddChildren(params RazorSyntaxNode[] items) + { + return WithChildren(this.Children.AddRange(items)); + } + } + + internal abstract partial class CSharpBlockSyntax : CSharpSyntaxNode + { + internal CSharpBlockSyntax(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public abstract CSharpTransitionSyntax Transition { get; } + public CSharpBlockSyntax WithTransition(CSharpTransitionSyntax _transition) => WithTransitionCore(_transition); + internal abstract CSharpBlockSyntax WithTransitionCore(CSharpTransitionSyntax _transition); + + public abstract CSharpSyntaxNode Body { get; } + public CSharpBlockSyntax WithBody(CSharpSyntaxNode _body) => WithBodyCore(_body); + internal abstract CSharpBlockSyntax WithBodyCore(CSharpSyntaxNode _body); + } + + internal sealed partial class CSharpStatement : CSharpBlockSyntax + { + private CSharpTransitionSyntax _transition; + private CSharpSyntaxNode _body; + + internal CSharpStatement(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public override CSharpTransitionSyntax Transition + { + get + { + return GetRedAtZero(ref _transition); + } + } + + public override CSharpSyntaxNode Body + { + get + { + return GetRed(ref _body, 1); + } + } + + internal override SyntaxNode GetNodeSlot(int index) + { + switch (index) + { + case 0: return GetRedAtZero(ref _transition); + case 1: return GetRed(ref _body, 1); + default: return null; + } + } + internal override SyntaxNode GetCachedSlot(int index) + { + switch (index) + { + case 0: return _transition; + case 1: return _body; + default: return null; + } + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpStatement(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpStatement(this); + } + + public CSharpStatement Update(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + { + if (transition != Transition || body != Body) + { + var newNode = SyntaxFactory.CSharpStatement(transition, body); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + return newNode.WithAnnotations(annotations); + return newNode; + } + + return this; + } + + internal override CSharpBlockSyntax WithTransitionCore(CSharpTransitionSyntax transition) => WithTransition(transition); + public new CSharpStatement WithTransition(CSharpTransitionSyntax transition) + { + return Update(transition, _body); + } + + internal override CSharpBlockSyntax WithBodyCore(CSharpSyntaxNode body) => WithBody(body); + public new CSharpStatement WithBody(CSharpSyntaxNode body) + { + return Update(_transition, body); + } + } + + internal sealed partial class CSharpStatementBodySyntax : CSharpSyntaxNode + { + private CSharpMetaCodeSyntax _openBrace; + private CSharpCodeBlockSyntax _cSharpCode; + private CSharpMetaCodeSyntax _closeBrace; + + internal CSharpStatementBodySyntax(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public CSharpMetaCodeSyntax OpenBrace + { + get + { + return GetRedAtZero(ref _openBrace); + } + } + + public CSharpCodeBlockSyntax CSharpCode + { + get + { + return GetRed(ref _cSharpCode, 1); + } + } + + public CSharpMetaCodeSyntax CloseBrace + { + get + { + return GetRed(ref _closeBrace, 2); + } + } + + internal override SyntaxNode GetNodeSlot(int index) + { + switch (index) + { + case 0: return GetRedAtZero(ref _openBrace); + case 1: return GetRed(ref _cSharpCode, 1); + case 2: return GetRed(ref _closeBrace, 2); + default: return null; + } + } + internal override SyntaxNode GetCachedSlot(int index) + { + switch (index) + { + case 0: return _openBrace; + case 1: return _cSharpCode; + case 2: return _closeBrace; + default: return null; + } + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpStatementBody(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpStatementBody(this); + } + + public CSharpStatementBodySyntax Update(CSharpMetaCodeSyntax openBrace, CSharpCodeBlockSyntax cSharpCode, CSharpMetaCodeSyntax closeBrace) + { + if (openBrace != OpenBrace || cSharpCode != CSharpCode || closeBrace != CloseBrace) + { + var newNode = SyntaxFactory.CSharpStatementBody(openBrace, cSharpCode, closeBrace); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + return newNode.WithAnnotations(annotations); + return newNode; + } + + return this; + } + + public CSharpStatementBodySyntax WithOpenBrace(CSharpMetaCodeSyntax openBrace) + { + return Update(openBrace, _cSharpCode, _closeBrace); + } + + public CSharpStatementBodySyntax WithCSharpCode(CSharpCodeBlockSyntax cSharpCode) + { + return Update(_openBrace, cSharpCode, _closeBrace); + } + + public CSharpStatementBodySyntax WithCloseBrace(CSharpMetaCodeSyntax closeBrace) + { + return Update(_openBrace, _cSharpCode, closeBrace); + } + + public CSharpStatementBodySyntax AddOpenBraceMetaCode(params SyntaxToken[] items) + { + return this.WithOpenBrace(this.OpenBrace.WithMetaCode(this.OpenBrace.MetaCode.AddRange(items))); + } + + public CSharpStatementBodySyntax AddCSharpCodeChildren(params RazorSyntaxNode[] items) + { + return this.WithCSharpCode(this.CSharpCode.WithChildren(this.CSharpCode.Children.AddRange(items))); + } + + public CSharpStatementBodySyntax AddCloseBraceMetaCode(params SyntaxToken[] items) + { + return this.WithCloseBrace(this.CloseBrace.WithMetaCode(this.CloseBrace.MetaCode.AddRange(items))); + } + } + + internal sealed partial class CSharpExpression : CSharpBlockSyntax + { + private CSharpTransitionSyntax _transition; + private CSharpSyntaxNode _body; + + internal CSharpExpression(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public override CSharpTransitionSyntax Transition + { + get + { + return GetRedAtZero(ref _transition); + } + } + + public override CSharpSyntaxNode Body + { + get + { + return GetRed(ref _body, 1); + } + } + + internal override SyntaxNode GetNodeSlot(int index) + { + switch (index) + { + case 0: return GetRedAtZero(ref _transition); + case 1: return GetRed(ref _body, 1); + default: return null; + } + } + internal override SyntaxNode GetCachedSlot(int index) + { + switch (index) + { + case 0: return _transition; + case 1: return _body; + default: return null; + } + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpExpression(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpExpression(this); + } + + public CSharpExpression Update(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + { + if (transition != Transition || body != Body) + { + var newNode = SyntaxFactory.CSharpExpression(transition, body); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + return newNode.WithAnnotations(annotations); + return newNode; + } + + return this; + } + + internal override CSharpBlockSyntax WithTransitionCore(CSharpTransitionSyntax transition) => WithTransition(transition); + public new CSharpExpression WithTransition(CSharpTransitionSyntax transition) + { + return Update(transition, _body); + } + + internal override CSharpBlockSyntax WithBodyCore(CSharpSyntaxNode body) => WithBody(body); + public new CSharpExpression WithBody(CSharpSyntaxNode body) + { + return Update(_transition, body); + } + } + + internal sealed partial class CSharpExpressionBodySyntax : CSharpSyntaxNode + { + private CSharpMetaCodeSyntax _openParen; + private CSharpCodeBlockSyntax _cSharpCode; + private CSharpMetaCodeSyntax _closeParen; + + internal CSharpExpressionBodySyntax(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public CSharpMetaCodeSyntax OpenParen + { + get + { + return GetRedAtZero(ref _openParen); + } + } + + public CSharpCodeBlockSyntax CSharpCode + { + get + { + return GetRed(ref _cSharpCode, 1); + } + } + + public CSharpMetaCodeSyntax CloseParen + { + get + { + return GetRed(ref _closeParen, 2); + } + } + + internal override SyntaxNode GetNodeSlot(int index) + { + switch (index) + { + case 0: return GetRedAtZero(ref _openParen); + case 1: return GetRed(ref _cSharpCode, 1); + case 2: return GetRed(ref _closeParen, 2); + default: return null; + } + } + internal override SyntaxNode GetCachedSlot(int index) + { + switch (index) + { + case 0: return _openParen; + case 1: return _cSharpCode; + case 2: return _closeParen; + default: return null; + } + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpExpressionBody(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpExpressionBody(this); + } + + public CSharpExpressionBodySyntax Update(CSharpMetaCodeSyntax openParen, CSharpCodeBlockSyntax cSharpCode, CSharpMetaCodeSyntax closeParen) + { + if (openParen != OpenParen || cSharpCode != CSharpCode || closeParen != CloseParen) + { + var newNode = SyntaxFactory.CSharpExpressionBody(openParen, cSharpCode, closeParen); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + return newNode.WithAnnotations(annotations); + return newNode; + } + + return this; + } + + public CSharpExpressionBodySyntax WithOpenParen(CSharpMetaCodeSyntax openParen) + { + return Update(openParen, _cSharpCode, _closeParen); + } + + public CSharpExpressionBodySyntax WithCSharpCode(CSharpCodeBlockSyntax cSharpCode) + { + return Update(_openParen, cSharpCode, _closeParen); + } + + public CSharpExpressionBodySyntax WithCloseParen(CSharpMetaCodeSyntax closeParen) + { + return Update(_openParen, _cSharpCode, closeParen); + } + + public CSharpExpressionBodySyntax AddOpenParenMetaCode(params SyntaxToken[] items) + { + var _openParen = this.OpenParen ?? SyntaxFactory.CSharpMetaCode(); + return this.WithOpenParen(_openParen.WithMetaCode(_openParen.MetaCode.AddRange(items))); + } + + public CSharpExpressionBodySyntax AddCSharpCodeChildren(params RazorSyntaxNode[] items) + { + return this.WithCSharpCode(this.CSharpCode.WithChildren(this.CSharpCode.Children.AddRange(items))); + } + + public CSharpExpressionBodySyntax AddCloseParenMetaCode(params SyntaxToken[] items) + { + var _closeParen = this.CloseParen ?? SyntaxFactory.CSharpMetaCode(); + return this.WithCloseParen(_closeParen.WithMetaCode(_closeParen.MetaCode.AddRange(items))); + } + } + + internal sealed partial class CSharpDirectiveSyntax : CSharpBlockSyntax + { + private CSharpTransitionSyntax _transition; + private CSharpSyntaxNode _body; + + internal CSharpDirectiveSyntax(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public override CSharpTransitionSyntax Transition + { + get + { + return GetRedAtZero(ref _transition); + } + } + + public override CSharpSyntaxNode Body + { + get + { + return GetRed(ref _body, 1); + } + } + + internal override SyntaxNode GetNodeSlot(int index) + { + switch (index) + { + case 0: return GetRedAtZero(ref _transition); + case 1: return GetRed(ref _body, 1); + default: return null; + } + } + internal override SyntaxNode GetCachedSlot(int index) + { + switch (index) + { + case 0: return _transition; + case 1: return _body; + default: return null; + } + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpDirective(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpDirective(this); + } + + public CSharpDirectiveSyntax Update(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + { + if (transition != Transition || body != Body) + { + var newNode = SyntaxFactory.CSharpDirective(transition, body); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + return newNode.WithAnnotations(annotations); + return newNode; + } + + return this; + } + + internal override CSharpBlockSyntax WithTransitionCore(CSharpTransitionSyntax transition) => WithTransition(transition); + public new CSharpDirectiveSyntax WithTransition(CSharpTransitionSyntax transition) + { + return Update(transition, _body); + } + + internal override CSharpBlockSyntax WithBodyCore(CSharpSyntaxNode body) => WithBody(body); + public new CSharpDirectiveSyntax WithBody(CSharpSyntaxNode body) + { + return Update(_transition, body); + } + } + + internal sealed partial class CSharpDirectiveBodySyntax : CSharpSyntaxNode + { + private CSharpMetaCodeSyntax _keyword; + private CSharpCodeBlockSyntax _cSharpCode; + + internal CSharpDirectiveBodySyntax(GreenNode green, SyntaxNode parent, int position) + : base(green, parent, position) + { + } + + public CSharpMetaCodeSyntax Keyword + { + get + { + return GetRedAtZero(ref _keyword); + } + } + + public CSharpCodeBlockSyntax CSharpCode + { + get + { + return GetRed(ref _cSharpCode, 1); + } + } + + internal override SyntaxNode GetNodeSlot(int index) + { + switch (index) + { + case 0: return GetRedAtZero(ref _keyword); + case 1: return GetRed(ref _cSharpCode, 1); + default: return null; + } + } + internal override SyntaxNode GetCachedSlot(int index) + { + switch (index) + { + case 0: return _keyword; + case 1: return _cSharpCode; + default: return null; + } + } + + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.VisitCSharpDirectiveBody(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitCSharpDirectiveBody(this); + } + + public CSharpDirectiveBodySyntax Update(CSharpMetaCodeSyntax keyword, CSharpCodeBlockSyntax cSharpCode) + { + if (keyword != Keyword || cSharpCode != CSharpCode) + { + var newNode = SyntaxFactory.CSharpDirectiveBody(keyword, cSharpCode); + var annotations = GetAnnotations(); + if (annotations != null && annotations.Length > 0) + return newNode.WithAnnotations(annotations); + return newNode; + } + + return this; + } + + public CSharpDirectiveBodySyntax WithKeyword(CSharpMetaCodeSyntax keyword) + { + return Update(keyword, _cSharpCode); + } + + public CSharpDirectiveBodySyntax WithCSharpCode(CSharpCodeBlockSyntax cSharpCode) + { + return Update(_keyword, cSharpCode); + } + + public CSharpDirectiveBodySyntax AddKeywordMetaCode(params SyntaxToken[] items) + { + return this.WithKeyword(this.Keyword.WithMetaCode(this.Keyword.MetaCode.AddRange(items))); + } + + public CSharpDirectiveBodySyntax AddCSharpCodeChildren(params RazorSyntaxNode[] items) + { + return this.WithCSharpCode(this.CSharpCode.WithChildren(this.CSharpCode.Children.AddRange(items))); + } + } +} diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/GreenNode.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/GreenNode.cs index e14cbc0594..7e05d7ab39 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/GreenNode.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/GreenNode.cs @@ -481,10 +481,9 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax internal abstract SyntaxNode CreateRed(SyntaxNode parent, int position); #endregion - internal virtual GreenNode Accept(InternalSyntax.SyntaxVisitor visitor) - { - return visitor.Visit(this); - } + public abstract TResult Accept(InternalSyntax.SyntaxVisitor visitor); + + public abstract void Accept(InternalSyntax.SyntaxVisitor visitor); #region StaticMethods diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/GreenNodeExtensions.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/GreenNodeExtensions.cs new file mode 100644 index 0000000000..6895dfdd02 --- /dev/null +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/GreenNodeExtensions.cs @@ -0,0 +1,56 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System.Collections.Generic; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax +{ + internal static class GreenNodeExtensions + { + internal static InternalSyntax.SyntaxList ToGreenList(this SyntaxNode node) where T : GreenNode + { + return node != null ? + ToGreenList(node.Green) : + default(InternalSyntax.SyntaxList); + } + + internal static InternalSyntax.SyntaxList ToGreenList(this GreenNode node) where T : GreenNode + { + return new InternalSyntax.SyntaxList(node); + } + + public static TNode WithAnnotationsGreen(this TNode node, IEnumerable annotations) where TNode : GreenNode + { + var newAnnotations = new List(); + foreach (var candidate in annotations) + { + if (!newAnnotations.Contains(candidate)) + { + newAnnotations.Add(candidate); + } + } + + if (newAnnotations.Count == 0) + { + var existingAnnotations = node.GetAnnotations(); + if (existingAnnotations == null || existingAnnotations.Length == 0) + { + return node; + } + else + { + return (TNode)node.SetAnnotations(null); + } + } + else + { + return (TNode)node.SetAnnotations(newAnnotations.ToArray()); + } + } + + public static TNode WithDiagnosticsGreen(this TNode node, RazorDiagnostic[] diagnostics) where TNode : GreenNode + { + return (TNode)node.SetDiagnostics(diagnostics); + } + } +} diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/HtmlNodeSyntax.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/HtmlNodeSyntax.cs deleted file mode 100644 index c247183c1d..0000000000 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/HtmlNodeSyntax.cs +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright (c) .NET Foundation. All rights reserved. -// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. - -namespace Microsoft.AspNetCore.Razor.Language.Syntax -{ - internal abstract class HtmlNodeSyntax : SyntaxNode - { - internal HtmlNodeSyntax(GreenNode green, SyntaxNode parent, int position) - : base(green, parent, position) - { - } - - internal new InternalSyntax.HtmlNodeSyntax Green => (InternalSyntax.HtmlNodeSyntax)base.Green; - - internal override SyntaxNode Accept(SyntaxVisitor visitor) - { - return visitor.VisitHtmlNode(this); - } - } -} diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/HtmlTextSyntax.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/HtmlTextSyntax.cs deleted file mode 100644 index a28dc9bbdd..0000000000 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/HtmlTextSyntax.cs +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright (c) .NET Foundation. All rights reserved. -// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. - -namespace Microsoft.AspNetCore.Razor.Language.Syntax -{ - internal class HtmlTextSyntax : HtmlNodeSyntax - { - private SyntaxNode _textTokens; - - internal HtmlTextSyntax(GreenNode green, SyntaxNode parent, int position) - : base(green, parent, position) - { - } - - public SyntaxList TextTokens => new SyntaxList(GetRed(ref _textTokens, 0)); - - public string Value => TextTokens[0]?.ToFullString() ?? string.Empty; - - internal override SyntaxNode Accept(SyntaxVisitor visitor) - { - return visitor.VisitHtmlText(this); - } - - internal override SyntaxNode GetCachedSlot(int index) - { - switch (index) - { - case 0: return _textTokens; - default: return null; - } - } - - internal override SyntaxNode GetNodeSlot(int slot) - { - switch (slot) - { - case 0: return GetRed(ref _textTokens, 0); - default: return null; - } - } - } -} diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/HtmlNodeSyntax.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/HtmlNodeSyntax.cs deleted file mode 100644 index 4289dfa683..0000000000 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/HtmlNodeSyntax.cs +++ /dev/null @@ -1,28 +0,0 @@ -// Copyright (c) .NET Foundation. All rights reserved. -// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. - -namespace Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax -{ - internal abstract class HtmlNodeSyntax : GreenNode - { - protected HtmlNodeSyntax(SyntaxKind kind) - : base(kind) - { - } - - protected HtmlNodeSyntax(SyntaxKind kind, int fullWidth) - : base(kind, fullWidth) - { - } - - protected HtmlNodeSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) - { - } - - internal override GreenNode Accept(SyntaxVisitor visitor) - { - return visitor.VisitHtmlNode(this); - } - } -} diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/HtmlTextSyntax.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/HtmlTextSyntax.cs deleted file mode 100644 index 57e3c4f113..0000000000 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/HtmlTextSyntax.cs +++ /dev/null @@ -1,59 +0,0 @@ -// Copyright (c) .NET Foundation. All rights reserved. -// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. - -using System; - -namespace Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax -{ - internal class HtmlTextSyntax : HtmlNodeSyntax - { - private readonly GreenNode _value; - - internal HtmlTextSyntax(GreenNode value) : base(SyntaxKind.HtmlText) - { - SlotCount = 1; - _value = value; - AdjustFlagsAndWidth(value); - } - - internal HtmlTextSyntax(GreenNode value, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(SyntaxKind.HtmlText, diagnostics, annotations) - { - SlotCount = 1; - _value = value; - AdjustFlagsAndWidth(value); - } - - internal SyntaxList TextTokens => new SyntaxList(_value); - - internal override GreenNode GetSlot(int index) - { - switch (index) - { - case 0: return _value; - } - - throw new InvalidOperationException(); - } - - internal override GreenNode Accept(SyntaxVisitor visitor) - { - return visitor.VisitHtmlText(this); - } - - internal override SyntaxNode CreateRed(SyntaxNode parent, int position) - { - return new Syntax.HtmlTextSyntax(this, parent, position); - } - - internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - { - return new HtmlTextSyntax(_value, diagnostics, GetAnnotations()); - } - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - { - return new HtmlTextSyntax(_value, GetDiagnostics(), annotations); - } - } -} diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxFactory.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxFactory.cs index 78b7f447d2..79562ded0d 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxFactory.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxFactory.cs @@ -6,13 +6,8 @@ using System.Linq; namespace Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax { - internal static class SyntaxFactory + internal static partial class SyntaxFactory { - internal static HtmlTextSyntax HtmlText(SyntaxList textTokens) - { - return new HtmlTextSyntax(textTokens.Node); - } - internal static SyntaxToken Token(SyntaxKind kind, string content, IEnumerable diagnostics) { return Token(kind, content, diagnostics.ToArray()); diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxList.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxList.cs index cd6270b599..ff466af513 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxList.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxList.cs @@ -121,6 +121,16 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax } } + public override TResult Accept(SyntaxVisitor visitor) + { + return visitor.Visit(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.Visit(this); + } + internal class WithTwoChildren : SyntaxList { private readonly GreenNode _child0; diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxToken.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxToken.cs index b7471591c8..3b11afa5e4 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxToken.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxToken.cs @@ -134,9 +134,14 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax throw new InvalidOperationException("Tokens don't have slots."); } - internal override GreenNode Accept(SyntaxVisitor visitor) + public override TResult Accept(SyntaxVisitor visitor) { - return visitor.VisitSyntaxToken(this); + return visitor.VisitToken(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitToken(this); } public override bool IsEquivalentTo(GreenNode other) diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxTrivia.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxTrivia.cs index 53867dc274..84ad53155a 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxTrivia.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxTrivia.cs @@ -62,9 +62,14 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax return new Syntax.SyntaxTrivia(this, parent, position); } - internal override GreenNode Accept(SyntaxVisitor visitor) + public override TResult Accept(SyntaxVisitor visitor) { - return visitor.VisitSyntaxTrivia(this); + return visitor.VisitTrivia(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitTrivia(this); } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxVisitor.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxVisitor.cs index 5e54b752f3..a00f30f477 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxVisitor.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/InternalSyntax/SyntaxVisitor.cs @@ -3,41 +3,58 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax { - internal abstract class SyntaxVisitor + internal abstract partial class SyntaxVisitor + { + public virtual TResult Visit(GreenNode node) + { + if (node == null) + { + return default(TResult); + } + + return node.Accept(this); + } + + public virtual TResult VisitToken(SyntaxToken token) + { + return DefaultVisit(token); + } + + public virtual TResult VisitTrivia(SyntaxTrivia trivia) + { + return DefaultVisit(trivia); + } + + protected virtual TResult DefaultVisit(GreenNode node) + { + return default(TResult); + } + } + + internal abstract partial class SyntaxVisitor { public virtual GreenNode Visit(GreenNode node) { if (node != null) { - return node.Accept(this); + node.Accept(this); } return null; } - public virtual GreenNode VisitSyntaxNode(GreenNode node) + public virtual void VisitToken(SyntaxToken token) { - return node; + DefaultVisit(token); } - public virtual GreenNode VisitHtmlNode(HtmlNodeSyntax node) + public virtual void VisitTrivia(SyntaxTrivia trivia) { - return VisitSyntaxNode(node); + DefaultVisit(trivia); } - public virtual GreenNode VisitHtmlText(HtmlTextSyntax node) + protected virtual void DefaultVisit(GreenNode node) { - return VisitHtmlNode(node); - } - - public virtual SyntaxToken VisitSyntaxToken(SyntaxToken token) - { - return token; - } - - public virtual SyntaxTrivia VisitSyntaxTrivia(SyntaxTrivia trivia) - { - return trivia; } } } diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/Syntax.xml b/src/Microsoft.AspNetCore.Razor.Language/Syntax/Syntax.xml new file mode 100644 index 0000000000..d1b9a0d960 --- /dev/null +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/Syntax.xml @@ -0,0 +1,102 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxFactory.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxFactory.cs index 46bfd219dc..98568d21d2 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxFactory.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxFactory.cs @@ -3,9 +3,14 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax { - internal static class SyntaxFactory + internal static partial class SyntaxFactory { - internal static SyntaxToken Token(SyntaxKind kind, string content, params RazorDiagnostic[] diagnostics) + public static SyntaxToken Token(SyntaxKind kind, params RazorDiagnostic[] diagnostics) + { + return Token(kind, content: string.Empty, diagnostics: diagnostics); + } + + public static SyntaxToken Token(SyntaxKind kind, string content, params RazorDiagnostic[] diagnostics) { return new SyntaxToken(InternalSyntax.SyntaxFactory.Token(kind, content), parent: null, position: 0); } diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxKind.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxKind.cs index 1cad1ed9f2..8cbc8f1363 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxKind.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxKind.cs @@ -6,9 +6,26 @@ namespace Microsoft.AspNetCore.Razor.Language internal enum SyntaxKind : byte { #region Nodes + // HTML HtmlText, HtmlDocument, HtmlDeclaration, + + // CSharp + CSharpBlock, + CSharpStatement, + CSharpStatementBody, + CSharpExpression, + CSharpExpressionBody, + CSharpDirective, + CSharpDirectiveBody, + CSharpCodeBlock, + CSharpCodeLiteral, + CSharpMetaCode, + CSharpTransition, + + // Common + RazorComment, #endregion #region Tokens @@ -89,7 +106,7 @@ namespace Microsoft.AspNetCore.Razor.Language Hash, // Razor specific - RazorComment, + RazorCommentLiteral, RazorCommentStar, RazorCommentTransition, #endregion diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxList.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxList.cs index e57b65599f..3b7d318e37 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxList.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxList.cs @@ -10,11 +10,16 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax { } - internal override SyntaxNode Accept(SyntaxVisitor visitor) + public override TResult Accept(SyntaxVisitor visitor) { return visitor.Visit(this); } + public override void Accept(SyntaxVisitor visitor) + { + visitor.Visit(this); + } + internal class WithTwoChildren : SyntaxList { private SyntaxNode _child0; diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxNode.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxNode.cs index f0634d10d3..1c63ed9663 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxNode.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxNode.cs @@ -80,7 +80,9 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax public bool ContainsAnnotations => Green.ContainsAnnotations; - internal abstract SyntaxNode Accept(SyntaxVisitor visitor); + public abstract TResult Accept(SyntaxVisitor visitor); + + public abstract void Accept(SyntaxVisitor visitor); internal abstract SyntaxNode GetNodeSlot(int index); @@ -103,6 +105,24 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax return result; } + // Special case of above function where slot = 0, does not need GetChildPosition + internal SyntaxNode GetRedAtZero(ref SyntaxNode field) + { + var result = field; + + if (result == null) + { + var green = Green.GetSlot(0); + if (green != null) + { + Interlocked.CompareExchange(ref field, green.CreateRed(this, Position), null); + result = field; + } + } + + return result; + } + protected T GetRed(ref T field, int slot) where T : SyntaxNode { var result = field; @@ -120,6 +140,24 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax return result; } + // special case of above function where slot = 0, does not need GetChildPosition + protected T GetRedAtZero(ref T field) where T : SyntaxNode + { + var result = field; + + if (result == null) + { + var green = Green.GetSlot(0); + if (green != null) + { + Interlocked.CompareExchange(ref field, (T)green.CreateRed(this, Position), null); + result = field; + } + } + + return result; + } + internal SyntaxNode GetRedElement(ref SyntaxNode element, int slot) { Debug.Assert(IsList); diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxNodeExtensions.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxNodeExtensions.cs new file mode 100644 index 0000000000..21ae1260ef --- /dev/null +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxNodeExtensions.cs @@ -0,0 +1,13 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +namespace Microsoft.AspNetCore.Razor.Language.Syntax +{ + internal static class SyntaxNodeExtensions + { + public static TNode WithAnnotations(this TNode node, params SyntaxAnnotation[] annotations) where TNode : SyntaxNode + { + return (TNode)node.Green.SetAnnotations(annotations).CreateRed(); + } + } +} diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxToken.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxToken.cs index c022f3634b..b87562f8f2 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxToken.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxToken.cs @@ -69,9 +69,14 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax throw new InvalidOperationException("Tokens can't have slots."); } - internal override SyntaxNode Accept(SyntaxVisitor visitor) + public override TResult Accept(SyntaxVisitor visitor) { - return visitor.VisitSyntaxToken(this); + return visitor.VisitToken(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitToken(this); } public SyntaxToken WithLeadingTrivia(SyntaxNode trivia) diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxTrivia.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxTrivia.cs index c576fee3d0..d16e42f1ed 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxTrivia.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxTrivia.cs @@ -26,9 +26,14 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax throw new InvalidOperationException(); } - internal override SyntaxNode Accept(SyntaxVisitor visitor) + public override TResult Accept(SyntaxVisitor visitor) { - return visitor.VisitSyntaxTrivia(this); + return visitor.VisitTrivia(this); + } + + public override void Accept(SyntaxVisitor visitor) + { + visitor.VisitTrivia(this); } public sealed override SyntaxTriviaList GetTrailingTrivia() diff --git a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxVisitor.cs b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxVisitor.cs index 08d833e515..98e1c8f245 100644 --- a/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxVisitor.cs +++ b/src/Microsoft.AspNetCore.Razor.Language/Syntax/SyntaxVisitor.cs @@ -3,41 +3,56 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax { - internal abstract class SyntaxVisitor + internal abstract partial class SyntaxVisitor { - public virtual SyntaxNode Visit(SyntaxNode node) + public virtual TResult Visit(SyntaxNode node) { if (node != null) { return node.Accept(this); } - return null; + return default(TResult); } - public virtual SyntaxNode VisitSyntaxNode(SyntaxNode node) + public virtual TResult VisitToken(SyntaxToken token) { - return node; + return DefaultVisit(token); } - public virtual SyntaxNode VisitHtmlNode(HtmlNodeSyntax node) + public virtual TResult VisitTrivia(SyntaxTrivia trivia) { - return VisitSyntaxNode(node); + return DefaultVisit(trivia); } - public virtual SyntaxNode VisitHtmlText(HtmlTextSyntax node) + protected virtual TResult DefaultVisit(SyntaxNode node) { - return VisitHtmlNode(node); + return default(TResult); + } + } + + internal abstract partial class SyntaxVisitor + { + public virtual void Visit(SyntaxNode node) + { + if (node != null) + { + node.Accept(this); + } } - public virtual SyntaxToken VisitSyntaxToken(SyntaxToken token) + public virtual void VisitToken(SyntaxToken token) { - return token; + DefaultVisit(token); } - public virtual SyntaxTrivia VisitSyntaxTrivia(SyntaxTrivia trivia) + public virtual void VisitTrivia(SyntaxTrivia trivia) + { + DefaultVisit(trivia); + } + + public virtual void DefaultVisit(SyntaxNode node) { - return trivia; } } } diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/CSharpTokenizerCommentTest.cs b/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/CSharpTokenizerCommentTest.cs index 4abaea783f..0a7c55cc34 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/CSharpTokenizerCommentTest.cs +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/CSharpTokenizerCommentTest.cs @@ -17,7 +17,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy "@* Foo * Bar * Baz *", SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), - SyntaxFactory.Token(SyntaxKind.RazorComment, " Foo * Bar * Baz *")); + SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo * Bar * Baz *")); } [Fact] @@ -27,7 +27,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy "@* Foo * Bar * Baz *@", SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), - SyntaxFactory.Token(SyntaxKind.RazorComment, " Foo * Bar * Baz "), + SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo * Bar * Baz "), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@")); } @@ -39,7 +39,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy "@* Foo Bar Baz *@", SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), - SyntaxFactory.Token(SyntaxKind.RazorComment, " Foo Bar Baz "), + SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo Bar Baz "), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@")); } diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/DirectiveCSharpTokenizerTest.cs b/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/DirectiveCSharpTokenizerTest.cs index 55f2626925..7f6e8db88a 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/DirectiveCSharpTokenizerTest.cs +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/DirectiveCSharpTokenizerTest.cs @@ -28,7 +28,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy "@*included*@\r\n @something \"value\"\r\n @this is ignored", SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), - SyntaxFactory.Token(SyntaxKind.RazorComment, "included"), + SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, "included"), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), SyntaxFactory.Token(SyntaxKind.NewLine, "\r\n"), diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/DirectiveHtmlTokenizerTest.cs b/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/DirectiveHtmlTokenizerTest.cs index 0df36e7a81..ffee2ab489 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/DirectiveHtmlTokenizerTest.cs +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/DirectiveHtmlTokenizerTest.cs @@ -27,7 +27,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy SyntaxFactory.Token(SyntaxKind.Whitespace, " "), SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), - SyntaxFactory.Token(SyntaxKind.RazorComment, "included"), + SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, "included"), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), SyntaxFactory.Token(SyntaxKind.Whitespace, " "), diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/HtmlTokenizerTest.cs b/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/HtmlTokenizerTest.cs index 472e64e28e..c17dbd0e87 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/HtmlTokenizerTest.cs +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/Legacy/HtmlTokenizerTest.cs @@ -134,7 +134,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy "@* Foo * Bar * Baz *", SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), - SyntaxFactory.Token(SyntaxKind.RazorComment, " Foo * Bar * Baz *")); + SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo * Bar * Baz *")); } [Fact] @@ -144,7 +144,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy "@* Foo * Bar * Baz *@", SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), - SyntaxFactory.Token(SyntaxKind.RazorComment, " Foo * Bar * Baz "), + SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo * Bar * Baz "), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@")); } @@ -156,7 +156,7 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy "@* Foo Bar Baz *@", SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), - SyntaxFactory.Token(SyntaxKind.RazorComment, " Foo Bar Baz "), + SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo Bar Baz "), SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@")); } diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenCatchAndFinallyClause.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenCatchAndFinallyClause.stree.txt index 4fc3ef825f..0c589bfbe6 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenCatchAndFinallyClause.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenCatchAndFinallyClause.stree.txt @@ -31,7 +31,7 @@ Statement block - Gen - 75 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (38:0,38) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Foo ] - SpanEditHandler;Accepts:Any - (39:0,39) - Tokens:1 - SyntaxKind.RazorComment;[ Foo ]; + SyntaxKind.RazorCommentLiteral;[ Foo ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (44:0,44) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (45:0,45) - Tokens:1 @@ -44,7 +44,7 @@ Statement block - Gen - 75 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (48:0,48) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Bar ] - SpanEditHandler;Accepts:Any - (49:0,49) - Tokens:1 - SyntaxKind.RazorComment;[ Bar ]; + SyntaxKind.RazorCommentLiteral;[ Bar ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (54:0,54) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (55:0,55) - Tokens:1 diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenDoAndWhileClause.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenDoAndWhileClause.stree.txt index 7c172925ca..3c23c80fad 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenDoAndWhileClause.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenDoAndWhileClause.stree.txt @@ -21,7 +21,7 @@ Statement block - Gen - 54 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (23:0,23) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Foo ] - SpanEditHandler;Accepts:Any - (24:0,24) - Tokens:1 - SyntaxKind.RazorComment;[ Foo ]; + SyntaxKind.RazorCommentLiteral;[ Foo ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (29:0,29) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (30:0,30) - Tokens:1 @@ -34,7 +34,7 @@ Statement block - Gen - 54 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (33:0,33) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Bar ] - SpanEditHandler;Accepts:Any - (34:0,34) - Tokens:1 - SyntaxKind.RazorComment;[ Bar ]; + SyntaxKind.RazorCommentLiteral;[ Bar ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (39:0,39) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (40:0,40) - Tokens:1 diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenElseIfAndElseClause.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenElseIfAndElseClause.stree.txt index ad49650008..b6367f8a36 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenElseIfAndElseClause.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenElseIfAndElseClause.stree.txt @@ -36,7 +36,7 @@ Statement block - Gen - 78 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (44:0,44) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Foo ] - SpanEditHandler;Accepts:Any - (45:0,45) - Tokens:1 - SyntaxKind.RazorComment;[ Foo ]; + SyntaxKind.RazorCommentLiteral;[ Foo ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (50:0,50) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (51:0,51) - Tokens:1 @@ -49,7 +49,7 @@ Statement block - Gen - 78 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (54:0,54) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Bar ] - SpanEditHandler;Accepts:Any - (55:0,55) - Tokens:1 - SyntaxKind.RazorComment;[ Bar ]; + SyntaxKind.RazorCommentLiteral;[ Bar ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (60:0,60) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (61:0,61) - Tokens:1 diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenIfAndElseClause.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenIfAndElseClause.stree.txt index 713331f34e..24f5021c5f 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenIfAndElseClause.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenIfAndElseClause.stree.txt @@ -20,7 +20,7 @@ Statement block - Gen - 54 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (20:0,20) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Foo ] - SpanEditHandler;Accepts:Any - (21:0,21) - Tokens:1 - SyntaxKind.RazorComment;[ Foo ]; + SyntaxKind.RazorCommentLiteral;[ Foo ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (26:0,26) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (27:0,27) - Tokens:1 @@ -33,7 +33,7 @@ Statement block - Gen - 54 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (30:0,30) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Bar ] - SpanEditHandler;Accepts:Any - (31:0,31) - Tokens:1 - SyntaxKind.RazorComment;[ Bar ]; + SyntaxKind.RazorCommentLiteral;[ Bar ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (36:0,36) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (37:0,37) - Tokens:1 diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenIfAndElseIfClause.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenIfAndElseIfClause.stree.txt index ec29570e46..868fb9cd86 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenIfAndElseIfClause.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenIfAndElseIfClause.stree.txt @@ -20,7 +20,7 @@ Statement block - Gen - 62 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (20:0,20) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Foo ] - SpanEditHandler;Accepts:Any - (21:0,21) - Tokens:1 - SyntaxKind.RazorComment;[ Foo ]; + SyntaxKind.RazorCommentLiteral;[ Foo ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (26:0,26) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (27:0,27) - Tokens:1 @@ -33,7 +33,7 @@ Statement block - Gen - 62 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (30:0,30) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Bar ] - SpanEditHandler;Accepts:Any - (31:0,31) - Tokens:1 - SyntaxKind.RazorComment;[ Bar ]; + SyntaxKind.RazorCommentLiteral;[ Bar ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (36:0,36) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (37:0,37) - Tokens:1 diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenTryAndCatchClause.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenTryAndCatchClause.stree.txt index 2fb8732823..465652cc21 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenTryAndCatchClause.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenTryAndCatchClause.stree.txt @@ -16,7 +16,7 @@ Statement block - Gen - 55 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (15:0,15) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Foo ] - SpanEditHandler;Accepts:Any - (16:0,16) - Tokens:1 - SyntaxKind.RazorComment;[ Foo ]; + SyntaxKind.RazorCommentLiteral;[ Foo ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (21:0,21) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (22:0,22) - Tokens:1 @@ -29,7 +29,7 @@ Statement block - Gen - 55 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (25:0,25) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Bar ] - SpanEditHandler;Accepts:Any - (26:0,26) - Tokens:1 - SyntaxKind.RazorComment;[ Bar ]; + SyntaxKind.RazorCommentLiteral;[ Bar ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (31:0,31) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (32:0,32) - Tokens:1 diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenTryAndFinallyClause.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenTryAndFinallyClause.stree.txt index 73825a078d..82faa128c9 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenTryAndFinallyClause.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpBlockTest/SupportsRazorCommentBetweenTryAndFinallyClause.stree.txt @@ -17,7 +17,7 @@ Statement block - Gen - 53 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (16:0,16) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Foo ] - SpanEditHandler;Accepts:Any - (17:0,17) - Tokens:1 - SyntaxKind.RazorComment;[ Foo ]; + SyntaxKind.RazorCommentLiteral;[ Foo ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (22:0,22) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (23:0,23) - Tokens:1 @@ -30,7 +30,7 @@ Statement block - Gen - 53 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (26:0,26) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ Bar ] - SpanEditHandler;Accepts:Any - (27:0,27) - Tokens:1 - SyntaxKind.RazorComment;[ Bar ]; + SyntaxKind.RazorCommentLiteral;[ Bar ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (32:0,32) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (33:0,33) - Tokens:1 diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpDirectivesTest/DirectiveDescriptor_FileScoped_CanBeBeneathOtherWhiteSpaceCommentsAndDirectives.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpDirectivesTest/DirectiveDescriptor_FileScoped_CanBeBeneathOtherWhiteSpaceCommentsAndDirectives.stree.txt index bf5881b70d..720c6442d6 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpDirectivesTest/DirectiveDescriptor_FileScoped_CanBeBeneathOtherWhiteSpaceCommentsAndDirectives.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpDirectivesTest/DirectiveDescriptor_FileScoped_CanBeBeneathOtherWhiteSpaceCommentsAndDirectives.stree.txt @@ -7,7 +7,7 @@ Markup block - Gen - 130 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (1:0,1) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ There are two directives beneath this ] - SpanEditHandler;Accepts:Any - (2:0,2) - Tokens:1 - SyntaxKind.RazorComment;[ There are two directives beneath this ]; + SyntaxKind.RazorCommentLiteral;[ There are two directives beneath this ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (41:0,41) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (42:0,42) - Tokens:1 diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentInClosingTagBlock.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentInClosingTagBlock.stree.txt index 313e55405c..e466692d7f 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentInClosingTagBlock.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentInClosingTagBlock.stree.txt @@ -16,7 +16,7 @@ Markup block - Gen - 33 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (14:0,14) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ razor comment ] - SpanEditHandler;Accepts:Any - (15:0,15) - Tokens:1 - SyntaxKind.RazorComment;[ razor comment ]; + SyntaxKind.RazorCommentLiteral;[ razor comment ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (30:0,30) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (31:0,31) - Tokens:1 diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentInOpeningTagBlock.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentInOpeningTagBlock.stree.txt index 21593eddb8..3411e37c9f 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentInOpeningTagBlock.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentInOpeningTagBlock.stree.txt @@ -10,7 +10,7 @@ Markup block - Gen - 33 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (7:0,7) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ razor comment ] - SpanEditHandler;Accepts:Any - (8:0,8) - Tokens:1 - SyntaxKind.RazorComment;[ razor comment ]; + SyntaxKind.RazorCommentLiteral;[ razor comment ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (23:0,23) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (24:0,24) - Tokens:1 diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentWithExtraNewLineInMarkup.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentWithExtraNewLineInMarkup.stree.txt index ec7b5e245e..8a2cae5609 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentWithExtraNewLineInMarkup.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentWithExtraNewLineInMarkup.stree.txt @@ -13,7 +13,7 @@ Markup block - Gen - 45 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (8:2,1) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ content ] - SpanEditHandler;Accepts:Any - (9:2,2) - Tokens:1 - SyntaxKind.RazorComment;[ content ]; + SyntaxKind.RazorCommentLiteral;[ content ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (18:2,11) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (19:2,12) - Tokens:1 @@ -26,7 +26,7 @@ Markup block - Gen - 45 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (23:3,1) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [LFcontentLF] - SpanEditHandler;Accepts:Any - (24:3,2) - Tokens:1 - SyntaxKind.RazorComment;[LFcontentLF]; + SyntaxKind.RazorCommentLiteral;[LFcontentLF]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (35:5,0) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (36:5,1) - Tokens:1 diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentsSurroundingMarkup.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentsSurroundingMarkup.stree.txt index ac2c6e2c12..59ce056162 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentsSurroundingMarkup.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/CSharpRazorCommentsTest/RazorCommentsSurroundingMarkup.stree.txt @@ -12,7 +12,7 @@ Markup block - Gen - 42 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (6:1,1) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ hello ] - SpanEditHandler;Accepts:Any - (7:1,2) - Tokens:1 - SyntaxKind.RazorComment;[ hello ]; + SyntaxKind.RazorCommentLiteral;[ hello ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (14:1,9) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (15:1,10) - Tokens:1 @@ -27,7 +27,7 @@ Markup block - Gen - 42 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (26:1,21) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [ world ] - SpanEditHandler;Accepts:Any - (27:1,22) - Tokens:1 - SyntaxKind.RazorComment;[ world ]; + SyntaxKind.RazorCommentLiteral;[ world ]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (34:1,29) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (35:1,30) - Tokens:1 diff --git a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/TagHelperParseTreeRewriterTest/AllowsRazorCommentsAsChildren.stree.txt b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/TagHelperParseTreeRewriterTest/AllowsRazorCommentsAsChildren.stree.txt index dffe889eda..e387f439a0 100644 --- a/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/TagHelperParseTreeRewriterTest/AllowsRazorCommentsAsChildren.stree.txt +++ b/test/Microsoft.AspNetCore.Razor.Language.Test/TestFiles/ParserTests/TagHelperParseTreeRewriterTest/AllowsRazorCommentsAsChildren.stree.txt @@ -20,7 +20,7 @@ Markup block - Gen - 26 - (0:0,0) MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (15:0,15) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Comment span - Gen - [asdf] - SpanEditHandler;Accepts:Any - (16:0,16) - Tokens:1 - SyntaxKind.RazorComment;[asdf]; + SyntaxKind.RazorCommentLiteral;[asdf]; MetaCode span - Gen - [*] - SpanEditHandler;Accepts:None - (20:0,20) - Tokens:1 SyntaxKind.RazorCommentStar;[*]; Transition span - Gen - [@] - SpanEditHandler;Accepts:None - (21:0,21) - Tokens:1