Почти все тесты по нативу зеленые

Author: EvilBeaver

src/OneScript.Native/Compiler/ExpressionHelpers.cs

@@ -730,10 +730,31 @@ private static bool IsModuleVariable(Expression counterVar)
 
         public static Expression CallContextMethod(Expression target, string name, ParameterExpression processParameter,
             IEnumerable<Expression> arguments)
+        {
+            return CallContextMethodInternal(
+                nameof(DynamicOperations.CallContextMethod), target, name, processParameter, arguments);
+        }
+        
+        public static Expression TryCallContextMethod(
+            Expression target,
+            string name,
+            ParameterExpression processParameter,
+            IEnumerable<Expression> arguments)
+        {
+            return CallContextMethodInternal(
+                nameof(DynamicOperations.TryCallContextMethod), target, name, processParameter, arguments);
+        }
+        
+        private static Expression CallContextMethodInternal(
+            string implementationName,
+            Expression target,
+            string name,
+            ParameterExpression processParameter,
+            IEnumerable<Expression> arguments)
         {
             var methodInfo = OperationsCache.GetOrAdd(
                 typeof(DynamicOperations),
-                nameof(DynamicOperations.CallContextMethod)
+                implementationName
             );
 
             var argExpressions = new List<Expression>

src/OneScript.Native/Compiler/MethodCompiler.cs

@@ -1101,11 +1101,23 @@ protected override void VisitObjectProcedureCall(BslSyntaxNode node)
             if (targetType.IsObjectValue())
             {
                 var methodInfo = FindMethodOfType(node, targetType, name);
-                var args = PrepareCallArguments(call.ArgumentList, methodInfo.GetParameters());
+                var args = PrepareCallArguments(call.ArgumentList, methodInfo.GetParameters(), methodInfo is ContextMethodInfo { InjectsProcess: true });
 
                 _blocks.Add(Expression.Call(target, methodInfo, args));
             }
-            else if (targetType.IsValue() || target is DynamicExpression)
+            else if (targetType.IsContext())
+            {
+                var contextCall = ExpressionHelpers.CallContextMethod(target, name, _processParameter,
+                    PrepareDynamicCallArguments(call.ArgumentList));
+                _blocks.Add(contextCall);
+            }
+            else if (targetType.IsValue())
+            {
+                var contextCall = ExpressionHelpers.TryCallContextMethod(target, name, _processParameter,
+                    PrepareDynamicCallArguments(call.ArgumentList));
+                _blocks.Add(contextCall);
+            }
+            else if (target is DynamicExpression)
             {
                 var args = new List<Expression>();
                 args.Add(target);
@@ -1156,14 +1168,20 @@ protected override void VisitObjectFunctionCall(BslSyntaxNode node)
                         $"Method {targetType}.{name} is not a function"), ToCodePosition(node.Location));
                 }
 
-                var args = PrepareCallArguments(call.ArgumentList, methodInfo.GetParameters());
+                var args = PrepareCallArguments(call.ArgumentList, methodInfo.GetParameters(), methodInfo is ContextMethodInfo { InjectsProcess: true });
                 _statementBuildParts.Push(Expression.Call(target, methodInfo, args));
             }
             else if (targetType.IsContext())
             {
                 _statementBuildParts.Push(ExpressionHelpers.CallContextMethod(target, name, _processParameter, PrepareDynamicCallArguments(call.ArgumentList)));
             }
-            else if (targetType.IsValue() || target is DynamicExpression)
+            else if (targetType.IsValue())
+            {
+                var contextCall = ExpressionHelpers.TryCallContextMethod(target, name, _processParameter,
+                    PrepareDynamicCallArguments(call.ArgumentList));
+                _statementBuildParts.Push(contextCall);
+            }
+            else if (target is DynamicExpression)
             {
                 var args = new List<Expression>();
                 args.Add(target);
@@ -1247,7 +1265,7 @@ private Expression CreateMethodCall(CallNode node)
             }
 
             var symbol = Symbols.GetScope(binding.ScopeNumber).Methods[binding.MemberNumber];
-            var args = PrepareCallArguments(node.ArgumentList, symbol.Method.GetParameters());
+            var args = PrepareCallArguments(node.ArgumentList, symbol.Method.GetParameters(), symbol.Method is ContextMethodInfo { InjectsProcess: true });
 
             var methodInfo = symbol.Method;
             if (methodInfo is ContextMethodInfo contextMethod)
@@ -1316,7 +1334,7 @@ private Expression CreateBuiltInFunctionCall(CallNode node)
                     var method = _builtInFunctions.GetMethod(methodName);
                     var declaredParameters = method.GetParameters();
 
-                    var args = PrepareCallArguments(node.ArgumentList, declaredParameters);
+                    var args = PrepareCallArguments(node.ArgumentList, declaredParameters, false);
 
                     result = Expression.Call(method, args);
                     break;
@@ -1385,7 +1403,7 @@ private Expression DirectConversionCall(CallNode node, Type type)
                 type);
         }
 
-        private List<Expression> PrepareCallArguments(BslSyntaxNode argList, ParameterInfo[] declaredParameters)
+        private List<Expression> PrepareCallArguments(BslSyntaxNode argList, ParameterInfo[] declaredParameters, bool injectsProcess)
         {
             var factArguments = new List<Expression>();
 
@@ -1395,7 +1413,8 @@ private List<Expression> PrepareCallArguments(BslSyntaxNode argList, ParameterIn
                     : null).ToArray();
 
             var parametersToProcess = declaredParameters.Length;
-            for (int i = 0; i < parameters.Length; i++)
+            var declStart = injectsProcess ? 1 : 0;
+            for (int i = 0, decl = declStart; i < parameters.Length; i++, decl++)
             {
                 if (parametersToProcess == 0)
                 {
@@ -1405,7 +1424,7 @@ private List<Expression> PrepareCallArguments(BslSyntaxNode argList, ParameterIn
                 }
 
                 var passedArg = parameters[i];
-                var declaredParam = declaredParameters[i];
+                var declaredParam = declaredParameters[decl];
 
                 if (declaredParam.GetCustomAttribute<ParamArrayAttribute>() != null)
                 {
@@ -1448,7 +1467,7 @@ private List<Expression> PrepareCallArguments(BslSyntaxNode argList, ParameterIn
 
             if (parametersToProcess > 0)
             {
-                foreach (var declaredParam in declaredParameters.Skip(parameters.Length))
+                foreach (var declaredParam in declaredParameters.Skip(parameters.Length + declStart))
                 {
                     if (declaredParam.HasDefaultValue)
                     {

src/OneScript.Native/Runtime/DynamicOperations.cs

@@ -205,10 +205,33 @@ public static BslValue GetPropertyValue(object target, string propertyName)
             return (BslValue)context.GetPropValue(propIndex);
         }
 
+        public static BslValue TryCallContextMethod(BslValue instance, string methodName, IBslProcess process, BslValue[] arguments)
+        {
+            if (!(instance is IRuntimeContextInstance context))
+                throw BslExceptions.ValueIsNotObjectException();
+
+            return CallContextMethod(context, methodName, process, arguments);
+        }
+        
         public static BslValue CallContextMethod(IRuntimeContextInstance instance, string methodName, IBslProcess process, BslValue[] arguments)
         {
             var idx = instance.GetMethodNumber(methodName);
-            instance.CallAsFunction(idx, arguments, out var result, process);
+            
+            var parameters = instance.GetMethodInfo(idx).GetParameters();
+            
+            if (arguments.Length > parameters.Length)
+                throw RuntimeException.TooManyArgumentsPassed();
+
+            var valueArgs = new IValue[parameters.Length];
+            for (int i = 0; i < valueArgs.Length; i++)
+            {
+                if (i < arguments.Length)
+                    valueArgs[i] = arguments[i];
+                else
+                    valueArgs[i] = BslSkippedParameterValue.Instance;
+            }
+            
+            instance.CallAsFunction(idx, valueArgs, out var result, process);
             return (BslValue)result;
         }
     }