Offer enums as completion items in expressions

Author: desplesda

YarnSpinner.LanguageServer.Tests/CompletionTests.cs

@@ -20,6 +20,13 @@ public CompletionTests(ITestOutputHelper outputHelper) : base(outputHelper)
         {
         }
 
+        private static int GetNodeBodyLineNumber(Workspace workspace, string nodeName)
+        {
+            var projectContainingNode = workspace.Projects.Single(p => p.Nodes.Any(n => n.SourceTitle == nodeName));
+            var node = projectContainingNode.Nodes.Single(n => n.SourceTitle == nodeName);
+            return node.BodyStartLine;
+        }
+
         [Fact]
         public async Task Server_OnCompletingStartOfCommand_ReturnsValidCompletions()
         {
@@ -163,33 +170,104 @@ public async Task Server_OnCompletingPartialJumpCommand_ReturnsNodeNames()
         }
 
         [Fact]
-        public async Task Server_OnCompletionRequestedInSetStatement_OffersVariableNames()
+        public async Task Server_OnCompletionRequestedInSetStatement_OffersVariableNamesForAssignment()
         {
             // Given
             // Given
             var (client, server) = await Initialize(ConfigureClient, ConfigureServer);
             var filePath = Path.Combine(TestUtility.PathToTestWorkspace, "Project1", "Test.yarn");
             var workspace = server.Workspace.GetService<Workspace>()!;
             var project = workspace.Projects.Single(p => p.Uri!.Path.Contains("Project1"));
+            var insertionLineNumber = GetNodeBodyLineNumber(workspace, "CodeCompletionTests");
 
-            ChangeTextInDocument(client, filePath, new Position(48, 0), "<<set ");
+            ChangeTextInDocument(client, filePath, new Position(insertionLineNumber, 0), "<<set ");
 
             // When
             var completionResults = await client.RequestCompletion(new CompletionParams
             {
                 TextDocument = new TextDocumentIdentifier { Uri = filePath },
-                Position = new Position(48, "<<set ".Length)
+                Position = new Position(insertionLineNumber, "<<set ".Length)
             });
 
+            var storedVariables = project.Variables.Where(v => v.IsInlineExpansion == false);
+            var smartVariables = project.Variables.Where(v => v.IsInlineExpansion == true);
+
+
             // Then
-            completionResults.Should().NotBeEmpty();
-            completionResults.Should().AllSatisfy(item =>
+            storedVariables.Should().AllSatisfy(v => completionResults.Should().Contain(res => res.Label == v.Name));
+            smartVariables.Should().AllSatisfy(v => completionResults.Should().NotContain(res => res.Label == v.Name));
+        }
+
+
+        [Fact]
+        public async Task Server_OnCompletionRequestedInSetStatement_OffersIdentifiersForValues()
+        {
+            // Given
+            var (client, server) = await Initialize(ConfigureClient, ConfigureServer);
+            var filePath = Path.Combine(TestUtility.PathToTestWorkspace, "Project1", "Test.yarn");
+            var workspace = server.Workspace.GetService<Workspace>()!;
+            var project = workspace.Projects.Single(p => p.Uri!.Path.Contains("Project1"));
+            var insertionLineNumber = GetNodeBodyLineNumber(workspace, "CodeCompletionTests");
+
+            ChangeTextInDocument(client, filePath, new Position(insertionLineNumber, 0), "<<set $x = ");
+
+            // When
+            var completionResults = await client.RequestCompletion(new CompletionParams
+            {
+                TextDocument = new TextDocumentIdentifier { Uri = filePath },
+                Position = new Position(insertionLineNumber, "<<set $x = ".Length)
+            });
+
+            var allFunctionsAndVariables = Enumerable.Concat(project.Variables, project.Functions.Select(a => a.Declaration));
+            var allEnumCaseNames = project.Enums.SelectMany(e => e.EnumCases.Select(c => $"{e.Name}.{c.Key}"));
+
+            allFunctionsAndVariables.Should().NotBeEmpty();
+            allFunctionsAndVariables.Should().AllSatisfy(decl => decl.Should().NotBeNull());
+            allEnumCaseNames.Should().NotBeEmpty();
+
+            // Then
+            // All functions and variables should be in the list of completions
+            allFunctionsAndVariables.Should().AllSatisfy(decl => completionResults.Should().Contain(res => res.Label == decl!.Name));
+            // All enum cases should be in the list of completions
+            allEnumCaseNames.Should().AllSatisfy(caseName => completionResults.Should().Contain(res => res.Label == caseName));
+        }
+
+        [InlineData(["<<if "])]
+        [InlineData(["<<elseif "])]
+        [InlineData(["<<myCoolCommand {"])]
+        [Theory]
+        public async Task Server_OnCompletionRequestedInStatement_OffersIdentifiers(string expression)
+        {
+            // Given
+            var (client, server) = await Initialize(ConfigureClient, ConfigureServer);
+            var filePath = Path.Combine(TestUtility.PathToTestWorkspace, "Project1", "Test.yarn");
+            var workspace = server.Workspace.GetService<Workspace>()!;
+            var project = workspace.Projects.Single(p => p.Uri!.Path.Contains("Project1"));
+            var insertionLineNumber = GetNodeBodyLineNumber(workspace, "CodeCompletionTests");
+
+            ChangeTextInDocument(client, filePath, new Position(insertionLineNumber, 0), expression);
+
+            // When
+            var completionResults = await client.RequestCompletion(new CompletionParams
             {
-                var decl = project.Variables.Should().Contain(v => v.Name == item.Label, "the completion should be a variable name").Subject;
-                decl.IsVariable.Should().BeTrue("the declaration should be a variable");
-                decl.IsInlineExpansion.Should().BeFalse("the variable should be a stored variable");
-            }, "all completion results should be stored variables");
+                TextDocument = new TextDocumentIdentifier { Uri = filePath },
+                Position = new Position(insertionLineNumber, expression.Length)
+            });
+
+            // Then
+            completionResults.Should().NotBeEmpty();
+
+            var allFunctionsAndVariables = Enumerable.Concat(project.Variables, project.Functions.Select(a => a.Declaration));
+            var allEnumCaseNames = project.Enums.SelectMany(e => e.EnumCases.Select(c => $"{e.Name}.{c.Key}"));
+
+            allFunctionsAndVariables.Should().NotBeEmpty();
+            allFunctionsAndVariables.Should().AllSatisfy(decl => decl.Should().NotBeNull());
+            allEnumCaseNames.Should().NotBeEmpty();
+
+            // All functions and variables should be in the list of completions
+            allFunctionsAndVariables.Should().AllSatisfy(decl => completionResults.Should().Contain(res => res.Label == decl!.Name));
 
+            allEnumCaseNames.Should().AllSatisfy(caseName => completionResults.Should().Contain(res => res.Label == caseName));
         }
 
     }

YarnSpinner.LanguageServer.Tests/TestData/TestWorkspace/Project1/Test.yarn

@@ -10,6 +10,12 @@ This is a line.
 
 <<jump Node2>>
 
+<<enum TestEnum>>
+<<case Item1>>
+<<case Item2>>
+<<case Item3>>
+<<endenum>>
+
 ===
 title: Node2
 tags: wow incredible

YarnSpinner.LanguageServer/src/Server/Handlers/CompletionHandler.cs

@@ -209,6 +209,27 @@ public CompletionHandler(Workspace workspace)
                     Documentation = "Set assigns the value of the expression to a variable",
                     InsertTextFormat = InsertTextFormat.PlainText,
                 },
+                new CompletionItem{
+                    Label = "enum",
+                    Kind = CompletionItemKind.Keyword,
+                    InsertText = "enum",
+                    Documentation = "Enums are collections of predefined values.",
+                    InsertTextFormat = InsertTextFormat.PlainText,
+                },
+                new CompletionItem{
+                    Label = "case",
+                    Kind = CompletionItemKind.Keyword,
+                    InsertText = "case",
+                    Documentation = new MarkupContent{ Kind=MarkupKind.Markdown, Value= "`case` creates a new member in an enum." },
+                    InsertTextFormat = InsertTextFormat.PlainText,
+                },
+                new CompletionItem{
+                    Label = "endenum",
+                    Kind = CompletionItemKind.Keyword,
+                    InsertText = "endenum",
+                    Documentation = new MarkupContent{ Kind=MarkupKind.Markdown, Value= "`endenum` ends an enum declaration." },
+                    InsertTextFormat = InsertTextFormat.PlainText,
+                }
             };
         }
 
@@ -520,6 +541,7 @@ enum IdentifierTypes
             Function = 1,
             StoredVariable = 2,
             SmartVariable = 4,
+            EnumCases = 8,
             All = ~0,
         }
 
@@ -529,8 +551,6 @@ private static void GetIdentifierCompletions(Project project, Range indexTokenRa
 
             if (identifierTypes.HasFlag(IdentifierTypes.Function))
             {
-
-
                 foreach (var function in project.Functions.DistinctBy(f => f.YarnName))
                 {
                     builder.Append(function.YarnName);
@@ -594,6 +614,29 @@ private static void GetIdentifierCompletions(Project project, Range indexTokenRa
                     });
                 }
             }
+
+            if (identifierTypes.HasFlag(IdentifierTypes.EnumCases))
+            {
+                foreach (var userEnum in project.Enums)
+                {
+                    foreach (var enumCase in userEnum.EnumCases)
+                    {
+                        var fullName = userEnum.Name + "." + enumCase.Key;
+                        results.Add(new CompletionItem
+                        {
+                            Label = fullName,
+                            Kind = CompletionItemKind.EnumMember,
+                            Documentation = enumCase.Value.Description,
+                            TextEdit = new TextEditOrInsertReplaceEdit(new TextEdit
+                            {
+                                NewText = fullName,
+                                Range = indexTokenRange.CollapseToEnd()
+                            }),
+                            InsertTextFormat = InsertTextFormat.PlainText,
+                        });
+                    }
+                }
+            }
         }
 
         private void GetCommandCompletions(CompletionParams request, Range indexTokenRange, List<CompletionItem> results)

YarnSpinner.LanguageServer/src/Server/Workspace/Project.cs

@@ -33,6 +33,20 @@ internal IEnumerable<Yarn.Compiler.Declaration> Variables
             }
         }
 
+        internal IEnumerable<Yarn.EnumType> Enums
+        {
+            get
+            {
+                if (LastCompilationResult == null)
+                {
+                    return Enumerable.Empty<Yarn.EnumType>();
+                }
+
+                var enums = LastCompilationResult.UserDefinedTypes.OfType<Yarn.EnumType>();
+                return enums;
+            }
+        }
+
         internal IEnumerable<Yarn.Compiler.Diagnostic> Diagnostics
         {
             get