C# (CSharp) LanguageModel.Tests.TestGeneration Tester.N 예제들

예제 #1

파일: EmptyProgram_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #2

파일: 27_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.SemiColonStatementNode);
             {
                 t.N(SyntaxKind.Semicolon);
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #3

파일: 13_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.FunctionCallStatementNode);
             {
                 t.N(SyntaxKind.NameVar);
                 {
                     t.N(SyntaxKind.Identifier);
                 }
                 t.N(SyntaxKind.StringArg);
                 {
                     t.N(SyntaxKind.String);
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #4

파일: 5_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.AssignmentStatementNode);
             {
                 t.N(SyntaxKind.VarList);
                 {
                     t.N(SyntaxKind.NameVar);
                     {
                         t.N(SyntaxKind.Identifier);
                     }
                 }
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.ExpList);
                 {
                     t.N(SyntaxKind.TableConstructorExp);
                     {
                         t.N(SyntaxKind.OpenCurlyBrace);
                         t.N(SyntaxKind.FieldList);
                         {
                             t.N(SyntaxKind.AssignmentField);
                             {
                                 t.N(SyntaxKind.Identifier);
                                 t.N(SyntaxKind.AssignmentOperator);
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.Number);
                                 }
                             }
                             t.N(SyntaxKind.Comma);
                             t.N(SyntaxKind.BracketField);
                             {
                                 t.N(SyntaxKind.OpenBracket);
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.String);
                                 }
                                 t.N(SyntaxKind.CloseBracket);
                                 t.N(SyntaxKind.AssignmentOperator);
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.Number);
                                 }
                             }
                             t.N(SyntaxKind.Comma);
                             t.N(SyntaxKind.AssignmentField);
                             {
                                 t.N(SyntaxKind.Identifier);
                                 t.N(SyntaxKind.AssignmentOperator);
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.Number);
                                 }
                             }
                             t.N(SyntaxKind.Semicolon);
                             t.N(SyntaxKind.ExpField);
                             {
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.String);
                                 }
                             }
                             t.N(SyntaxKind.Comma);
                             t.N(SyntaxKind.ExpField);
                             {
                                 t.N(SyntaxKind.FunctionCallExp);
                                 {
                                     t.N(SyntaxKind.NameVar);
                                     {
                                         t.N(SyntaxKind.Identifier);
                                     }
                                     t.N(SyntaxKind.ParenArg);
                                     {
                                         t.N(SyntaxKind.OpenParen);
                                         t.N(SyntaxKind.ExpList);
                                         {
                                             t.N(SyntaxKind.SimpleExpression);
                                             {
                                                 t.N(SyntaxKind.String);
                                             }
                                         }
                                         t.N(SyntaxKind.CloseParen);
                                     }
                                 }
                             }
                             t.N(SyntaxKind.Comma);
                             t.N(SyntaxKind.BracketField);
                             {
                                 t.N(SyntaxKind.OpenBracket);
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.Number);
                                 }
                                 t.N(SyntaxKind.CloseBracket);
                                 t.N(SyntaxKind.AssignmentOperator);
                                 t.N(SyntaxKind.TableConstructorExp);
                                 {
                                     t.N(SyntaxKind.OpenCurlyBrace);
                                     t.N(SyntaxKind.FieldList);
                                     {
                                         t.N(SyntaxKind.AssignmentField);
                                         {
                                             t.N(SyntaxKind.Identifier);
                                             t.N(SyntaxKind.AssignmentOperator);
                                             t.N(SyntaxKind.SimpleExpression);
                                             {
                                                 t.N(SyntaxKind.Number);
                                             }
                                         }
                                     }
                                     t.N(SyntaxKind.CloseCurlyBrace);
                                 }
                             }
                             t.N(SyntaxKind.Comma);
                             t.N(SyntaxKind.ExpField);
                             {
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.String);
                                 }
                             }
                             t.N(SyntaxKind.Comma);
                             t.N(SyntaxKind.ExpField);
                             {
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.String);
                                 }
                             }
                         }
                         t.N(SyntaxKind.CloseCurlyBrace);
                     }
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #5

파일: 3_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.IfStatementNode);
             {
                 t.N(SyntaxKind.IfKeyword);
                 t.N(SyntaxKind.BinaryOperatorExpression);
                 {
                     t.N(SyntaxKind.SquareBracketVar);
                     {
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.OpenBracket);
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.CloseBracket);
                     }
                     t.N(SyntaxKind.EqualityOperator);
                     t.N(SyntaxKind.NameVar);
                     {
                         t.N(SyntaxKind.Identifier);
                     }
                 }
                 t.N(SyntaxKind.ThenKeyword);
                 t.N(SyntaxKind.BlockNode);
                 {
                     t.N(SyntaxKind.BreakStatementNode);
                     {
                         t.N(SyntaxKind.BreakKeyword);
                     }
                 }
                 t.N(SyntaxKind.EndKeyword);
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #6

파일: IfStatement_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.IfStatementNode);
             {
                 t.N(SyntaxKind.IfKeyword);
                 t.N(SyntaxKind.NameVar);
                 {
                     t.N(SyntaxKind.Identifier);
                 }
                 t.N(SyntaxKind.ThenKeyword);
                 t.N(SyntaxKind.BlockNode);
                 {
                     t.N(SyntaxKind.AssignmentStatementNode);
                     {
                         t.N(SyntaxKind.VarList);
                         {
                             t.N(SyntaxKind.NameVar);
                             {
                                 t.N(SyntaxKind.Identifier);
                             }
                         }
                         t.N(SyntaxKind.AssignmentOperator);
                         t.N(SyntaxKind.ExpList);
                         {
                             t.N(SyntaxKind.BinaryOperatorExpression);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                                 t.N(SyntaxKind.PlusOperator);
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.Number);
                                 }
                             }
                         }
                     }
                     t.N(SyntaxKind.SemiColonStatementNode);
                     {
                         t.N(SyntaxKind.Semicolon);
                     }
                 }
                 t.N(SyntaxKind.ElseBlockNode);
                 {
                     t.N(SyntaxKind.ElseKeyword);
                     t.N(SyntaxKind.BlockNode);
                     {
                         t.N(SyntaxKind.AssignmentStatementNode);
                         {
                             t.N(SyntaxKind.VarList);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                             }
                             t.N(SyntaxKind.AssignmentOperator);
                             t.N(SyntaxKind.ExpList);
                             {
                                 t.N(SyntaxKind.FunctionCallExp);
                                 {
                                     t.N(SyntaxKind.NameVar);
                                     {
                                         t.N(SyntaxKind.Identifier);
                                     }
                                     t.N(SyntaxKind.Colon);
                                     t.N(SyntaxKind.Identifier);
                                     t.N(SyntaxKind.ParenArg);
                                     {
                                         t.N(SyntaxKind.OpenParen);
                                         t.N(SyntaxKind.ExpList);
                                         t.N(SyntaxKind.CloseParen);
                                     }
                                 }
                             }
                         }
                         t.N(SyntaxKind.SemiColonStatementNode);
                         {
                             t.N(SyntaxKind.Semicolon);
                         }
                     }
                 }
                 t.N(SyntaxKind.EndKeyword);
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #7

파일: PrefixExpNested_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.FunctionCallStatementNode);
             {
                 t.N(SyntaxKind.FunctionCallExp);
                 {
                     t.N(SyntaxKind.DotVar);
                     {
                         t.N(SyntaxKind.FunctionCallExp);
                         {
                             t.N(SyntaxKind.DotVar);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                                 t.N(SyntaxKind.Dot);
                                 t.N(SyntaxKind.Identifier);
                             }
                             t.N(SyntaxKind.ParenArg);
                             {
                                 t.N(SyntaxKind.OpenParen);
                                 t.N(SyntaxKind.ExpList);
                                 {
                                     t.N(SyntaxKind.SquareBracketVar);
                                     {
                                         t.N(SyntaxKind.NameVar);
                                         {
                                             t.N(SyntaxKind.Identifier);
                                         }
                                         t.N(SyntaxKind.OpenBracket);
                                         t.N(SyntaxKind.SimpleExpression);
                                         {
                                             t.N(SyntaxKind.Number);
                                         }
                                         t.N(SyntaxKind.CloseBracket);
                                     }
                                 }
                                 t.N(SyntaxKind.CloseParen);
                             }
                         }
                         t.N(SyntaxKind.Dot);
                         t.N(SyntaxKind.Identifier);
                     }
                     t.N(SyntaxKind.ParenArg);
                     {
                         t.N(SyntaxKind.OpenParen);
                         t.N(SyntaxKind.ExpList);
                         t.N(SyntaxKind.CloseParen);
                     }
                 }
                 t.N(SyntaxKind.Colon);
                 t.N(SyntaxKind.Identifier);
                 t.N(SyntaxKind.TableConstructorArg);
                 {
                     t.N(SyntaxKind.OpenCurlyBrace);
                     t.N(SyntaxKind.FieldList);
                     t.N(SyntaxKind.CloseCurlyBrace);
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #8

파일: 17_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.IfStatementNode);
             {
                 t.N(SyntaxKind.IfKeyword);
                 t.N(SyntaxKind.BinaryOperatorExpression);
                 {
                     t.N(SyntaxKind.NameVar);
                     {
                         t.N(SyntaxKind.Identifier);
                     }
                     t.N(SyntaxKind.EqualityOperator);
                     t.N(SyntaxKind.SimpleExpression);
                     {
                         t.N(SyntaxKind.String);
                     }
                 }
                 t.N(SyntaxKind.ThenKeyword);
                 t.N(SyntaxKind.BlockNode);
                 {
                     t.N(SyntaxKind.AssignmentStatementNode);
                     {
                         t.N(SyntaxKind.VarList);
                         {
                             t.N(SyntaxKind.NameVar);
                             {
                                 t.N(SyntaxKind.Identifier);
                             }
                         }
                         t.N(SyntaxKind.AssignmentOperator);
                         t.N(SyntaxKind.ExpList);
                         {
                             t.N(SyntaxKind.BinaryOperatorExpression);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                                 t.N(SyntaxKind.PlusOperator);
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                             }
                         }
                     }
                 }
                 t.N(SyntaxKind.ElseIfBlockNode);
                 {
                     t.N(SyntaxKind.ElseIfKeyword);
                     t.N(SyntaxKind.BinaryOperatorExpression);
                     {
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.EqualityOperator);
                         t.N(SyntaxKind.SimpleExpression);
                         {
                             t.N(SyntaxKind.String);
                         }
                     }
                     t.N(SyntaxKind.ThenKeyword);
                     t.N(SyntaxKind.BlockNode);
                     {
                         t.N(SyntaxKind.AssignmentStatementNode);
                         {
                             t.N(SyntaxKind.VarList);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                             }
                             t.N(SyntaxKind.AssignmentOperator);
                             t.N(SyntaxKind.ExpList);
                             {
                                 t.N(SyntaxKind.BinaryOperatorExpression);
                                 {
                                     t.N(SyntaxKind.NameVar);
                                     {
                                         t.N(SyntaxKind.Identifier);
                                     }
                                     t.N(SyntaxKind.MinusOperator);
                                     t.N(SyntaxKind.NameVar);
                                     {
                                         t.N(SyntaxKind.Identifier);
                                     }
                                 }
                             }
                         }
                     }
                 }
                 t.N(SyntaxKind.EndKeyword);
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #9

파일: SmallIf_Generated.cs 프로젝트: Strongc/VSLua

        public void Test(Tester t)
        {
            t.N(SyntaxKind.ChunkNode);
            {
                t.N(SyntaxKind.BlockNode);
                {
                    t.N(SyntaxKind.IfStatementNode);
                    {
                        t.N(SyntaxKind.IfKeyword);
                        t.N(SyntaxKind.BinaryOperatorExpression);
                        {
                            t.N(SyntaxKind.SimpleExpression);
                            {
                                t.N(SyntaxKind.TrueKeyValue);
                            }
                            t.N(SyntaxKind.EqualityOperator);
                            t.N(SyntaxKind.SimpleExpression);
                            {
                                t.N(SyntaxKind.String);
                            }
                        }
                        t.N(SyntaxKind.ThenKeyword);
                        t.N(SyntaxKind.BlockNode);
                        {
                            t.N(SyntaxKind.FunctionCallStatementNode);
                            {
                                t.N(SyntaxKind.NameVar);
                                {
                                    t.N(SyntaxKind.Identifier);
                                }
                                t.N(SyntaxKind.ParenArg);
                                {
                                    t.N(SyntaxKind.OpenParen);
                                    t.N(SyntaxKind.ExpList);
                                    t.N(SyntaxKind.CloseParen);
                                }
                            }
                            t.N(SyntaxKind.SemiColonStatementNode);
                            {
                                t.N(SyntaxKind.Semicolon);
                            }
                        }
                        t.N(SyntaxKind.EndKeyword);
                    }
                }
                t.N(SyntaxKind.EndOfFile);
            }

        }

예제 #10

파일: TripleNestedFunctionCall_Generated.cs 프로젝트: Strongc/VSLua

        public void Test(Tester t)
        {
            t.N(SyntaxKind.ChunkNode);
            {
                t.N(SyntaxKind.BlockNode);
                {
                    t.N(SyntaxKind.FunctionCallStatementNode);
                    {
                        t.N(SyntaxKind.NameVar);
                        {
                            t.N(SyntaxKind.Identifier);
                        }
                        t.N(SyntaxKind.ParenArg);
                        {
                            t.N(SyntaxKind.OpenParen);
                            t.N(SyntaxKind.ExpList);
                            {
                                t.N(SyntaxKind.FunctionCallExp);
                                {
                                    t.N(SyntaxKind.NameVar);
                                    {
                                        t.N(SyntaxKind.Identifier);
                                    }
                                    t.N(SyntaxKind.ParenArg);
                                    {
                                        t.N(SyntaxKind.OpenParen);
                                        t.N(SyntaxKind.ExpList);
                                        {
                                            t.N(SyntaxKind.FunctionCallExp);
                                            {
                                                t.N(SyntaxKind.NameVar);
                                                {
                                                    t.N(SyntaxKind.Identifier);
                                                }
                                                t.N(SyntaxKind.ParenArg);
                                                {
                                                    t.N(SyntaxKind.OpenParen);
                                                    t.N(SyntaxKind.ExpList);
                                                    {
                                                        t.N(SyntaxKind.NameVar);
                                                        {
                                                            t.N(SyntaxKind.Identifier);
                                                        }

                                                    }
                                                    t.N(SyntaxKind.CloseParen);
                                                }
                                            }
                                        }
                                        t.N(SyntaxKind.CloseParen);
                                    }
                                }
                            }
                            t.N(SyntaxKind.CloseParen);
                        }
                    }
                }
                t.N(SyntaxKind.EndOfFile);
            }

        }

예제 #11

파일: NestedTable_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.AssignmentStatementNode);
             {
                 t.N(SyntaxKind.VarList);
                 {
                     t.N(SyntaxKind.NameVar);
                     {
                         t.N(SyntaxKind.Identifier);
                     }
                 }
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.ExpList);
                 {
                     t.N(SyntaxKind.TableConstructorExp);
                     {
                         t.N(SyntaxKind.OpenCurlyBrace);
                         t.N(SyntaxKind.FieldList);
                         {
                             t.N(SyntaxKind.AssignmentField);
                             {
                                 t.N(SyntaxKind.Identifier);
                                 t.N(SyntaxKind.AssignmentOperator);
                                 t.N(SyntaxKind.TableConstructorExp);
                                 {
                                     t.N(SyntaxKind.OpenCurlyBrace);
                                     t.N(SyntaxKind.FieldList);
                                     t.N(SyntaxKind.CloseCurlyBrace);
                                 }
                             }
                         }
                         t.N(SyntaxKind.CloseCurlyBrace);
                     }
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #12

파일: BracketError_Generator.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.AssignmentStatementNode);
             {
                 t.N(SyntaxKind.VarList);
                 {
                     t.N(SyntaxKind.DotVar);
                     {
                         t.N(SyntaxKind.ParenPrefixExp);
                         {
                             t.N(SyntaxKind.OpenParen);
                             t.N(SyntaxKind.MissingToken);
                             {
                                 t.N(SyntaxKind.MissingToken);
                             }
                             t.N(SyntaxKind.MissingToken);
                         }
                         t.N(SyntaxKind.MissingToken);
                         t.N(SyntaxKind.MissingToken);
                     }
                 }
                 t.N(SyntaxKind.MissingToken);
                 t.N(SyntaxKind.ExpList);
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #13

파일: Assignments_Generated.cs 프로젝트: Strongc/VSLua

        public void Test(Tester t)
        {
            t.N(SyntaxKind.ChunkNode);
            {
                t.N(SyntaxKind.BlockNode);
                {
                    t.N(SyntaxKind.AssignmentStatementNode);
                    {
                        t.N(SyntaxKind.VarList);
                        {
                            t.N(SyntaxKind.NameVar);
                            {
                                t.N(SyntaxKind.Identifier);
                            }
                        }
                        t.N(SyntaxKind.AssignmentOperator);
                        t.N(SyntaxKind.ExpList);
                        {
                            t.N(SyntaxKind.BinaryOperatorExpression);
                            {
                                t.N(SyntaxKind.SimpleExpression);
                                {
                                    t.N(SyntaxKind.String);
                                }
                                t.N(SyntaxKind.StringConcatOperator);
                                t.N(SyntaxKind.SimpleExpression);
                                {
                                    t.N(SyntaxKind.String);
                                }
                            }
                        }
                    }
                    t.N(SyntaxKind.AssignmentStatementNode);
                    {
                        t.N(SyntaxKind.VarList);
                        {
                            t.N(SyntaxKind.DotVar);
                            {
                                t.N(SyntaxKind.NameVar);
                                {
                                    t.N(SyntaxKind.Identifier);
                                }
                                t.N(SyntaxKind.Dot);
                                t.N(SyntaxKind.Identifier);
                            }
                        }
                        t.N(SyntaxKind.AssignmentOperator);
                        t.N(SyntaxKind.ExpList);
                        {
                            t.N(SyntaxKind.BinaryOperatorExpression);
                            {
                                t.N(SyntaxKind.DotVar);
                                {
                                    t.N(SyntaxKind.NameVar);
                                    {
                                        t.N(SyntaxKind.Identifier);
                                    }
                                    t.N(SyntaxKind.Dot);
                                    t.N(SyntaxKind.Identifier);
                                }
                                t.N(SyntaxKind.PlusOperator);
                                t.N(SyntaxKind.SimpleExpression);
                                {
                                    t.N(SyntaxKind.Number);
                                }
                            }
                        }
                    }
                    t.N(SyntaxKind.AssignmentStatementNode);
                    {
                        t.N(SyntaxKind.VarList);
                        {
                            t.N(SyntaxKind.NameVar);
                            {
                                t.N(SyntaxKind.Identifier);
                            }
                            t.N(SyntaxKind.Comma);
                            t.N(SyntaxKind.NameVar);
                            {
                                t.N(SyntaxKind.Identifier);
                            }
                        }
                        t.N(SyntaxKind.AssignmentOperator);
                        t.N(SyntaxKind.ExpList);
                        {
                            t.N(SyntaxKind.SimpleExpression);
                            {
                                t.N(SyntaxKind.Number);
                            }

                            t.N(SyntaxKind.Comma);
                            t.N(SyntaxKind.BinaryOperatorExpression);
                            {
                                t.N(SyntaxKind.SimpleExpression);
                                {
                                    t.N(SyntaxKind.Number);
                                }
                                t.N(SyntaxKind.MultiplyOperator);
                                t.N(SyntaxKind.NameVar);
                                {
                                    t.N(SyntaxKind.Identifier);
                                }
                            }
                        }
                    }
                }
                t.N(SyntaxKind.EndOfFile);
            }

        }

예제 #14

파일: 14_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.FunctionCallStatementNode);
             {
                 t.N(SyntaxKind.NameVar);
                 {
                     t.N(SyntaxKind.Identifier);
                 }
                 t.N(SyntaxKind.TableConstructorArg);
                 {
                     t.N(SyntaxKind.OpenCurlyBrace);
                     t.N(SyntaxKind.FieldList);
                     {
                         t.N(SyntaxKind.AssignmentField);
                         {
                             t.N(SyntaxKind.Identifier);
                             t.N(SyntaxKind.AssignmentOperator);
                             t.N(SyntaxKind.SimpleExpression);
                             {
                                 t.N(SyntaxKind.String);
                             }
                         }
                         t.N(SyntaxKind.Comma);
                         t.N(SyntaxKind.AssignmentField);
                         {
                             t.N(SyntaxKind.Identifier);
                             t.N(SyntaxKind.AssignmentOperator);
                             t.N(SyntaxKind.SimpleExpression);
                             {
                                 t.N(SyntaxKind.String);
                             }
                         }
                     }
                     t.N(SyntaxKind.CloseCurlyBrace);
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #15

파일: 23_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.GlobalFunctionStatementNode);
             {
                 t.N(SyntaxKind.FunctionKeyword);
                 t.N(SyntaxKind.FuncNameNode);
                 {
                     t.N(SyntaxKind.Identifier);
                     t.N(SyntaxKind.DotSeparatedNameList);
                 }
                 t.N(SyntaxKind.FuncBodyNode);
                 {
                     t.N(SyntaxKind.OpenParen);
                     t.N(SyntaxKind.NameListPar);
                     {
                         t.N(SyntaxKind.NameList);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                     }
                     t.N(SyntaxKind.CloseParen);
                     t.N(SyntaxKind.BlockNode);
                     {
                         t.N(SyntaxKind.ReturnStatementNode);
                         {
                             t.N(SyntaxKind.ReturnKeyword);
                             t.N(SyntaxKind.ExpList);
                             {
                                 t.N(SyntaxKind.FunctionCallExp);
                                 {
                                     t.N(SyntaxKind.NameVar);
                                     {
                                         t.N(SyntaxKind.Identifier);
                                     }
                                     t.N(SyntaxKind.TableConstructorArg);
                                     {
                                         t.N(SyntaxKind.OpenCurlyBrace);
                                         t.N(SyntaxKind.FieldList);
                                         {
                                             t.N(SyntaxKind.AssignmentField);
                                             {
                                                 t.N(SyntaxKind.Identifier);
                                                 t.N(SyntaxKind.AssignmentOperator);
                                                 t.N(SyntaxKind.NameVar);
                                                 {
                                                     t.N(SyntaxKind.Identifier);
                                                 }
                                             }
                                             t.N(SyntaxKind.Comma);
                                             t.N(SyntaxKind.AssignmentField);
                                             {
                                                 t.N(SyntaxKind.Identifier);
                                                 t.N(SyntaxKind.AssignmentOperator);
                                                 t.N(SyntaxKind.FunctionDef);
                                                 {
                                                     t.N(SyntaxKind.FunctionKeyword);
                                                     t.N(SyntaxKind.FuncBodyNode);
                                                     {
                                                         t.N(SyntaxKind.OpenParen);
                                                         t.N(SyntaxKind.NameListPar);
                                                         {
                                                             t.N(SyntaxKind.NameList);
                                                         }
                                                         t.N(SyntaxKind.CloseParen);
                                                         t.N(SyntaxKind.BlockNode);
                                                         {
                                                             t.N(SyntaxKind.FunctionCallStatementNode);
                                                             {
                                                                 t.N(SyntaxKind.NameVar);
                                                                 {
                                                                     t.N(SyntaxKind.Identifier);
                                                                 }
                                                                 t.N(SyntaxKind.ParenArg);
                                                                 {
                                                                     t.N(SyntaxKind.OpenParen);
                                                                     t.N(SyntaxKind.ExpList);
                                                                     {
                                                                         t.N(SyntaxKind.NameVar);
                                                                         {
                                                                             t.N(SyntaxKind.Identifier);
                                                                         }
                                                                     }
                                                                     t.N(SyntaxKind.CloseParen);
                                                                 }
                                                             }
                                                         }
                                                         t.N(SyntaxKind.EndKeyword);
                                                     }
                                                 }
                                             }
                                         }
                                         t.N(SyntaxKind.CloseCurlyBrace);
                                     }
                                 }
                             }
                         }
                     }
                     t.N(SyntaxKind.EndKeyword);
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #16

파일: GrabKeyFromTable_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.AssignmentStatementNode);
             {
                 t.N(SyntaxKind.VarList);
                 {
                     t.N(SyntaxKind.SquareBracketVar);
                     {
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.OpenBracket);
                         t.N(SyntaxKind.SimpleExpression);
                         {
                             t.N(SyntaxKind.String);
                         }
                         t.N(SyntaxKind.CloseBracket);
                     }
                 }
                 t.N(SyntaxKind.MissingToken);
                 t.N(SyntaxKind.ExpList);
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #17

파일: 10_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.SimpleForStatementNode);
             {
                 t.N(SyntaxKind.ForKeyword);
                 t.N(SyntaxKind.Identifier);
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.NameVar);
                 {
                     t.N(SyntaxKind.Identifier);
                 }
                 t.N(SyntaxKind.Comma);
                 t.N(SyntaxKind.NameVar);
                 {
                     t.N(SyntaxKind.Identifier);
                 }
                 t.N(SyntaxKind.Comma);
                 t.N(SyntaxKind.NameVar);
                 {
                     t.N(SyntaxKind.Identifier);
                 }
                 t.N(SyntaxKind.DoKeyword);
                 t.N(SyntaxKind.BlockNode);
                 {
                     t.N(SyntaxKind.FunctionCallStatementNode);
                     {
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.ParenArg);
                         {
                             t.N(SyntaxKind.OpenParen);
                             t.N(SyntaxKind.ExpList);
                             t.N(SyntaxKind.CloseParen);
                         }
                     }
                     t.N(SyntaxKind.SemiColonStatementNode);
                     {
                         t.N(SyntaxKind.Semicolon);
                     }
                 }
                 t.N(SyntaxKind.EndKeyword);
             }
             t.N(SyntaxKind.SimpleForStatementNode);
             {
                 t.N(SyntaxKind.ForKeyword);
                 t.N(SyntaxKind.Identifier);
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.SimpleExpression);
                 {
                     t.N(SyntaxKind.Number);
                 }
                 t.N(SyntaxKind.Comma);
                 t.N(SyntaxKind.FunctionCallExp);
                 {
                     t.N(SyntaxKind.NameVar);
                     {
                         t.N(SyntaxKind.Identifier);
                     }
                     t.N(SyntaxKind.ParenArg);
                     {
                         t.N(SyntaxKind.OpenParen);
                         t.N(SyntaxKind.ExpList);
                         {
                             t.N(SyntaxKind.NameVar);
                             {
                                 t.N(SyntaxKind.Identifier);
                             }
                         }
                         t.N(SyntaxKind.CloseParen);
                     }
                 }
                 t.N(SyntaxKind.DoKeyword);
                 t.N(SyntaxKind.BlockNode);
                 {
                     t.N(SyntaxKind.FunctionCallStatementNode);
                     {
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.ParenArg);
                         {
                             t.N(SyntaxKind.OpenParen);
                             t.N(SyntaxKind.ExpList);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                             }
                             t.N(SyntaxKind.CloseParen);
                         }
                     }
                 }
                 t.N(SyntaxKind.EndKeyword);
             }
             t.N(SyntaxKind.SimpleForStatementNode);
             {
                 t.N(SyntaxKind.ForKeyword);
                 t.N(SyntaxKind.Identifier);
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.SimpleExpression);
                 {
                     t.N(SyntaxKind.Number);
                 }
                 t.N(SyntaxKind.Comma);
                 t.N(SyntaxKind.SimpleExpression);
                 {
                     t.N(SyntaxKind.Number);
                 }
                 t.N(SyntaxKind.Comma);
                 t.N(SyntaxKind.EndKeyword);
                 {
                     t.N(SyntaxKind.MinusOperator);
                     t.N(SyntaxKind.SimpleExpression);
                     {
                         t.N(SyntaxKind.Number);
                     }
                 }
                 t.N(SyntaxKind.DoKeyword);
                 t.N(SyntaxKind.BlockNode);
                 {
                     t.N(SyntaxKind.FunctionCallStatementNode);
                     {
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.ParenArg);
                         {
                             t.N(SyntaxKind.OpenParen);
                             t.N(SyntaxKind.ExpList);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                             }
                             t.N(SyntaxKind.CloseParen);
                         }
                     }
                 }
                 t.N(SyntaxKind.EndKeyword);
             }
             t.N(SyntaxKind.SimpleForStatementNode);
             {
                 t.N(SyntaxKind.ForKeyword);
                 t.N(SyntaxKind.Identifier);
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.FunctionCallExp);
                 {
                     t.N(SyntaxKind.NameVar);
                     {
                         t.N(SyntaxKind.Identifier);
                     }
                     t.N(SyntaxKind.ParenArg);
                     {
                         t.N(SyntaxKind.OpenParen);
                         t.N(SyntaxKind.ExpList);
                         {
                             t.N(SyntaxKind.SimpleExpression);
                             {
                                 t.N(SyntaxKind.TrueKeyValue);
                             }
                         }
                         t.N(SyntaxKind.CloseParen);
                     }
                 }
                 t.N(SyntaxKind.Comma);
                 t.N(SyntaxKind.SimpleExpression);
                 {
                     t.N(SyntaxKind.Number);
                 }
                 t.N(SyntaxKind.DoKeyword);
                 t.N(SyntaxKind.BlockNode);
                 {
                     t.N(SyntaxKind.FunctionCallStatementNode);
                     {
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.ParenArg);
                         {
                             t.N(SyntaxKind.OpenParen);
                             t.N(SyntaxKind.ExpList);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                             }
                             t.N(SyntaxKind.CloseParen);
                         }
                     }
                 }
                 t.N(SyntaxKind.EndKeyword);
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #18

파일: 31_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.GlobalFunctionStatementNode);
             {
                 t.N(SyntaxKind.FunctionKeyword);
                 t.N(SyntaxKind.FuncNameNode);
                 {
                     t.N(SyntaxKind.Identifier);
                     t.N(SyntaxKind.DotSeparatedNameList);
                 }
                 t.N(SyntaxKind.FuncBodyNode);
                 {
                     t.N(SyntaxKind.OpenParen);
                     t.N(SyntaxKind.NameListPar);
                     {
                         t.N(SyntaxKind.NameList);
                     }
                     t.N(SyntaxKind.CloseParen);
                     t.N(SyntaxKind.BlockNode);
                     {
                         t.N(SyntaxKind.LocalAssignmentStatementNode);
                         {
                             t.N(SyntaxKind.LocalKeyword);
                             t.N(SyntaxKind.NameList);
                             {
                                 t.N(SyntaxKind.Identifier);
                             }
                             t.N(SyntaxKind.AssignmentOperator);
                             t.N(SyntaxKind.ExpList);
                             {
                                 t.N(SyntaxKind.FunctionCallExp);
                                 {
                                     t.N(SyntaxKind.DotVar);
                                     {
                                         t.N(SyntaxKind.NameVar);
                                         {
                                             t.N(SyntaxKind.Identifier);
                                         }
                                         t.N(SyntaxKind.Dot);
                                         t.N(SyntaxKind.Identifier);
                                     }
                                     t.N(SyntaxKind.ParenArg);
                                     {
                                         t.N(SyntaxKind.OpenParen);
                                         t.N(SyntaxKind.ExpList);
                                         t.N(SyntaxKind.CloseParen);
                                     }
                                 }
                             }
                         }
                         t.N(SyntaxKind.IfStatementNode);
                         {
                             t.N(SyntaxKind.IfKeyword);
                             t.N(SyntaxKind.BinaryOperatorExpression);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                                 t.N(SyntaxKind.EqualityOperator);
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.String);
                                 }
                             }
                             t.N(SyntaxKind.ThenKeyword);
                             t.N(SyntaxKind.BlockNode);
                             {
                                 t.N(SyntaxKind.ReturnStatementNode);
                                 {
                                     t.N(SyntaxKind.ReturnKeyword);
                                     t.N(SyntaxKind.ExpList);
                                     {
                                         t.N(SyntaxKind.FunctionCallExp);
                                         {
                                             t.N(SyntaxKind.NameVar);
                                             {
                                                 t.N(SyntaxKind.Identifier);
                                             }
                                             t.N(SyntaxKind.ParenArg);
                                             {
                                                 t.N(SyntaxKind.OpenParen);
                                                 t.N(SyntaxKind.ExpList);
                                                 t.N(SyntaxKind.CloseParen);
                                             }
                                         }
                                     }
                                 }
                             }
                             t.N(SyntaxKind.EndKeyword);
                         }
                     }
                     t.N(SyntaxKind.EndKeyword);
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #19

파일: 8_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.MultipleArgForStatementNode);
             {
                 t.N(SyntaxKind.ForKeyword);
                 t.N(SyntaxKind.NameList);
                 {
                     t.N(SyntaxKind.Identifier);
                     t.N(SyntaxKind.Comma);
                     t.N(SyntaxKind.Identifier);
                 }
                 t.N(SyntaxKind.InKeyword);
                 t.N(SyntaxKind.ExpList);
                 {
                     t.N(SyntaxKind.FunctionCallExp);
                     {
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.ParenArg);
                         {
                             t.N(SyntaxKind.OpenParen);
                             t.N(SyntaxKind.ExpList);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                             }
                             t.N(SyntaxKind.CloseParen);
                         }
                     }
                 }
                 t.N(SyntaxKind.DoKeyword);
                 t.N(SyntaxKind.BlockNode);
                 {
                     t.N(SyntaxKind.FunctionCallStatementNode);
                     {
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.ParenArg);
                         {
                             t.N(SyntaxKind.OpenParen);
                             t.N(SyntaxKind.ExpList);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                                 t.N(SyntaxKind.Comma);
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                             }
                             t.N(SyntaxKind.CloseParen);
                         }
                     }
                 }
                 t.N(SyntaxKind.EndKeyword);
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #20

파일: WhileStatement_Generated.cs 프로젝트: Strongc/VSLua

        public void Test(Tester t)
        {
            t.N(SyntaxKind.ChunkNode);
            {
                t.N(SyntaxKind.BlockNode);
                {
                    t.N(SyntaxKind.LocalAssignmentStatementNode);
                    {
                        t.N(SyntaxKind.LocalKeyword);
                        t.N(SyntaxKind.NameList);
                        {
                            t.N(SyntaxKind.Identifier);
                        }
                        t.N(SyntaxKind.AssignmentOperator);
                        t.N(SyntaxKind.ExpList);
                        {
                            t.N(SyntaxKind.SimpleExpression);
                            {
                                t.N(SyntaxKind.Number);
                            }
                        }
                    }
                    t.N(SyntaxKind.WhileStatementNode);
                    {
                        t.N(SyntaxKind.WhileKeyword);
                        t.N(SyntaxKind.SquareBracketVar);
                        {
                            t.N(SyntaxKind.NameVar);
                            {
                                t.N(SyntaxKind.Identifier);
                            }
                            t.N(SyntaxKind.OpenBracket);
                            t.N(SyntaxKind.NameVar);
                            {
                                t.N(SyntaxKind.Identifier);
                            }
                            t.N(SyntaxKind.CloseBracket);
                        }
                        t.N(SyntaxKind.DoKeyword);
                        t.N(SyntaxKind.BlockNode);
                        {
                            t.N(SyntaxKind.FunctionCallStatementNode);
                            {
                                t.N(SyntaxKind.NameVar);
                                {
                                    t.N(SyntaxKind.Identifier);
                                }
                                t.N(SyntaxKind.ParenArg);
                                {
                                    t.N(SyntaxKind.OpenParen);
                                    t.N(SyntaxKind.ExpList);
                                    {
                                        t.N(SyntaxKind.SquareBracketVar);
                                        {
                                            t.N(SyntaxKind.NameVar);
                                            {
                                                t.N(SyntaxKind.Identifier);
                                            }
                                            t.N(SyntaxKind.OpenBracket);
                                            t.N(SyntaxKind.NameVar);
                                            {
                                                t.N(SyntaxKind.Identifier);
                                            }
                                            t.N(SyntaxKind.CloseBracket);
                                        }
                                    }
                                    t.N(SyntaxKind.CloseParen);
                                }
                            }
                            t.N(SyntaxKind.AssignmentStatementNode);
                            {
                                t.N(SyntaxKind.VarList);
                                {
                                    t.N(SyntaxKind.NameVar);
                                    {
                                        t.N(SyntaxKind.Identifier);
                                    }
                                }
                                t.N(SyntaxKind.AssignmentOperator);
                                t.N(SyntaxKind.ExpList);
                                {
                                    t.N(SyntaxKind.BinaryOperatorExpression);
                                    {
                                        t.N(SyntaxKind.NameVar);
                                        {
                                            t.N(SyntaxKind.Identifier);
                                        }
                                        t.N(SyntaxKind.PlusOperator);
                                        t.N(SyntaxKind.SimpleExpression);
                                        {
                                            t.N(SyntaxKind.Number);
                                        }
                                    }
                                }
                            }
                        }
                        t.N(SyntaxKind.EndKeyword);
                    }
                }
                t.N(SyntaxKind.EndOfFile);
            }

        }

예제 #21

파일: 20_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.IfStatementNode);
             {
                 t.N(SyntaxKind.IfKeyword);
                 t.N(SyntaxKind.BinaryOperatorExpression);
                 {
                     t.N(SyntaxKind.SquareBracketVar);
                     {
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.OpenBracket);
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.CloseBracket);
                     }
                     t.N(SyntaxKind.NotEqualsOperator);
                     t.N(SyntaxKind.SimpleExpression);
                     {
                         t.N(SyntaxKind.NilKeyValue);
                     }
                 }
                 t.N(SyntaxKind.ThenKeyword);
                 t.N(SyntaxKind.BlockNode);
                 {
                     t.N(SyntaxKind.ReturnStatementNode);
                     {
                         t.N(SyntaxKind.ReturnKeyword);
                         t.N(SyntaxKind.ExpList);
                         {
                             t.N(SyntaxKind.SquareBracketVar);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                                 t.N(SyntaxKind.OpenBracket);
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                                 t.N(SyntaxKind.CloseBracket);
                             }
                             t.N(SyntaxKind.Comma);
                             t.N(SyntaxKind.FunctionCallExp);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                                 t.N(SyntaxKind.ParenArg);
                                 {
                                     t.N(SyntaxKind.OpenParen);
                                     t.N(SyntaxKind.ExpList);
                                     {
                                         t.N(SyntaxKind.NameVar);
                                         {
                                             t.N(SyntaxKind.Identifier);
                                         }
                                         t.N(SyntaxKind.Comma);
                                         t.N(SyntaxKind.BinaryOperatorExpression);
                                         {
                                             t.N(SyntaxKind.NameVar);
                                             {
                                                 t.N(SyntaxKind.Identifier);
                                             }
                                             t.N(SyntaxKind.PlusOperator);
                                             t.N(SyntaxKind.SimpleExpression);
                                             {
                                                 t.N(SyntaxKind.Number);
                                             }
                                         }
                                     }
                                     t.N(SyntaxKind.CloseParen);
                                 }
                             }
                         }
                     }
                 }
                 t.N(SyntaxKind.EndKeyword);
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #22

파일: FunctionDefError_Generated.cs 프로젝트: Strongc/VSLua

        public void Test(Tester t)
        {
            t.N(SyntaxKind.ChunkNode);
            {
                t.N(SyntaxKind.BlockNode);
                {
                    t.N(SyntaxKind.AssignmentStatementNode);
                    {
                        t.N(SyntaxKind.VarList);
                        {
                            t.N(SyntaxKind.NameVar);
                            {
                                t.N(SyntaxKind.Identifier);
                            }
                        }
                        t.N(SyntaxKind.AssignmentOperator);
                        t.N(SyntaxKind.ExpList);
                        {
                            t.N(SyntaxKind.FunctionDef);
                            {
                                t.N(SyntaxKind.FunctionKeyword);
                                t.N(SyntaxKind.FuncBodyNode);
                                {
                                    t.N(SyntaxKind.MissingToken);
                                    t.N(SyntaxKind.NameListPar);
                                    {
                                        t.N(SyntaxKind.NameList);
                                    }
                                    t.N(SyntaxKind.MissingToken);
                                    t.N(SyntaxKind.BlockNode);
                                    {
                                        t.N(SyntaxKind.ReturnStatementNode);
                                        {
                                            t.N(SyntaxKind.ReturnKeyword);
                                            t.N(SyntaxKind.ExpList);
                                        }
                                    }
                                    t.N(SyntaxKind.EndKeyword);
                                }
                            }
                        }
                    }
                }
                t.N(SyntaxKind.EndOfFile);
            }

        }

예제 #23

파일: 2_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.AssignmentStatementNode);
             {
                 t.N(SyntaxKind.VarList);
                 {
                     t.N(SyntaxKind.NameVar);
                     {
                         t.N(SyntaxKind.Identifier);
                     }
                 }
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.ExpList);
                 {
                     t.N(SyntaxKind.FunctionCallExp);
                     {
                         t.N(SyntaxKind.DotVar);
                         {
                             t.N(SyntaxKind.NameVar);
                             {
                                 t.N(SyntaxKind.Identifier);
                             }
                             t.N(SyntaxKind.Dot);
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.ParenArg);
                         {
                             t.N(SyntaxKind.OpenParen);
                             t.N(SyntaxKind.ExpList);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                                 t.N(SyntaxKind.Comma);
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.String);
                                 }
                                 t.N(SyntaxKind.Comma);
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.String);
                                 }
                             }
                             t.N(SyntaxKind.CloseParen);
                         }
                     }
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #24

파일: 12_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.FunctionCallStatementNode);
             {
                 t.N(SyntaxKind.NameVar);
                 {
                     t.N(SyntaxKind.Identifier);
                 }
                 t.N(SyntaxKind.ParenArg);
                 {
                     t.N(SyntaxKind.OpenParen);
                     t.N(SyntaxKind.ExpList);
                     {
                         t.N(SyntaxKind.SimpleExpression);
                         {
                             t.N(SyntaxKind.TrueKeyValue);
                         }
                         t.N(SyntaxKind.Comma);
                         t.N(SyntaxKind.SimpleExpression);
                         {
                             t.N(SyntaxKind.Number);
                         }
                     }
                     t.N(SyntaxKind.CloseParen);
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #25

파일: 26_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.GlobalFunctionStatementNode);
             {
                 t.N(SyntaxKind.FunctionKeyword);
                 t.N(SyntaxKind.FuncNameNode);
                 {
                     t.N(SyntaxKind.Identifier);
                     t.N(SyntaxKind.DotSeparatedNameList);
                 }
                 t.N(SyntaxKind.FuncBodyNode);
                 {
                     t.N(SyntaxKind.OpenParen);
                     t.N(SyntaxKind.NameListPar);
                     {
                         t.N(SyntaxKind.NameList);
                     }
                     t.N(SyntaxKind.CloseParen);
                     t.N(SyntaxKind.BlockNode);
                     {
                         t.N(SyntaxKind.ReturnStatementNode);
                         {
                             t.N(SyntaxKind.ReturnKeyword);
                             t.N(SyntaxKind.ExpList);
                             t.N(SyntaxKind.Semicolon);
                         }
                     }
                     t.N(SyntaxKind.EndKeyword);
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #26

파일: 28_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.IfStatementNode);
             {
                 t.N(SyntaxKind.IfKeyword);
                 t.N(SyntaxKind.BinaryOperatorExpression);
                 {
                     t.N(SyntaxKind.SimpleExpression);
                     {
                         t.N(SyntaxKind.TrueKeyValue);
                     }
                     t.N(SyntaxKind.EqualityOperator);
                     t.N(SyntaxKind.SimpleExpression);
                     {
                         t.N(SyntaxKind.String);
                     }
                 }
                 t.N(SyntaxKind.ThenKeyword);
                 t.N(SyntaxKind.BlockNode);
                 {
                     t.N(SyntaxKind.AssignmentStatementNode);
                     {
                         t.N(SyntaxKind.VarList);
                         {
                             t.N(SyntaxKind.NameVar);
                             {
                                 t.N(SyntaxKind.Identifier);
                             }
                         }
                         t.N(SyntaxKind.AssignmentOperator);
                         t.N(SyntaxKind.ExpList);
                         {
                             t.N(SyntaxKind.SquareBracketVar);
                             {
                                 t.N(SyntaxKind.NameVar);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                                 t.N(SyntaxKind.OpenBracket);
                                 t.N(SyntaxKind.SimpleExpression);
                                 {
                                     t.N(SyntaxKind.TrueKeyValue);
                                 }
                                 t.N(SyntaxKind.CloseBracket);
                             }
                         }
                     }
                 }
                 t.N(SyntaxKind.EndKeyword);
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #27

파일: 11_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.LocalAssignmentStatementNode);
             {
                 t.N(SyntaxKind.LocalKeyword);
                 t.N(SyntaxKind.NameList);
                 {
                     t.N(SyntaxKind.Identifier);
                 }
             }
             t.N(SyntaxKind.AssignmentStatementNode);
             {
                 t.N(SyntaxKind.VarList);
                 {
                     t.N(SyntaxKind.NameVar);
                     {
                         t.N(SyntaxKind.Identifier);
                     }
                 }
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.ExpList);
                 {
                     t.N(SyntaxKind.FunctionDef);
                     {
                         t.N(SyntaxKind.FunctionKeyword);
                         t.N(SyntaxKind.FuncBodyNode);
                         {
                             t.N(SyntaxKind.OpenParen);
                             t.N(SyntaxKind.NameListPar);
                             {
                                 t.N(SyntaxKind.NameList);
                                 {
                                     t.N(SyntaxKind.Identifier);
                                 }
                             }
                             t.N(SyntaxKind.CloseParen);
                             t.N(SyntaxKind.BlockNode);
                             {
                                 t.N(SyntaxKind.IfStatementNode);
                                 {
                                     t.N(SyntaxKind.IfKeyword);
                                     t.N(SyntaxKind.BinaryOperatorExpression);
                                     {
                                         t.N(SyntaxKind.NameVar);
                                         {
                                             t.N(SyntaxKind.Identifier);
                                         }
                                         t.N(SyntaxKind.EqualityOperator);
                                         t.N(SyntaxKind.SimpleExpression);
                                         {
                                             t.N(SyntaxKind.Number);
                                         }
                                     }
                                     t.N(SyntaxKind.ThenKeyword);
                                     t.N(SyntaxKind.BlockNode);
                                     {
                                         t.N(SyntaxKind.ReturnStatementNode);
                                         {
                                             t.N(SyntaxKind.ReturnKeyword);
                                             t.N(SyntaxKind.ExpList);
                                             {
                                                 t.N(SyntaxKind.SimpleExpression);
                                                 {
                                                     t.N(SyntaxKind.Number);
                                                 }
                                             }
                                         }
                                     }
                                     t.N(SyntaxKind.EndKeyword);
                                 }
                             }
                             t.N(SyntaxKind.EndKeyword);
                         }
                     }
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #28

파일: SimpleTableError_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.AssignmentStatementNode);
             {
                 t.N(SyntaxKind.VarList);
                 {
                     t.N(SyntaxKind.NameVar);
                     {
                         t.N(SyntaxKind.Identifier);
                     }
                 }
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.ExpList);
                 {
                     t.N(SyntaxKind.SimpleExpression);
                     {
                         t.N(SyntaxKind.Number);
                     }
                     t.N(SyntaxKind.Comma);
                     t.N(SyntaxKind.NameVar);
                     {
                         t.N(SyntaxKind.Identifier);
                     }
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #29

파일: 19_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.LocalAssignmentStatementNode);
             {
                 t.N(SyntaxKind.LocalKeyword);
                 t.N(SyntaxKind.NameList);
                 {
                     t.N(SyntaxKind.Identifier);
                 }
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.ExpList);
                 {
                     t.N(SyntaxKind.BinaryOperatorExpression);
                     {
                         t.N(SyntaxKind.SimpleExpression);
                         {
                             t.N(SyntaxKind.Number);
                         }
                         t.N(SyntaxKind.MultiplyOperator);
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                     }
                 }
             }
             t.N(SyntaxKind.LocalAssignmentStatementNode);
             {
                 t.N(SyntaxKind.LocalKeyword);
                 t.N(SyntaxKind.NameList);
                 {
                     t.N(SyntaxKind.Identifier);
                 }
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.ExpList);
                 {
                     t.N(SyntaxKind.FunctionCallExp);
                     {
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.ParenArg);
                         {
                             t.N(SyntaxKind.OpenParen);
                             t.N(SyntaxKind.ExpList);
                             {
                                 t.N(SyntaxKind.BinaryOperatorExpression);
                                 {
                                     t.N(SyntaxKind.NameVar);
                                     {
                                         t.N(SyntaxKind.Identifier);
                                     }
                                     t.N(SyntaxKind.ExponentOperator);
                                     t.N(SyntaxKind.BinaryOperatorExpression);
                                     {
                                         t.N(SyntaxKind.SimpleExpression);
                                         {
                                             t.N(SyntaxKind.Number);
                                         }
                                         t.N(SyntaxKind.MinusOperator);
                                         t.N(SyntaxKind.BinaryOperatorExpression);
                                         {
                                             t.N(SyntaxKind.SimpleExpression);
                                             {
                                                 t.N(SyntaxKind.Number);
                                             }
                                             t.N(SyntaxKind.MultiplyOperator);
                                             t.N(SyntaxKind.BinaryOperatorExpression);
                                             {
                                                 t.N(SyntaxKind.NameVar);
                                                 {
                                                     t.N(SyntaxKind.Identifier);
                                                 }
                                                 t.N(SyntaxKind.MultiplyOperator);
                                                 t.N(SyntaxKind.NameVar);
                                                 {
                                                     t.N(SyntaxKind.Identifier);
                                                 }
                                             }
                                         }
                                     }
                                 }
                             }
                             t.N(SyntaxKind.CloseParen);
                         }
                     }
                 }
             }
             t.N(SyntaxKind.LocalAssignmentStatementNode);
             {
                 t.N(SyntaxKind.LocalKeyword);
                 t.N(SyntaxKind.NameList);
                 {
                     t.N(SyntaxKind.Identifier);
                 }
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.ExpList);
                 {
                     t.N(SyntaxKind.BinaryOperatorExpression);
                     {
                         t.N(SyntaxKind.ParenPrefixExp);
                         {
                             t.N(SyntaxKind.OpenParen);
                             t.N(SyntaxKind.EndKeyword);
                             {
                                 t.N(SyntaxKind.MinusOperator);
                                 t.N(SyntaxKind.BinaryOperatorExpression);
                                 {
                                     t.N(SyntaxKind.NameVar);
                                     {
                                         t.N(SyntaxKind.Identifier);
                                     }
                                     t.N(SyntaxKind.PlusOperator);
                                     t.N(SyntaxKind.NameVar);
                                     {
                                         t.N(SyntaxKind.Identifier);
                                     }
                                 }
                             }
                             t.N(SyntaxKind.CloseParen);
                         }
                         t.N(SyntaxKind.DivideOperator);
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                     }
                 }
             }
             t.N(SyntaxKind.LocalAssignmentStatementNode);
             {
                 t.N(SyntaxKind.LocalKeyword);
                 t.N(SyntaxKind.NameList);
                 {
                     t.N(SyntaxKind.Identifier);
                 }
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.ExpList);
                 {
                     t.N(SyntaxKind.SimpleExpression);
                     {
                         t.N(SyntaxKind.Number);
                     }
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }

예제 #30

파일: PrefixExpFirst_Generated.cs 프로젝트: Strongc/VSLua

 public void Test(Tester t)
 {
     t.N(SyntaxKind.ChunkNode);
     {
         t.N(SyntaxKind.BlockNode);
         {
             t.N(SyntaxKind.AssignmentStatementNode);
             {
                 t.N(SyntaxKind.VarList);
                 {
                     t.N(SyntaxKind.SquareBracketVar);
                     {
                         t.N(SyntaxKind.ParenPrefixExp);
                         {
                             t.N(SyntaxKind.OpenParen);
                             t.N(SyntaxKind.NameVar);
                             {
                                 t.N(SyntaxKind.Identifier);
                             }
                             t.N(SyntaxKind.CloseParen);
                         }
                         t.N(SyntaxKind.OpenBracket);
                         t.N(SyntaxKind.NameVar);
                         {
                             t.N(SyntaxKind.Identifier);
                         }
                         t.N(SyntaxKind.CloseBracket);
                     }
                 }
                 t.N(SyntaxKind.AssignmentOperator);
                 t.N(SyntaxKind.ExpList);
                 {
                     t.N(SyntaxKind.NameVar);
                     {
                         t.N(SyntaxKind.Identifier);
                     }
                 }
             }
         }
         t.N(SyntaxKind.EndOfFile);
     }
 }