Upsilon/Upsilon/StandardLibraries/StaticScope.cs

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Upsilon.BaseTypes;
using Upsilon.BaseTypes.Number;
using Upsilon.BaseTypes.ScriptTypeInterfaces;
using Upsilon.Binder;
using Upsilon.Binder.VariableSymbols;
using Upsilon.BoundTypes;
using Upsilon.Evaluator;
using Type = Upsilon.BaseTypes.Type;

namespace Upsilon.StandardLibraries
{
    public static class StaticScope
    {
        private static EvaluationScope _staticScope;
        private static BoundScope _staticBoundScope;

        public static EvaluationScope Scope
        {
            get
            {
                if (_staticScope != null)
                    return _staticScope;

                var (evaluationScope, boundScope) = CreateStandardLibrary();
                _staticScope                      = evaluationScope;
                _staticBoundScope                 = boundScope;
                return _staticScope;
            }
        }

        public static BoundScope BoundScope
        {
            get
            {
                if (_staticBoundScope != null)
                    return _staticBoundScope;

                var (evaluationScope, boundScope) = CreateStandardLibrary();
                _staticScope                      = evaluationScope;
                _staticBoundScope                 = boundScope;
                return _staticBoundScope;
            }
        }

        public static (EvaluationScope, BoundScope) CreateStandardLibrary()
        {
            var basicFunctions = new BasicFunctions().LoadMethods();
            var funcs = new Dictionary<string, ScriptType>();
            var boundFuncs = new Dictionary<string, VariableSymbol>();
            foreach (var func in basicFunctions)
            {
                funcs.Add(func.Key, func.Value.MethodInfoFunction);
                var functionSymbol = new InternalFunctionVariableSymbol(func.Key, true,
                    func.Value.MethodInfoFunction.ReturnType.GetScriptType(),
                    func.Value.MethodInfoFunction.GetParameterInfo().Select(typeInfo =>
                    {
                        var derivedType = DeriveValidTypes(typeInfo.Type);
                        return new InternalFunctionVariableSymbol.InternalFunctionParameter(derivedType,
                            typeInfo.IsOptional);
                    }).ToArray())
                {
                    CommentValue = func.Value.CommentValue?.Split('\n')
                };
                boundFuncs.Add(func.Key, functionSymbol);
            }
            var scope = new EvaluationScope(funcs);
            var boundScope = new BoundScope(boundFuncs, null);
            return (scope, boundScope);
        }

        public static void RegisterStaticVariable(string name, object value)
        {
            var luaVariable = value.ToScriptType();
            var ubDef = BoundTypeHandler.GetTypeDefinition(value.GetType());
            VariableSymbol varSymbol = null;
            if (ubDef != null)
            {
                varSymbol = new FunctionParameterSymbol(name, ubDef);
            }
            else
            {
                var type = value.GetType();
                if (type.IsGenericType)
                {
                    var generic = type.GetGenericTypeDefinition();
                    if (generic.FullName != null && generic.FullName.StartsWith("System.Func"))
                    {
                        varSymbol = BuildFunctionVariableSymbol(name, type);
                    }
                    else if (generic.FullName != null && generic.FullName.StartsWith("System.Action"))
                    {
                        varSymbol = BuildActionVariableSymbol(name, type);
                    }
                }
                if (varSymbol == null)
                    throw new Exception("Unknown type: " + type);

            }
            BoundScope.AssignToNearest(varSymbol);
            Scope.AssignToNearest(varSymbol, luaVariable);
        }

        private static VariableSymbol BuildFunctionVariableSymbol(string name, System.Type type)
        {
            var genericParameters = type.GetGenericArguments();
            var parameters        = new List<InternalFunctionVariableSymbol.InternalFunctionParameter>();
            for (var i = 0; i < genericParameters.Length - 1; i++)
            {
                var t = genericParameters[i].GetScriptType();
                parameters.Add(new InternalFunctionVariableSymbol.InternalFunctionParameter(t, false));
            }

            var result = genericParameters[parameters.Count - 1].GetScriptType();
            return new InternalFunctionVariableSymbol(name, true, result, parameters.ToArray());
        }

        private static VariableSymbol BuildActionVariableSymbol(string name, System.Type type)
        {
            var genericParameters = type.GetGenericArguments();
            var parameters        = new List<InternalFunctionVariableSymbol.InternalFunctionParameter>();
            for (var i = 0; i < genericParameters.Length; i++)
            {
                var t = genericParameters[i].GetScriptType();
                parameters.Add(new InternalFunctionVariableSymbol.InternalFunctionParameter(t, false));
            }
            return new InternalFunctionVariableSymbol(name, true, Type.Nil, parameters.ToArray());
        }

        private static Type DeriveValidTypes(System.Type type)
        {
            if (type == typeof(ScriptString))
                return Type.String;
            if (typeof(ScriptNumber).IsAssignableFrom(type))
                return Type.Number;
            if (type == typeof(ScriptBoolean))
                return Type.Boolean;
            if (type == typeof(IIterable))
                return Type.Table | Type.UserData;
            if (typeof(ScriptTable).IsAssignableFrom(type))
                return Type.Table;
            if (type == typeof(ScriptType))
                // allows every type
                return (Type) 255;
            if (type.IsEnum)
                return Type.Number;
            return Type.UserData;
        }
    }
}