VB support for back-end and add IOperation as part of node properties (#14)

* Initial re-organization

* One more step

* Add IOperation to properties

* Add back-end support for VB

Author: Youssef1313

DotNetSyntaxTreeVisualizer/ClientApp/src/components/Home.js

@@ -37,7 +37,7 @@ export class Home extends Component {
             headers: { 'Content-Type': 'text/plain;charset=UTF-8' },
             body: event.target.value
         };
-        fetch('SyntaxTree', requestOptions)
+        fetch('SyntaxTree/CSharp', requestOptions)
             .then(response => response.json())
             .then(data => this.setState({ treeJson: data }));
     }

DotNetSyntaxTreeVisualizer/Controllers/SyntaxTreeController.cs

@@ -8,6 +8,7 @@
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.VisualBasic;
 using Microsoft.Extensions.Logging;
 
 namespace DotNetSyntaxTreeVisualizer.Controllers
@@ -23,65 +24,30 @@ public SyntaxTreeController(ILogger<SyntaxTreeController> logger)
             _logger = logger;
         }
 
-        [HttpPost]
+        [HttpPost("CSharp")] // POST: /SyntaxTree/CSharp
         public async Task<SyntaxTreeNode> CSharpPost(CancellationToken cancellationToken)
         {
             using var reader = new StreamReader(Request.Body, Encoding.UTF8);
             string body = await reader.ReadToEndAsync().ConfigureAwait(false);
-            SyntaxNode root = await CSharpSyntaxTree.ParseText(body).GetRootAsync(cancellationToken).ConfigureAwait(false);
-            SyntaxTreeNode myRoot = CreateMyOwnTree(root);
+            SyntaxTree tree = CSharpSyntaxTree.ParseText(body);
+            SyntaxNode root = await tree.GetRootAsync(cancellationToken).ConfigureAwait(false);
+            Compilation compilation = CSharpCompilation.Create("HelloWorld", new[] { tree });
+            SemanticModel model = compilation.GetSemanticModel(tree);
+            SyntaxTreeNode myRoot = SyntaxTreeNode.CreateMyOwnTree(root, model);
             return myRoot;
         }
 
-        private SyntaxTreeNode CreateMyOwnTree(SyntaxNodeOrToken nodeOrToken)
+        [HttpPost("VisualBasic")] // POST: /SyntaxTree/VisualBasic
+        public async Task<SyntaxTreeNode> VisualBasicPost(CancellationToken cancellationToken)
         {
-            var root = new SyntaxTreeNode(GetSyntaxNodeOrTokenInformation(nodeOrToken));
-            foreach (SyntaxNodeOrToken child in nodeOrToken.ChildNodesAndTokens())
-            {
-                root.AddChild(CreateMyOwnTree(child));
-            }
-            return root;
-        }
-
-        private IDictionary<string, string> GetSyntaxNodeOrTokenInformation(SyntaxNodeOrToken nodeOrToken)
-        {
-            return nodeOrToken.IsNode
-                ? GetSyntaxInformation(nodeOrToken.AsNode())
-                : GetSyntaxInformation(nodeOrToken.AsToken());
-        }
-
-        private IDictionary<string, string> GetSyntaxInformation<T>(T syntax)
-        {
-            var result = new Dictionary<string, string>();
-            if (syntax is SyntaxNode node)
-            {
-                result.Add("NodeKind", node.Kind().ToString()); // TODO: Kind() here is for C#. Considering fixing that.
-            }
-            else if (syntax is SyntaxToken token)
-            {
-                result.Add("TokenKind", token.Kind().ToString());
-            }
-            else
-            {
-                throw new ArgumentException($"The specified {nameof(syntax)} is not a SyntaxNode nor a SyntaxToken.");
-            }
-            PropertyInfo[] properties = syntax.GetType().GetProperties();
-            foreach (PropertyInfo info in properties)
-            {
-                // Language isn't important to include in each node.
-                // Parent is redundant. I can already see the parent.
-                // ValueText and Value are the same as Text.
-                // SyntaxTree shows the complete source in each node. That's redundant.
-                // RawKind is just the underlying numeric value of SyntaxKind enum. It's meaningless.
-                if (info.Name == "Language" || info.Name == "Parent" ||
-                    info.Name == "ValueText" || info.Name == "Value" ||
-                    info.Name == "SyntaxTree" || info.Name == "RawKind")
-                {
-                    continue;
-                }
-                result.Add(info.Name, info.GetValue(syntax)?.ToString());
-            }
-            return result;
+            using var reader = new StreamReader(Request.Body, Encoding.UTF8);
+            string body = await reader.ReadToEndAsync().ConfigureAwait(false);
+            SyntaxTree tree = VisualBasicSyntaxTree.ParseText(body);
+            SyntaxNode root = await tree.GetRootAsync(cancellationToken).ConfigureAwait(false);
+            Compilation compilation = VisualBasicCompilation.Create("HelloWorld", new[] { tree });
+            SemanticModel model = compilation.GetSemanticModel(tree);
+            SyntaxTreeNode myRoot = SyntaxTreeNode.CreateMyOwnTree(root, model);
+            return myRoot;
         }
     }
 }

DotNetSyntaxTreeVisualizer/DotNetSyntaxTreeVisualizer.csproj

@@ -11,7 +11,8 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.SpaServices.Extensions" Version="3.1.4" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.6.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.7.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic" Version="3.7.0" />
   </ItemGroup>
 
   <ItemGroup>

DotNetSyntaxTreeVisualizer/SyntaxTreeNode.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
+using Microsoft.CodeAnalysis;
 
 namespace DotNetSyntaxTreeVisualizer
 {
@@ -20,6 +22,55 @@ public void AddChild(SyntaxTreeNode child)
             Children.Add(child);
         }
 
+        public static SyntaxTreeNode CreateMyOwnTree(SyntaxNodeOrToken nodeOrToken, SemanticModel model)
+        {
+            var root = new SyntaxTreeNode(GetSyntaxInformation(nodeOrToken, model));
+            foreach (SyntaxNodeOrToken child in nodeOrToken.ChildNodesAndTokens())
+            {
+                root.AddChild(CreateMyOwnTree(child, model));
+            }
+            return root;
+        }
+
+        private static IDictionary<string, string> GetSyntaxInformation(SyntaxNodeOrToken syntax, SemanticModel model)
+        {
+            Func<SyntaxNodeOrToken, Microsoft.CodeAnalysis.CSharp.SyntaxKind> csharpKind = Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind;
+            Func<SyntaxNodeOrToken, Microsoft.CodeAnalysis.VisualBasic.SyntaxKind> vbKind = Microsoft.CodeAnalysis.VisualBasic.VisualBasicExtensions.Kind;
+            string kind =
+                syntax.Language == LanguageNames.CSharp
+                ? csharpKind(syntax).ToString()
+                : vbKind(syntax).ToString();
+
+            var result = new Dictionary<string, string>
+            {
+                { "Kind", kind },
+            };
+
+            IOperation operation = model.GetOperation(syntax.AsNode());
+            if (operation is object)
+            {
+                result.Add(nameof(IOperation), operation.Kind.ToString());
+            }
+
+            PropertyInfo[] properties = syntax.GetType().GetProperties();
+            foreach (PropertyInfo info in properties)
+            {
+                // Language isn't important to include in each node.
+                // Parent is redundant. I can already see the parent.
+                // ValueText and Value are the same as Text.
+                // SyntaxTree shows the complete source in each node. That's redundant.
+                // RawKind is just the underlying numeric value of SyntaxKind enum. It's meaningless.
+                if (info.Name == "Language" || info.Name == "Parent" ||
+                    info.Name == "ValueText" || info.Name == "Value" ||
+                    info.Name == "SyntaxTree" || info.Name == "RawKind")
+                {
+                    continue;
+                }
+                result.Add(info.Name, info.GetValue(syntax)?.ToString());
+            }
+            return result;
+        }
+
         public override string ToString()
         {
             return Properties.Values.First();