Merge remote-tracking branch 'origin/latest' into latest

Author: EvilBeaver

src/ScriptEngine/Machine/Contexts/ContextMethodMapper.cs

@@ -181,41 +181,43 @@ private static MethodInfo CreateMetadata(System.Reflection.MethodInfo target, Co
                 var paramDefs = new ParameterDefinition[argNum];
                 for (int i = 0; i < argNum; i++)
                 {
+                    var param = parameters[i];
+
                     var pd = new ParameterDefinition();
-                    if (parameters[i].GetCustomAttributes(typeof(ByRefAttribute), false).Length != 0)
+                    pd.RealType = param.ParameterType;
+
+                    if (param.GetCustomAttributes(typeof(ByRefAttribute), false).Length != 0)
                     {
-                        if (parameters[i].ParameterType != typeof(IVariable))
-                        {
+                        if (param.ParameterType != typeof(IVariable))
                             throw new InvalidOperationException("Attribute ByRef can be applied only on IVariable parameters");
-                        }
+
                         pd.IsByValue = false;
                     }
                     else
                     {
                         pd.IsByValue = true;
                     }
 
-                    if (parameters[i].IsOptional)
+                    if (param.HasDefaultValue)
                     {
                         pd.HasDefaultValue = true;
+                        pd.DefaultValue = ContextValuesMarshaller.ConvertParameterDefaultValue(param);
                         pd.DefaultValueIndex = ParameterDefinition.UNDEFINED_VALUE_INDEX;
                     }
 
                     paramDefs[i] = pd;
-
                 }
 
-                var scriptMethInfo = new ScriptEngine.Machine.MethodInfo();
-                scriptMethInfo.IsFunction = isFunc;
-                scriptMethInfo.IsExport = true;
-                scriptMethInfo.IsDeprecated = binding.IsDeprecated;
-                scriptMethInfo.ThrowOnUseDeprecated = binding.ThrowOnUse;
-                scriptMethInfo.Name = binding.GetName();
-                scriptMethInfo.Alias = binding.GetAlias(target.Name);
-
-                scriptMethInfo.Params = paramDefs;
-
-                return scriptMethInfo;
+                return new MethodInfo
+                {
+                    IsFunction = isFunc,
+                    IsExport = true,
+                    IsDeprecated = binding.IsDeprecated,
+                    ThrowOnUseDeprecated = binding.ThrowOnUse,
+                    Name = binding.GetName(),
+                    Alias = binding.GetAlias(target.Name),
+                    Params = paramDefs
+                };
             }
 
             private static ContextCallableDelegate<TInstance> CreateFunction(System.Reflection.MethodInfo target)

src/ScriptEngine/Machine/Contexts/ContextValuesMarshaller.cs

@@ -6,6 +6,7 @@ This Source Code Form is subject to the terms of the
 ----------------------------------------------------------*/
 using System;
 using System.Linq;
+using System.Reflection;
 using ScriptEngine.Machine.Values;
 
 namespace ScriptEngine.Machine.Contexts
@@ -208,6 +209,15 @@ public static T ConvertWrappedEnum<T>(IValue enumeration, T defValue) where T :
             throw RuntimeException.InvalidArgumentValue();
         }
 
+        public static IValue ConvertParameterDefaultValue(ParameterInfo paramInfo)
+        {
+            if (paramInfo.DefaultValue == null)
+                return null;
+
+            return ConvertReturnValue(paramInfo.DefaultValue, paramInfo.ParameterType);
+        }
+
+
         public static IValue ConvertDynamicValue(object param)
         {
             if (param == null)

src/ScriptEngine/Machine/Core.cs

@@ -217,7 +217,8 @@ public struct ParameterDefinition
 
         [NonSerialized]
         public IValue DefaultValue;
-        
+        public Type RealType;
+
         public int DefaultValueIndex;
         public AnnotationDefinition[] Annotations;
 

src/ScriptEngine/Machine/MachineInstance.cs

@@ -8,11 +8,14 @@ This Source Code Form is subject to the terms of the
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using OneScript.Language;
 using OneScript.Language.LexicalAnalysis;
 using ScriptEngine.Compiler;
 using ScriptEngine.Environment;
 using ScriptEngine.Machine.Values;
+using System.Reflection;
+//using System.Runtime.Remoting.Contexts;
 
 namespace ScriptEngine.Machine
 {
@@ -1005,29 +1008,33 @@ private bool MethodCallImpl(int arg, bool asFunc)
         private void CallContext(IRuntimeContextInstance instance, int index, ref MethodInfo methInfo, IValue[] argValues, bool asFunc)
         {
             IValue[] realArgs;
-            if (!instance.DynamicMethodSignatures)
+            if (instance.DynamicMethodSignatures)
+            {
+                realArgs = PrepareDynamicArgs(argValues);
+            }
+            else
             {
                 realArgs = new IValue[methInfo.ArgCount];
-                var skippedArg = ValueFactory.CreateInvalidValueMarker();
+                
                 int i = 0;
                 for (; i < argValues.Length; i++)
                 {
-                    realArgs[i] = argValues[i];
+                    realArgs[i] = PrepareArg(argValues[i], methInfo.Params[i], i);
                 }
+
+                // "Недостаточно параметров" - отсечено при компиляции
+                // все оставшиеся должны иметь дефолтное значение
                 for (; i < realArgs.Length; i++)
                 {
-                    realArgs[i] = skippedArg;
+                    realArgs[i] = methInfo.Params[i].DefaultValue;
                 }
             }
-            else
-            {
-                realArgs = argValues;
-            }
 
             if (asFunc)
             {
                 instance.CallAsFunction(index, realArgs, out IValue retVal);
                 _operationStack.Push(retVal);
+
             }
             else
             {
@@ -1036,6 +1043,52 @@ private void CallContext(IRuntimeContextInstance instance, int index, ref Method
             NextInstruction();
         }
 
+        private static IValue[] PrepareDynamicArgs(IValue[] factArgs)
+        {
+            var realArgs = new IValue[factArgs.Length];
+            for (int i = 0; i < factArgs.Length; i++)
+            {
+                var argValue = factArgs[i];
+                if (argValue.DataType != DataType.NotAValidValue)
+                {
+                    realArgs[i] = argValue;
+                }
+                // else null
+            }
+
+            return realArgs;
+        }
+
+        private static IValue PrepareArg(IValue argValue, ParameterDefinition paramDef, int index)
+        {
+            if (argValue.DataType == DataType.NotAValidValue)
+            {
+                if (paramDef.HasDefaultValue)
+                {
+                    return paramDef.DefaultValue;
+                }
+                else if (paramDef.RealType == typeof(string))
+                {
+                    return ValueFactory.Create(""); // Undefined.AsString()
+                }
+                else if (!typeof(IValue).IsAssignableFrom(paramDef.RealType))
+                {
+                    throw RuntimeException.MissedNthArgument(index+1);
+                }
+            }
+            else
+            {
+                if (paramDef.IsByValue)
+                    return argValue.GetRawValue();
+                else
+                {
+                    return argValue is IVariable ? argValue : Variable.Create(argValue, "");
+                }
+            }
+
+            return null;
+        }
+
         private void ArgNum(int arg)
         {
             _operationStack.Push(ValueFactory.Create(arg));
@@ -1060,8 +1113,9 @@ private void ResolveProp(int arg)
             var propName = _module.Constants[arg].AsString();
             var propNum = context.FindProperty(propName);
 
-            var propReference = Variable.CreateContextPropertyReference(context, propNum, "stackvar");
+            var propReference = Variable.CreateContextPropertyReference(context, propNum, propName);
             _operationStack.Push(propReference);
+
             NextInstruction();
         }
 
@@ -1110,15 +1164,7 @@ private void PrepareContextCallArguments(int arg, out IRuntimeContextInstance co
 
             if (context.DynamicMethodSignatures)
             {
-                argValues = new IValue[argCount];
-                for (int i = 0; i < argCount; i++)
-                {
-                    var argValue = factArgs[i];
-                    if (argValue.DataType != DataType.NotAValidValue)
-                    {
-                        argValues[i] = argValue;
-                    }
-                }
+                argValues = PrepareDynamicArgs(factArgs);
             }
             else
             {
@@ -1132,23 +1178,15 @@ private void PrepareContextCallArguments(int arg, out IRuntimeContextInstance co
                 int i = 0;
                 for (; i < argCount; i++)
                 {
-                    var argValue = factArgs[i];
-                    if (argValue.DataType != DataType.NotAValidValue)
-                    {
-                        if (methodParams[i].IsByValue)
-                            argValues[i] = argValue.GetRawValue();
-                        else
-                        {
-                            argValues[i] = argValue is IVariable ? argValue : Variable.Create(argValue, "");
-                        }
-                    }
-                    else if (!methodParams[i].HasDefaultValue)
-                        throw RuntimeException.MissedArgument();
+                    argValues[i] = PrepareArg(factArgs[i], methodParams[i], i);
                 }
+
                 for (; i < methodParams.Length; i++)
                 {
                     if (!methodParams[i].HasDefaultValue)
                         throw RuntimeException.TooFewArgumentsPassed();
+
+                    argValues[i] = methodParams[i].DefaultValue;
                 }
             }
         }
@@ -1534,7 +1572,7 @@ private void ExitTry(int arg)
             NextInstruction();
         }
 
-        #endregion
+#endregion
 
         #region Built-in functions
 
@@ -2470,7 +2508,7 @@ private void NewFunc(int argCount)
 
         #endregion
 
-        #endregion
+#endregion
 
         private LoadedModule CompileExpressionModule(string expression)
         {

src/ScriptEngine/Machine/RuntimeExceptions.cs

@@ -46,19 +46,19 @@ public static RuntimeException DeprecatedMethodCall(string name)
 
         public static RuntimeException ConvertToNumberException()
         {
-            return new RuntimeException("Преобразование к типу 'Число' не поддерживается");
+            return new TypeConvertionException("Число");
         }
 
         public static RuntimeException ConvertToBooleanException()
         {
-            return new RuntimeException("Преобразование к типу 'Булево' не поддерживается");
+            return new TypeConvertionException("Булево");
         }
 
         public static RuntimeException ConvertToDateException()
         {
-            return new RuntimeException("Преобразование к типу 'Дата' не поддерживается");
+            return new TypeConvertionException("Дата");
         }
-
+  
         public static RuntimeException PropIsNotReadableException(string prop)
         {
             return PropertyAccessException.GetPropIsNotReadableException(prop);
@@ -104,6 +104,11 @@ public static RuntimeException MissedArgument()
             return new RuntimeException("Пропущен обязательный параметр");
         }
 
+        public static RuntimeException MissedNthArgument(int argNum)
+        {
+            return new RuntimeException($"Пропущен обязательный параметр номер {argNum}" );
+        }
+
         public static RuntimeException InvalidArgumentType()
         {
             return new RuntimeException("Неверный тип аргумента");
@@ -214,6 +219,14 @@ public ScriptInterruptionException(int exitCode) : base("Script interrupted")
         public int ExitCode { get; private set; }
     }
 
+    public class TypeConvertionException : RuntimeException
+    {
+        public TypeConvertionException(string typename) 
+            : base($"Преобразование к типу '{typename}' не поддерживается")
+        {
+        }
+    }
+
     public class ValueMarshallingException : RuntimeException
     {
         public ValueMarshallingException() : this("Неклассифицированная ошибка маршаллинга значений")