Create specific syntax node type for using directives

Author: davidwengier

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Internal.Generated.cs

@@ -2935,7 +2935,20 @@ internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics)
         => new CSharpImplicitExpressionBodySyntax(Kind, _csharpCode, diagnostics);
 }
 
-internal sealed partial class RazorDirectiveSyntax : CSharpRazorBlockSyntax
+internal abstract partial class BaseRazorDirectiveSyntax : CSharpRazorBlockSyntax
+{
+    internal BaseRazorDirectiveSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics)
+        : base(kind, diagnostics)
+    {
+    }
+
+    internal BaseRazorDirectiveSyntax(SyntaxKind kind)
+        : base(kind)
+    {
+    }
+}
+
+internal sealed partial class RazorDirectiveSyntax : BaseRazorDirectiveSyntax
 {
     internal readonly CSharpTransitionSyntax _transition;
     internal readonly CSharpSyntaxNode _body;
@@ -2998,6 +3011,69 @@ internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics)
         => new RazorDirectiveSyntax(Kind, _transition, _body, _directiveDescriptor, diagnostics);
 }
 
+internal sealed partial class RazorUsingDirectiveSyntax : BaseRazorDirectiveSyntax
+{
+    internal readonly CSharpTransitionSyntax _transition;
+    internal readonly CSharpSyntaxNode _body;
+    internal readonly DirectiveDescriptor _directiveDescriptor;
+
+    internal RazorUsingDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor, RazorDiagnostic[] diagnostics)
+        : base(kind, diagnostics)
+    {
+        SlotCount = 2;
+        AdjustFlagsAndWidth(transition);
+        _transition = transition;
+        AdjustFlagsAndWidth(body);
+        _body = body;
+        _directiveDescriptor = directiveDescriptor;
+    }
+
+    internal RazorUsingDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor)
+        : base(kind)
+    {
+        SlotCount = 2;
+        AdjustFlagsAndWidth(transition);
+        _transition = transition;
+        AdjustFlagsAndWidth(body);
+        _body = body;
+        _directiveDescriptor = directiveDescriptor;
+    }
+
+    public override CSharpTransitionSyntax Transition => _transition;
+    public override CSharpSyntaxNode Body => _body;
+    public DirectiveDescriptor DirectiveDescriptor => _directiveDescriptor;
+
+    internal override GreenNode GetSlot(int index)
+        => index switch
+        {
+            0 => _transition,
+            1 => _body,
+            _ => null
+        };
+
+    internal override SyntaxNode CreateRed(SyntaxNode parent, int position) => new Syntax.RazorUsingDirectiveSyntax(this, parent, position);
+
+    public override TResult Accept<TResult>(SyntaxVisitor<TResult> visitor) => visitor.VisitRazorUsingDirective(this);
+    public override void Accept(SyntaxVisitor visitor) => visitor.VisitRazorUsingDirective(this);
+
+    public RazorUsingDirectiveSyntax Update(CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor)
+    {
+        if (transition != Transition || body != Body)
+        {
+            var newNode = SyntaxFactory.RazorUsingDirective(transition, body, directiveDescriptor);
+            var diags = GetDiagnostics();
+            if (diags != null && diags.Length > 0)
+                newNode = newNode.WithDiagnosticsGreen(diags);
+            return newNode;
+        }
+
+        return this;
+    }
+
+    internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics)
+        => new RazorUsingDirectiveSyntax(Kind, _transition, _body, _directiveDescriptor, diagnostics);
+}
+
 internal sealed partial class RazorDirectiveBodySyntax : CSharpSyntaxNode
 {
     internal readonly RazorSyntaxNode _keyword;
@@ -3104,6 +3180,7 @@ internal partial class SyntaxVisitor<TResult>
     public virtual TResult VisitCSharpImplicitExpression(CSharpImplicitExpressionSyntax node) => DefaultVisit(node);
     public virtual TResult VisitCSharpImplicitExpressionBody(CSharpImplicitExpressionBodySyntax node) => DefaultVisit(node);
     public virtual TResult VisitRazorDirective(RazorDirectiveSyntax node) => DefaultVisit(node);
+    public virtual TResult VisitRazorUsingDirective(RazorUsingDirectiveSyntax node) => DefaultVisit(node);
     public virtual TResult VisitRazorDirectiveBody(RazorDirectiveBodySyntax node) => DefaultVisit(node);
 }
 
@@ -3148,6 +3225,7 @@ internal partial class SyntaxVisitor
     public virtual void VisitCSharpImplicitExpression(CSharpImplicitExpressionSyntax node) => DefaultVisit(node);
     public virtual void VisitCSharpImplicitExpressionBody(CSharpImplicitExpressionBodySyntax node) => DefaultVisit(node);
     public virtual void VisitRazorDirective(RazorDirectiveSyntax node) => DefaultVisit(node);
+    public virtual void VisitRazorUsingDirective(RazorUsingDirectiveSyntax node) => DefaultVisit(node);
     public virtual void VisitRazorDirectiveBody(RazorDirectiveBodySyntax node) => DefaultVisit(node);
 }
 
@@ -3270,6 +3348,9 @@ public override GreenNode VisitCSharpImplicitExpressionBody(CSharpImplicitExpres
     public override GreenNode VisitRazorDirective(RazorDirectiveSyntax node)
         => node.Update((CSharpTransitionSyntax)Visit(node.Transition), (CSharpSyntaxNode)Visit(node.Body), node.DirectiveDescriptor);
 
+    public override GreenNode VisitRazorUsingDirective(RazorUsingDirectiveSyntax node)
+        => node.Update((CSharpTransitionSyntax)Visit(node.Transition), (CSharpSyntaxNode)Visit(node.Body), node.DirectiveDescriptor);
+
     public override GreenNode VisitRazorDirectiveBody(RazorDirectiveBodySyntax node)
         => node.Update((RazorSyntaxNode)Visit(node.Keyword), (CSharpCodeBlockSyntax)Visit(node.CSharpCode));
 }
@@ -3663,6 +3744,16 @@ public static RazorDirectiveSyntax RazorDirective(CSharpTransitionSyntax transit
         return result;
     }
 
+    public static RazorUsingDirectiveSyntax RazorUsingDirective(CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor)
+    {
+        ArgHelper.ThrowIfNull(transition);
+        ArgHelper.ThrowIfNull(body);
+
+        var result = new RazorUsingDirectiveSyntax(SyntaxKind.RazorUsingDirective, transition, body, directiveDescriptor);
+
+        return result;
+    }
+
     public static RazorDirectiveBodySyntax RazorDirectiveBody(RazorSyntaxNode keyword, CSharpCodeBlockSyntax csharpCode)
     {
         ArgHelper.ThrowIfNull(keyword);
@@ -3715,6 +3806,7 @@ internal static IEnumerable<Type> GetNodeTypes()
             typeof(CSharpImplicitExpressionSyntax),
             typeof(CSharpImplicitExpressionBodySyntax),
             typeof(RazorDirectiveSyntax),
+            typeof(RazorUsingDirectiveSyntax),
             typeof(RazorDirectiveBodySyntax)
         };
     }

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Main.Generated.cs

@@ -125,6 +125,9 @@ internal partial class SyntaxVisitor<TResult>
     /// <summary>Called when the visitor visits a RazorDirectiveSyntax node.</summary>
     public virtual TResult VisitRazorDirective(RazorDirectiveSyntax node) => DefaultVisit(node);
 
+    /// <summary>Called when the visitor visits a RazorUsingDirectiveSyntax node.</summary>
+    public virtual TResult VisitRazorUsingDirective(RazorUsingDirectiveSyntax node) => DefaultVisit(node);
+
     /// <summary>Called when the visitor visits a RazorDirectiveBodySyntax node.</summary>
     public virtual TResult VisitRazorDirectiveBody(RazorDirectiveBodySyntax node) => DefaultVisit(node);
 }
@@ -248,6 +251,9 @@ internal partial class SyntaxVisitor
     /// <summary>Called when the visitor visits a RazorDirectiveSyntax node.</summary>
     public virtual void VisitRazorDirective(RazorDirectiveSyntax node) => DefaultVisit(node);
 
+    /// <summary>Called when the visitor visits a RazorUsingDirectiveSyntax node.</summary>
+    public virtual void VisitRazorUsingDirective(RazorUsingDirectiveSyntax node) => DefaultVisit(node);
+
     /// <summary>Called when the visitor visits a RazorDirectiveBodySyntax node.</summary>
     public virtual void VisitRazorDirectiveBody(RazorDirectiveBodySyntax node) => DefaultVisit(node);
 }
@@ -371,6 +377,9 @@ public override SyntaxNode VisitCSharpImplicitExpressionBody(CSharpImplicitExpre
     public override SyntaxNode VisitRazorDirective(RazorDirectiveSyntax node)
         => node.Update((CSharpTransitionSyntax)Visit(node.Transition), (CSharpSyntaxNode)Visit(node.Body), node.DirectiveDescriptor);
 
+    public override SyntaxNode VisitRazorUsingDirective(RazorUsingDirectiveSyntax node)
+        => node.Update((CSharpTransitionSyntax)Visit(node.Transition), (CSharpSyntaxNode)Visit(node.Body), node.DirectiveDescriptor);
+
     public override SyntaxNode VisitRazorDirectiveBody(RazorDirectiveBodySyntax node)
         => node.Update((RazorSyntaxNode)Visit(node.Keyword), (CSharpCodeBlockSyntax)Visit(node.CSharpCode));
 }
@@ -807,6 +816,18 @@ public static RazorDirectiveSyntax RazorDirective(CSharpTransitionSyntax transit
     public static RazorDirectiveSyntax RazorDirective(CSharpTransitionSyntax transition, CSharpSyntaxNode body)
         => SyntaxFactory.RazorDirective(transition, body, default(DirectiveDescriptor));
 
+    /// <summary>Creates a new RazorUsingDirectiveSyntax instance.</summary>
+    public static RazorUsingDirectiveSyntax RazorUsingDirective(CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor)
+    {
+        ArgHelper.ThrowIfNull(transition);
+        ArgHelper.ThrowIfNull(body);
+        return (RazorUsingDirectiveSyntax)InternalSyntax.SyntaxFactory.RazorUsingDirective(transition == null ? null : (InternalSyntax.CSharpTransitionSyntax)transition.Green, body == null ? null : (InternalSyntax.CSharpSyntaxNode)body.Green, directiveDescriptor).CreateRed();
+    }
+
+    /// <summary>Creates a new RazorUsingDirectiveSyntax instance.</summary>
+    public static RazorUsingDirectiveSyntax RazorUsingDirective(CSharpTransitionSyntax transition, CSharpSyntaxNode body)
+        => SyntaxFactory.RazorUsingDirective(transition, body, default(DirectiveDescriptor));
+
     /// <summary>Creates a new RazorDirectiveBodySyntax instance.</summary>
     public static RazorDirectiveBodySyntax RazorDirectiveBody(RazorSyntaxNode keyword, CSharpCodeBlockSyntax csharpCode)
     {

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Syntax.Generated.cs

@@ -2128,7 +2128,18 @@ public CSharpImplicitExpressionBodySyntax Update(CSharpCodeBlockSyntax csharpCod
     public CSharpImplicitExpressionBodySyntax AddCSharpCodeChildren(params RazorSyntaxNode[] items) => WithCSharpCode(this.CSharpCode.WithChildren(this.CSharpCode.Children.AddRange(items)));
 }
 
-internal sealed partial class RazorDirectiveSyntax : CSharpRazorBlockSyntax
+internal abstract partial class BaseRazorDirectiveSyntax : CSharpRazorBlockSyntax
+{
+    internal BaseRazorDirectiveSyntax(GreenNode green, SyntaxNode parent, int position)
+        : base(green, parent, position)
+    {
+    }
+
+    public new BaseRazorDirectiveSyntax WithTransition(CSharpTransitionSyntax transition) => (BaseRazorDirectiveSyntax)WithTransitionCore(transition);
+    public new BaseRazorDirectiveSyntax WithBody(CSharpSyntaxNode body) => (BaseRazorDirectiveSyntax)WithBodyCore(body);
+}
+
+internal sealed partial class RazorDirectiveSyntax : BaseRazorDirectiveSyntax
 {
     private CSharpTransitionSyntax _transition;
     private CSharpSyntaxNode _body;
@@ -2182,6 +2193,60 @@ public RazorDirectiveSyntax Update(CSharpTransitionSyntax transition, CSharpSynt
     public RazorDirectiveSyntax WithDirectiveDescriptor(DirectiveDescriptor directiveDescriptor) => Update(Transition, Body, directiveDescriptor);
 }
 
+internal sealed partial class RazorUsingDirectiveSyntax : BaseRazorDirectiveSyntax
+{
+    private CSharpTransitionSyntax _transition;
+    private CSharpSyntaxNode _body;
+
+    internal RazorUsingDirectiveSyntax(GreenNode green, SyntaxNode parent, int position)
+        : base(green, parent, position)
+    {
+    }
+
+    public override CSharpTransitionSyntax Transition  => GetRedAtZero(ref _transition);
+    public override CSharpSyntaxNode Body  => GetRed(ref _body, 1);
+    public DirectiveDescriptor DirectiveDescriptor => ((InternalSyntax.RazorUsingDirectiveSyntax)Green).DirectiveDescriptor;
+
+    internal override SyntaxNode GetNodeSlot(int index)
+        => index switch
+        {
+            0 => GetRedAtZero(ref _transition),
+            1 => GetRed(ref _body, 1),
+            _ => null
+        };
+
+    internal override SyntaxNode GetCachedSlot(int index)
+        => index switch
+        {
+            0 => this._transition,
+            1 => this._body,
+            _ => null
+        };
+
+    public override TResult Accept<TResult>(SyntaxVisitor<TResult> visitor) => visitor.VisitRazorUsingDirective(this);
+    public override void Accept(SyntaxVisitor visitor) => visitor.VisitRazorUsingDirective(this);
+
+    public RazorUsingDirectiveSyntax Update(CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor)
+    {
+        if (transition != Transition || body != Body || directiveDescriptor != DirectiveDescriptor)
+        {
+            var newNode = SyntaxFactory.RazorUsingDirective(transition, body, directiveDescriptor);
+            var diagnostics = GetDiagnostics();
+            if (diagnostics != null && diagnostics.Length > 0)
+                newNode = newNode.WithDiagnostics(diagnostics);
+            return newNode;
+        }
+
+        return this;
+    }
+
+    internal override CSharpRazorBlockSyntax WithTransitionCore(CSharpTransitionSyntax transition) => WithTransition(transition);
+    public new RazorUsingDirectiveSyntax WithTransition(CSharpTransitionSyntax transition) => Update(transition, Body, DirectiveDescriptor);
+    internal override CSharpRazorBlockSyntax WithBodyCore(CSharpSyntaxNode body) => WithBody(body);
+    public new RazorUsingDirectiveSyntax WithBody(CSharpSyntaxNode body) => Update(Transition, body, DirectiveDescriptor);
+    public RazorUsingDirectiveSyntax WithDirectiveDescriptor(DirectiveDescriptor directiveDescriptor) => Update(Transition, Body, directiveDescriptor);
+}
+
 internal sealed partial class RazorDirectiveBodySyntax : CSharpSyntaxNode
 {
     private RazorSyntaxNode _keyword;

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Syntax.xml

@@ -380,7 +380,9 @@
     <Kind Name="CSharpImplicitExpressionBody" />
     <Field Name="CSharpCode" Type="CSharpCodeBlockSyntax" />
   </Node>
-  <Node Name="RazorDirectiveSyntax" Base="CSharpRazorBlockSyntax">
+  <AbstractNode Name="BaseRazorDirectiveSyntax" Base="CSharpRazorBlockSyntax">
+  </AbstractNode>
+  <Node Name="RazorDirectiveSyntax" Base="BaseRazorDirectiveSyntax">
     <Kind Name="RazorDirective" />
     <Field Name="Transition" Type="CSharpTransitionSyntax" Override="true">
       <Kind Name="CSharpTransition" />
@@ -390,6 +392,16 @@
     </Field>
     <Field Name="DirectiveDescriptor" Type="DirectiveDescriptor" Optional="true" />
   </Node>
+  <Node Name="RazorUsingDirectiveSyntax" Base="BaseRazorDirectiveSyntax">
+    <Kind Name="RazorUsingDirective" />
+    <Field Name="Transition" Type="CSharpTransitionSyntax" Override="true">
+      <Kind Name="CSharpTransition" />
+    </Field>
+    <Field Name="Body" Type="CSharpSyntaxNode" Override="true">
+      <Kind Name="RazorDirectiveBody" />
+    </Field>
+    <Field Name="DirectiveDescriptor" Type="DirectiveDescriptor" Optional="true" />
+  </Node>
   <Node Name="RazorDirectiveBodySyntax" Base="CSharpSyntaxNode">
     <Kind Name="RazorDirectiveBody" />
     <Field Name="Keyword" Type="RazorSyntaxNode" />

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxKind.cs

@@ -14,6 +14,7 @@ internal enum SyntaxKind : byte
     RazorComment,
     RazorMetaCode,
     RazorDirective,
+    RazorUsingDirective,
     RazorDirectiveBody,
     UnclassifiedTextLiteral,