Merge pull request #163 from toxamin/type-functions

Implement type functions

Author: GGG-KILLER

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

@@ -184,6 +184,9 @@ public partial class LuaSyntaxVisitor<TResult>
         /// <summary>Called when the visitor visits a TypeDeclarationStatementSyntax node.</summary>
         public virtual TResult? VisitTypeDeclarationStatement(TypeDeclarationStatementSyntax node) => this.DefaultVisit(node);
 
+        /// <summary>Called when the visitor visits a TypeFunctionDeclarationStatementSyntax node.</summary>
+        public virtual TResult? VisitTypeFunctionDeclarationStatement(TypeFunctionDeclarationStatementSyntax node) => this.DefaultVisit(node);
+
         /// <summary>Called when the visitor visits a TypeBindingSyntax node.</summary>
         public virtual TResult? VisitTypeBinding(TypeBindingSyntax node) => this.DefaultVisit(node);
 
@@ -427,6 +430,9 @@ public partial class LuaSyntaxVisitor
         /// <summary>Called when the visitor visits a TypeDeclarationStatementSyntax node.</summary>
         public virtual void VisitTypeDeclarationStatement(TypeDeclarationStatementSyntax node) => this.DefaultVisit(node);
 
+        /// <summary>Called when the visitor visits a TypeFunctionDeclarationStatementSyntax node.</summary>
+        public virtual void VisitTypeFunctionDeclarationStatement(TypeFunctionDeclarationStatementSyntax node) => this.DefaultVisit(node);
+
         /// <summary>Called when the visitor visits a TypeBindingSyntax node.</summary>
         public virtual void VisitTypeBinding(TypeBindingSyntax node) => this.DefaultVisit(node);
 
@@ -670,6 +676,9 @@ public partial class LuaSyntaxRewriter : LuaSyntaxVisitor<SyntaxNode?>
         public override SyntaxNode? VisitTypeDeclarationStatement(TypeDeclarationStatementSyntax node)
             => node.Update(VisitToken(node.ExportKeyword), VisitToken(node.TypeKeyword), VisitToken(node.Name), (TypeParameterListSyntax?)Visit(node.TypeParameterList), VisitToken(node.EqualsToken), (TypeSyntax?)Visit(node.Type) ?? throw new ArgumentNullException("type"), VisitToken(node.SemicolonToken));
 
+        public override SyntaxNode? VisitTypeFunctionDeclarationStatement(TypeFunctionDeclarationStatementSyntax node)
+            => node.Update(VisitToken(node.ExportKeyword), VisitToken(node.TypeKeyword), VisitToken(node.FunctionKeyword), VisitToken(node.Name), (ParameterListSyntax?)Visit(node.Parameters) ?? throw new ArgumentNullException("parameters"), (TypeBindingSyntax?)Visit(node.TypeBinding), (StatementListSyntax?)Visit(node.Body) ?? throw new ArgumentNullException("body"), VisitToken(node.EndKeyword), VisitToken(node.SemicolonToken));
+
         public override SyntaxNode? VisitTypeBinding(TypeBindingSyntax node)
             => node.Update(VisitToken(node.ColonToken), (TypeSyntax?)Visit(node.Type) ?? throw new ArgumentNullException("type"));
 
@@ -1947,6 +1956,46 @@ public static TypeDeclarationStatementSyntax TypeDeclarationStatement(SyntaxToke
         public static TypeDeclarationStatementSyntax TypeDeclarationStatement(string name, TypeSyntax type)
             => SyntaxFactory.TypeDeclarationStatement(default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.TypeKeyword), SyntaxFactory.Identifier(name), default(TypeParameterListSyntax?), SyntaxFactory.Token(SyntaxKind.EqualsToken), type, default(SyntaxToken));
 
+        /// <summary>
+        /// Creates a new
+        /// <see cref="TypeFunctionDeclarationStatementSyntax" />
+        /// node.
+        /// </summary>
+        public static TypeFunctionDeclarationStatementSyntax TypeFunctionDeclarationStatement(SyntaxToken exportKeyword, SyntaxToken typeKeyword, SyntaxToken functionKeyword, SyntaxToken name, ParameterListSyntax parameters, TypeBindingSyntax? typeBinding, StatementListSyntax body, SyntaxToken endKeyword, SyntaxToken semicolonToken)
+        {
+            switch (exportKeyword.Kind())
+            {
+                case SyntaxKind.ExportKeyword:
+                case SyntaxKind.None: break;
+                default: throw new ArgumentException("Provided kind is not one of the valid ones.", nameof(exportKeyword));
+            }
+            if (typeKeyword.Kind() != SyntaxKind.TypeKeyword) throw new ArgumentException($"Invalid kind provided. Expected TypeKeyword but got {typeKeyword.Kind()}.", nameof(typeKeyword));
+            if (functionKeyword.Kind() != SyntaxKind.FunctionKeyword) throw new ArgumentException($"Invalid kind provided. Expected FunctionKeyword but got {functionKeyword.Kind()}.", nameof(functionKeyword));
+            if (name.Kind() != SyntaxKind.IdentifierToken) throw new ArgumentException($"Invalid kind provided. Expected IdentifierToken but got {name.Kind()}.", nameof(name));
+            if (parameters == null) throw new ArgumentNullException(nameof(parameters));
+            if (body == null) throw new ArgumentNullException(nameof(body));
+            if (endKeyword.Kind() != SyntaxKind.EndKeyword) throw new ArgumentException($"Invalid kind provided. Expected EndKeyword but got {endKeyword.Kind()}.", nameof(endKeyword));
+            switch (semicolonToken.Kind())
+            {
+                case SyntaxKind.SemicolonToken:
+                case SyntaxKind.None: break;
+                default: throw new ArgumentException("Provided kind is not one of the valid ones.", nameof(semicolonToken));
+            }
+            return (TypeFunctionDeclarationStatementSyntax)Syntax.InternalSyntax.SyntaxFactory.TypeFunctionDeclarationStatement((Syntax.InternalSyntax.SyntaxToken?)exportKeyword.Node, (Syntax.InternalSyntax.SyntaxToken)typeKeyword.Node!, (Syntax.InternalSyntax.SyntaxToken)functionKeyword.Node!, (Syntax.InternalSyntax.SyntaxToken)name.Node!, (Syntax.InternalSyntax.ParameterListSyntax)parameters.Green, typeBinding == null ? null : (Syntax.InternalSyntax.TypeBindingSyntax)typeBinding.Green, (Syntax.InternalSyntax.StatementListSyntax)body.Green, (Syntax.InternalSyntax.SyntaxToken)endKeyword.Node!, (Syntax.InternalSyntax.SyntaxToken?)semicolonToken.Node).CreateRed();
+        }
+
+        /// <summary>Creates a new TypeFunctionDeclarationStatementSyntax instance.</summary>
+        public static TypeFunctionDeclarationStatementSyntax TypeFunctionDeclarationStatement(SyntaxToken name, ParameterListSyntax parameters, TypeBindingSyntax? typeBinding, StatementListSyntax body)
+            => SyntaxFactory.TypeFunctionDeclarationStatement(default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.TypeKeyword), SyntaxFactory.Token(SyntaxKind.FunctionKeyword), name, parameters, typeBinding, body, SyntaxFactory.Token(SyntaxKind.EndKeyword), default(SyntaxToken));
+
+        /// <summary>Creates a new TypeFunctionDeclarationStatementSyntax instance.</summary>
+        public static TypeFunctionDeclarationStatementSyntax TypeFunctionDeclarationStatement(SyntaxToken name, ParameterListSyntax parameters, StatementListSyntax body)
+            => SyntaxFactory.TypeFunctionDeclarationStatement(default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.TypeKeyword), SyntaxFactory.Token(SyntaxKind.FunctionKeyword), name, parameters, default(TypeBindingSyntax?), body, SyntaxFactory.Token(SyntaxKind.EndKeyword), default(SyntaxToken));
+
+        /// <summary>Creates a new TypeFunctionDeclarationStatementSyntax instance.</summary>
+        public static TypeFunctionDeclarationStatementSyntax TypeFunctionDeclarationStatement(string name, ParameterListSyntax parameters, StatementListSyntax body)
+            => SyntaxFactory.TypeFunctionDeclarationStatement(default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.TypeKeyword), SyntaxFactory.Token(SyntaxKind.FunctionKeyword), SyntaxFactory.Identifier(name), parameters, default(TypeBindingSyntax?), body, SyntaxFactory.Token(SyntaxKind.EndKeyword), default(SyntaxToken));
+
         /// <summary>
         /// Creates a new
         /// <see cref="TypeBindingSyntax" />

src/Compilers/Lua/Portable/Generated/Loretta.Generators.SyntaxXml/Loretta.Generators.SyntaxXml.SourceGenerator/Syntax.xml.Internal.g.cs

@@ -3669,6 +3669,113 @@ public TypeDeclarationStatementSyntax AddTypeParameterListNames(params TypeParam
         }
     }
 
+    /// <summary>Represents a type function declaration statement.</summary>
+    /// <remarks>
+    /// <para>This node is associated with the following syntax kinds:</para>
+    /// <list type="bullet">
+    /// <item><description><see cref="SyntaxKind.TypeFunctionDeclarationStatement"/></description></item>
+    /// </list>
+    /// </remarks>
+    public sealed partial class TypeFunctionDeclarationStatementSyntax : StatementSyntax
+    {
+        private ParameterListSyntax? parameters;
+        private TypeBindingSyntax? typeBinding;
+        private StatementListSyntax? body;
+
+        internal TypeFunctionDeclarationStatementSyntax(InternalSyntax.LuaSyntaxNode green, SyntaxNode? parent, int position)
+          : base(green, parent, position)
+        {
+        }
+
+        /// <summary>The 'export' keyword.</summary>
+        public SyntaxToken ExportKeyword
+        {
+            get
+            {
+                var slot = ((Syntax.InternalSyntax.TypeFunctionDeclarationStatementSyntax)this.Green).exportKeyword;
+                return slot != null ? new SyntaxToken(this, slot, Position, 0) : default;
+            }
+        }
+
+        /// <summary>The 'type' keyword.</summary>
+        public SyntaxToken TypeKeyword => new SyntaxToken(this, ((Syntax.InternalSyntax.TypeFunctionDeclarationStatementSyntax)this.Green).typeKeyword, GetChildPosition(1), GetChildIndex(1));
+
+        /// <summary>The 'function' keyword.</summary>
+        public SyntaxToken FunctionKeyword => new SyntaxToken(this, ((Syntax.InternalSyntax.TypeFunctionDeclarationStatementSyntax)this.Green).functionKeyword, GetChildPosition(2), GetChildIndex(2));
+
+        /// <summary>Represents the type function's name.</summary>
+        public SyntaxToken Name => new SyntaxToken(this, ((Syntax.InternalSyntax.TypeFunctionDeclarationStatementSyntax)this.Green).name, GetChildPosition(3), GetChildIndex(3));
+
+        /// <summary>The parameter list.</summary>
+        public ParameterListSyntax Parameters => GetRed(ref this.parameters, 4)!;
+
+        /// <summary>The function's (optional) return type.</summary>
+        public TypeBindingSyntax? TypeBinding => GetRed(ref this.typeBinding, 5);
+
+        /// <summary>The function's body.</summary>
+        public StatementListSyntax Body => GetRed(ref this.body, 6)!;
+
+        /// <summary>The 'end' keyword.</summary>
+        public SyntaxToken EndKeyword => new SyntaxToken(this, ((Syntax.InternalSyntax.TypeFunctionDeclarationStatementSyntax)this.Green).endKeyword, GetChildPosition(7), GetChildIndex(7));
+
+        /// <summary>The semicolon at the end of the statement (if any).</summary>
+        public override SyntaxToken SemicolonToken
+        {
+            get
+            {
+                var slot = ((Syntax.InternalSyntax.TypeFunctionDeclarationStatementSyntax)this.Green).semicolonToken;
+                return slot != null ? new SyntaxToken(this, slot, GetChildPosition(8), GetChildIndex(8)) : default;
+            }
+        }
+
+        internal override SyntaxNode? GetNodeSlot(int index)
+            => index switch
+            {
+                4 => GetRed(ref this.parameters, 4)!,
+                5 => GetRed(ref this.typeBinding, 5),
+                6 => GetRed(ref this.body, 6)!,
+                _ => null,
+            };
+
+        internal override SyntaxNode? GetCachedSlot(int index)
+            => index switch
+            {
+                4 => this.parameters,
+                5 => this.typeBinding,
+                6 => this.body,
+                _ => null,
+            };
+
+        public override void Accept(LuaSyntaxVisitor visitor) => visitor.VisitTypeFunctionDeclarationStatement(this);
+        public override TResult? Accept<TResult>(LuaSyntaxVisitor<TResult> visitor) where TResult : default => visitor.VisitTypeFunctionDeclarationStatement(this);
+
+        public TypeFunctionDeclarationStatementSyntax Update(SyntaxToken exportKeyword, SyntaxToken typeKeyword, SyntaxToken functionKeyword, SyntaxToken name, ParameterListSyntax parameters, TypeBindingSyntax? typeBinding, StatementListSyntax body, SyntaxToken endKeyword, SyntaxToken semicolonToken)
+        {
+            if (exportKeyword != this.ExportKeyword || typeKeyword != this.TypeKeyword || functionKeyword != this.FunctionKeyword || name != this.Name || parameters != this.Parameters || typeBinding != this.TypeBinding || body != this.Body || endKeyword != this.EndKeyword || semicolonToken != this.SemicolonToken)
+            {
+                var newNode = SyntaxFactory.TypeFunctionDeclarationStatement(exportKeyword, typeKeyword, functionKeyword, name, parameters, typeBinding, body, endKeyword, semicolonToken);
+                var annotations = GetAnnotations();
+                return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode;
+            }
+
+            return this;
+        }
+
+        public TypeFunctionDeclarationStatementSyntax WithExportKeyword(SyntaxToken exportKeyword) => Update(exportKeyword, this.TypeKeyword, this.FunctionKeyword, this.Name, this.Parameters, this.TypeBinding, this.Body, this.EndKeyword, this.SemicolonToken);
+        public TypeFunctionDeclarationStatementSyntax WithTypeKeyword(SyntaxToken typeKeyword) => Update(this.ExportKeyword, typeKeyword, this.FunctionKeyword, this.Name, this.Parameters, this.TypeBinding, this.Body, this.EndKeyword, this.SemicolonToken);
+        public TypeFunctionDeclarationStatementSyntax WithFunctionKeyword(SyntaxToken functionKeyword) => Update(this.ExportKeyword, this.TypeKeyword, functionKeyword, this.Name, this.Parameters, this.TypeBinding, this.Body, this.EndKeyword, this.SemicolonToken);
+        public TypeFunctionDeclarationStatementSyntax WithName(SyntaxToken name) => Update(this.ExportKeyword, this.TypeKeyword, this.FunctionKeyword, name, this.Parameters, this.TypeBinding, this.Body, this.EndKeyword, this.SemicolonToken);
+        public TypeFunctionDeclarationStatementSyntax WithParameters(ParameterListSyntax parameters) => Update(this.ExportKeyword, this.TypeKeyword, this.FunctionKeyword, this.Name, parameters, this.TypeBinding, this.Body, this.EndKeyword, this.SemicolonToken);
+        public TypeFunctionDeclarationStatementSyntax WithTypeBinding(TypeBindingSyntax? typeBinding) => Update(this.ExportKeyword, this.TypeKeyword, this.FunctionKeyword, this.Name, this.Parameters, typeBinding, this.Body, this.EndKeyword, this.SemicolonToken);
+        public TypeFunctionDeclarationStatementSyntax WithBody(StatementListSyntax body) => Update(this.ExportKeyword, this.TypeKeyword, this.FunctionKeyword, this.Name, this.Parameters, this.TypeBinding, body, this.EndKeyword, this.SemicolonToken);
+        public TypeFunctionDeclarationStatementSyntax WithEndKeyword(SyntaxToken endKeyword) => Update(this.ExportKeyword, this.TypeKeyword, this.FunctionKeyword, this.Name, this.Parameters, this.TypeBinding, this.Body, endKeyword, this.SemicolonToken);
+        internal override StatementSyntax WithSemicolonTokenCore(SyntaxToken semicolonToken) => WithSemicolonToken(semicolonToken);
+        public new TypeFunctionDeclarationStatementSyntax WithSemicolonToken(SyntaxToken semicolonToken) => Update(this.ExportKeyword, this.TypeKeyword, this.FunctionKeyword, this.Name, this.Parameters, this.TypeBinding, this.Body, this.EndKeyword, semicolonToken);
+
+        public TypeFunctionDeclarationStatementSyntax AddParametersParameters(params ParameterSyntax[] items) => WithParameters(this.Parameters.WithParameters(this.Parameters.Parameters.AddRange(items)));
+        public TypeFunctionDeclarationStatementSyntax AddBodyStatements(params StatementSyntax[] items) => WithBody(this.Body.WithStatements(this.Body.Statements.AddRange(items)));
+    }
+
     /// <summary>The base node for type annotations</summary>
     public abstract partial class TypeSyntax : LuaSyntaxNode
     {