Merge pull request #164 from Fiusen/fix/luau-type-cast-parsing

Fix luau type cast parsing and improve goto tests

Author: GGG-KILLER

CHANGES.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Diagnostic LUA1019: "Goto statements and labels are not supported in this lua version".
 - Support for floor division assignments (`//=`) by @toxamin in https://github.com/LorettaDevs/Loretta/pull/157.
 - Support for underlines before the number base prefix by @toxamin in https://github.com/LorettaDevs/Loretta/pull/156.
 
@@ -21,6 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Fixed parsing of Luau type casts (`::`) when `AcceptGoto` is false by @Fiusen in https://github.com/LorettaDevs/Loretta/pull/164.
 - Parsing of empty return statements at the end of the file by @toxamin in https://github.com/LorettaDevs/Loretta/pull/148.
 
 <!-- ### Security -->

src/Compilers/Lua/Portable/Errors/ErrorCode.cs

@@ -66,6 +66,7 @@ internal enum ErrorCode
         ERR_TypedLuaNotSupportedInLuaVersion           = 1016,
         ERR_OnlyOneTableTypeIndexerIsAllowed           = 1017,
         ERR_NormalTypeParametersComeBeforePacks        = 1018,
+        ERR_GotoNotSupportedInLuaVersion               = 1019,
 
         // MessageProvider stuff
         ERR_BadDocumentationMode = 2000,

src/Compilers/Lua/Portable/Generated/Loretta.Generators.SyntaxFactsGenerator/Loretta.Generators.SyntaxFactsGenerator.SyntaxFactsGenerator/SyntaxFacts.g.cs

@@ -319,4 +319,7 @@
     <data name="ERR_InterpolatedStringsNotSupportedInVersion" xml:space="preserve">
       <value>Interpolated strings are not supported in this lua version</value>
   </data>
+  <data name="ERR_GotoNotSupportedInLuaVersion" xml:space="preserve">
+    <value>Goto statements and labels are not supported in this lua version</value>
+  </data>
 </root>

src/Compilers/Lua/Portable/LuaResources.Designer.cs

@@ -599,10 +599,16 @@ private GotoStatementSyntax ParseGotoStatement()
             var gotoKeyword = EatToken(SyntaxKind.GotoKeyword);
             var labelName = EatToken(SyntaxKind.IdentifierToken);
             var semicolonToken = TryMatchSemicolon();
-            return SyntaxFactory.GotoStatement(
+            
+            var node = SyntaxFactory.GotoStatement(
                 gotoKeyword,
                 labelName,
                 semicolonToken);
+
+            if (!Options.SyntaxOptions.AcceptGoto)
+                node = AddError(node, ErrorCode.ERR_GotoNotSupportedInLuaVersion);
+
+            return node;
         }
 
         private BreakStatementSyntax ParseBreakStatement()
@@ -628,11 +634,17 @@ private GotoLabelStatementSyntax ParseGotoLabelStatement()
             var identifier = EatToken(SyntaxKind.IdentifierToken);
             var rightDelimiterToken = EatToken(SyntaxKind.ColonColonToken);
             var semicolonToken = TryMatchSemicolon();
-            return SyntaxFactory.GotoLabelStatement(
+
+            var node = SyntaxFactory.GotoLabelStatement(
                 leftDelimiterToken,
                 identifier,
                 rightDelimiterToken,
                 semicolonToken);
+
+            if (!Options.SyntaxOptions.AcceptGoto)
+                node = AddError(node, ErrorCode.ERR_GotoNotSupportedInLuaVersion);
+
+            return node;
         }
 
         private FunctionDeclarationStatementSyntax ParseFunctionDeclarationStatement()

src/Compilers/Lua/Portable/LuaResources.resx

@@ -271,7 +271,7 @@ private void LexSyntaxToken(ref TokenInfo info)
 
                 case ':':
                     TextWindow.AdvanceChar();
-                    if (_options.SyntaxOptions.AcceptGoto && TextWindow.PeekChar() == ':')
+                    if ((_options.SyntaxOptions.AcceptGoto || _options.SyntaxOptions.AcceptTypedLua) && TextWindow.PeekChar() == ':')
                     {
                         TextWindow.AdvanceChar();
                         info.Kind = SyntaxKind.ColonColonToken;

src/Compilers/Lua/Portable/Parser/LanguageParser.cs

@@ -91,7 +91,7 @@ internal static bool IsTokenOrTriviaKindEnabled(SyntaxKind kind, LuaSyntaxOption
         {
             switch (kind)
             {
-                case SyntaxKind.ColonColonToken when !options.AcceptGoto:
+                case SyntaxKind.ColonColonToken when !options.AcceptGoto && !options.AcceptTypedLua:
                 case SyntaxKind.SlashSlashToken or SyntaxKind.SlashSlashEqualsToken 
                     when !options.AcceptFloorDivision:
                 case SyntaxKind.AmpersandAmpersandToken or SyntaxKind.PipePipeToken or SyntaxKind.BangToken

src/Compilers/Lua/Portable/Parser/Lexer.cs

@@ -289,4 +289,67 @@ public async Task LanguageParser_ConcatIsRightAssociative()
         }
         EOF();
     }
+
+    [Test]
+    public async Task LanguageParser_LuauTypeCast_ParsesCorrectly()
+    {
+        // ensure that "::" is correctly recognized as a TypeCastExpression in Luau
+        await UsingTreeAsync("local a = {} :: table", new LuaParseOptions(LuaSyntaxOptions.Luau));
+        await N(SyntaxKind.CompilationUnit);
+        {
+            await N(SyntaxKind.StatementList);
+            {
+                await N(SyntaxKind.LocalVariableDeclarationStatement);
+                {
+                    await N(SyntaxKind.LocalKeyword);
+                    await N(SyntaxKind.LocalDeclarationName);
+                    {
+                        await N(SyntaxKind.IdentifierName);
+                        {
+                            await N(SyntaxKind.IdentifierToken, "a");
+                        }
+                    }
+                    await N(SyntaxKind.EqualsValuesClause);
+                    {
+                        await N(SyntaxKind.EqualsToken);
+                        await N(SyntaxKind.TypeCastExpression);
+                        {
+                            await N(SyntaxKind.TableConstructorExpression);
+                            {
+                                await N(SyntaxKind.OpenBraceToken);
+                                await N(SyntaxKind.CloseBraceToken);
+                            }
+                            await N(SyntaxKind.ColonColonToken, "::");
+                            await N(SyntaxKind.SimpleTypeName);
+                            {
+                                await N(SyntaxKind.IdentifierToken, "table");
+                            }
+                        }
+                    }
+                }
+            }
+            await N(SyntaxKind.EndOfFileToken);
+        }
+        EOF();
+    }
+    [Test]
+    public async Task LanguageParser_LuauGoto_GeneratesCorrectError()
+    {
+        // ensure that while "::" is enabled for type casts, using it for labels still generates the goto error in Luau
+        await ParseAndValidateAsync(
+               "::label::",
+               LuaSyntaxOptions.Luau,
+               // (1,1): error LUA1019: Goto statements and labels are not supported in this lua version
+               Diagnostic(ErrorCode.ERR_GotoNotSupportedInLuaVersion, "::label::").WithLocation(1, 1));
+    }
+    [Test]
+    public async Task LanguageParser_Lua52_TypeCast_GeneratesError()
+    {
+        // ensure that in Lua 5.2 (which supports goto but not types), using :: for a cast triggers the "Typed lua is not supported" error.
+        await ParseAndValidateAsync(
+            "local a = x :: table",
+            LuaSyntaxOptions.Lua52,
+            // (1,11): error LUA1016: Typed lua is not supported in this lua version
+            Diagnostic(ErrorCode.ERR_TypedLuaNotSupportedInLuaVersion, "x :: table").WithLocation(1, 11));
+    }
 }