Adds basics for predefined function parameter types

Upsilon/Binder/Binder.cs

@@ -4,6 +4,7 @@ using System.Collections.Immutable;
 using System.Linq;
 using Upsilon.BaseTypes;
 using Upsilon.BaseTypes.Number;
+using Upsilon.BoundTypes;
 using Upsilon.Parser;
 using Type = Upsilon.BaseTypes.Type;
 
@@ -421,12 +422,19 @@ namespace Upsilon.Binder
             var parameters = ImmutableArray.CreateBuilder<BoundVariableSymbol>();
             foreach (var identifierToken in e.Parameters)
             {
-                var vari = new VariableSymbol(identifierToken.Name, Type.Unknown, true);
+                var variable = identifierToken;
+                var scriptType = Type.Unknown;
+                if (variable.TypeName != null)
+                {
+                    var type = BoundTypeHandler.GetTypeDefinition(variable.TypeName.Name);
+                    scriptType = type.ScriptType;
+                }
+                var vari = new VariableSymbol(variable.IdentifierName.Name, scriptType, true);
                 parameters.Add(new BoundVariableSymbol(vari, identifierToken.Span));
                 innerScope.DefineLocalVariable(vari);
             }
 
-            if (parameters.Count == 0)
+            if (parameters.All(x => x.Type != Type.Unknown))
             {
                 Scope = innerScope;
                 var block = BindBlockStatement(e.Block);

Upsilon/BoundTypes/BoundTypeHandler.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+using Upsilon.BaseTypes;
+
+namespace Upsilon.BoundTypes
+{
+    public static class BoundTypeHandler
+    {
+        private static Dictionary<string, BoundTypeDefinition> _typeDefinitions = new Dictionary<string, BoundTypeDefinition>
+        {
+            {"string", new BoundTypeDefinition(Type.String, typeof(string))},
+            {
+                "number",
+                new BoundTypeDefinition(Type.Number,
+                    new[] {typeof(int), typeof(long), typeof(float), typeof(double)})
+            },
+            {"bool", new BoundTypeDefinition(Type.Boolean, typeof(bool))}
+        };
+
+        public static BoundTypeDefinition GetTypeDefinition(string key)
+        {
+            return _typeDefinitions[key.ToLowerInvariant()];
+        }
+    }
+
+    public class BoundTypeDefinition
+    {
+        public BoundTypeDefinition(Type scriptType, System.Type[] validInternalTypes)
+        {
+            ScriptType = scriptType;
+            ValidInternalTypes = validInternalTypes;
+        }
+
+        public BoundTypeDefinition(Type scriptType, System.Type validInternalType)
+        {
+            ScriptType = scriptType;
+            ValidInternalTypes = new []{validInternalType};
+        }
+
+        public Type ScriptType { get; }
+        public System.Type[] ValidInternalTypes { get; }
+    }
+}

Upsilon/Parser/ExpressionSyntax/FunctionExpressionSyntax.cs

@@ -8,13 +8,13 @@ namespace Upsilon.Parser
     {
         public SyntaxToken FunctionToken { get; }
         public SyntaxToken OpenParenthesis { get; }
-        public ImmutableArray<IdentifierToken> Parameters { get; }
+        public ImmutableArray<ParameterToken> Parameters { get; }
         public SyntaxToken CloseParenthesis { get; }
         public BlockStatementSyntax Block { get; }
         public SyntaxToken EndToken { get; }
 
         public FunctionExpressionSyntax(SyntaxToken functionToken,
-            SyntaxToken openParenthesis, ImmutableArray<IdentifierToken> parameters, SyntaxToken closeParenthesis,
+            SyntaxToken openParenthesis, ImmutableArray<ParameterToken> parameters, SyntaxToken closeParenthesis,
             BlockStatementSyntax block, SyntaxToken endToken)
         {
             FunctionToken = functionToken;

Upsilon/Parser/ParameterToken.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+
+namespace Upsilon.Parser
+{
+    public class ParameterToken : SyntaxNode
+    {
+        public ParameterToken(IdentifierToken typeName, IdentifierToken identifierName)
+        {
+            IdentifierName = identifierName;
+            TypeName = typeName;
+        }
+
+        public IdentifierToken IdentifierName { get; }
+        public IdentifierToken TypeName { get; }
+
+        public override SyntaxKind Kind => SyntaxKind.Parameter;
+        public override IEnumerable<SyntaxNode> ChildNodes()
+        {
+            yield return TypeName;
+            yield return IdentifierName;
+        }
+    }
+}

Upsilon/Parser/Parser.cs

@@ -204,7 +204,7 @@ namespace Upsilon.Parser
         {
             var functionToken = MatchToken(SyntaxKind.FunctionKeyword);
             var openParenthesis = MatchToken(SyntaxKind.OpenParenthesis);
-            var variableBuilder = ImmutableArray.CreateBuilder<IdentifierToken>();
+            var variableBuilder = ImmutableArray.CreateBuilder<ParameterToken>();
             SyntaxToken current = null;
             while (Current.Kind != SyntaxKind.CloseParenthesis)
             {
@@ -213,8 +213,16 @@ namespace Upsilon.Parser
                     break;
                 }
                 current = Current;
-                var variableIdentifier = (IdentifierToken)MatchToken(SyntaxKind.Identifier);
+                var firstToken = MatchToken(SyntaxKind.Identifier);
-                variableBuilder.Add(variableIdentifier);
+                if (Current.Kind == SyntaxKind.Identifier)
+                {
+                    variableBuilder.Add(new ParameterToken((IdentifierToken) firstToken,
+                        (IdentifierToken) NextToken()));
+                }
+                else
+                {
+                    variableBuilder.Add(new ParameterToken(null, (IdentifierToken) firstToken));
+                }
                 if (Current.Kind == SyntaxKind.Comma)
                     NextToken();
             }
@@ -241,17 +249,19 @@ namespace Upsilon.Parser
             }
             var identifier      = MatchToken(SyntaxKind.Identifier);
             var openParenthesis = MatchToken(SyntaxKind.OpenParenthesis);
-            var variableBuilder = ImmutableArray.CreateBuilder<IdentifierToken>();
+            var variableBuilder = ImmutableArray.CreateBuilder<ParameterToken>();
-            IdentifierToken lastIdentifier = null;
             while (Current.Kind != SyntaxKind.CloseParenthesis || Current.Kind == SyntaxKind.EndOfFile)
             {
-                var variableIdentifier =(IdentifierToken) MatchToken(SyntaxKind.Identifier);
+                var firstToken = MatchToken(SyntaxKind.Identifier);
-                if (lastIdentifier == variableIdentifier)
+                if (Current.Kind == SyntaxKind.Identifier)
                 {
-                    break;
+                    variableBuilder.Add(new ParameterToken((IdentifierToken) firstToken,
+                        (IdentifierToken) NextToken()));
+                }
+                else
+                {
+                    variableBuilder.Add(new ParameterToken(null, (IdentifierToken) firstToken));
                 }
-                lastIdentifier = variableIdentifier;
-                variableBuilder.Add( variableIdentifier);
                 if (Current.Kind == SyntaxKind.Comma)
                     NextToken();
             }

Upsilon/Parser/SyntaxKind.cs

@@ -51,6 +51,7 @@ namespace Upsilon.Parser
         BreakKeyword,
 
         Identifier,
+        Parameter,
 
         // Expressions
         UnaryExpression,