Upsilon/Upsilon/Binder/Binder.cs

using System;
using System.Runtime.InteropServices;
using Upsilon.BaseTypes.Number;
using Upsilon.Parser;
using Type = Upsilon.BaseTypes.Type;

namespace Upsilon.Binder
{
    public class Binder
    {
        private readonly Diagnostics _diagnostics;
        private BoundScope _scope;

        public Binder(BoundScope parentScope, Diagnostics diagnostics)
        {
            _diagnostics = diagnostics;
            _scope = new BoundScope(parentScope);
        }

        public BoundScript BindScript(ScriptSyntax e)
        {
            var bound = BindExpression(e.Statement);
            return new BoundScript(bound);
        }

        public BoundExpression BindExpression(ExpressionSyntax e)
        {
            switch (e.Kind)
            {
                case SyntaxKind.UnaryExpression:
                    break;
                case SyntaxKind.BinaryExpression:
                    return BindBinaryExpression((BinaryExpressionSyntax) e);
                case SyntaxKind.LiteralExpression:
                    return BindLiteralExpression((LiteralExpressionSyntax) e);
                case SyntaxKind.ParenthesizedExpression:
                    break;
                case SyntaxKind.AssignmentExpression:
                    break;
                case SyntaxKind.VariableExpression:
                    break;
                case SyntaxKind.BadExpression:
                    break;
                case SyntaxKind.ScriptUnit:
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
            throw new NotImplementedException(e.Kind.ToString());
        }

        private BoundExpression BindBinaryExpression(BinaryExpressionSyntax e)
        {
            var left = BindExpression(e.Left);
            var right = BindExpression(e.Right);
            var op = BoundBinaryOperator.BindBinaryOperator(e.Operator.Kind, left.Type, right.Type);
            if (op == null)
            {
                _diagnostics.LogUnknownOperator(e.Span, e.Operator.Kind, left.Type, right.Type);
                return left;
            }
            return new BoundBinaryExpression(op, left, right, op.OutType);
        }

        private BoundExpression BindLiteralExpression(LiteralExpressionSyntax e)
        {
            var value = e.Value;
            var type = Type.Nil;
            object outValue = null;
            switch (value)
            {
                case double d:
                    type     = Type.Number;
                    outValue = new NumberDouble(d);
                    break;
                case long l:
                    type     = Type.Number;
                    outValue = new NumberLong(l);
                    break;
                case bool b:
                    type = Type.Boolean;
                    outValue = value;
                    break;
                default:
                    _diagnostics.LogUnknownType(e.Span);
                    break;
            }
            return new BoundLiteralExpression(outValue, type);
        }
    }
}