Merge branch 'main' into dev

Author: Tosoks67

Code/ArgumentSystem/Arguments/ValueArgument.cs

@@ -19,6 +19,6 @@ public DynamicTryGet<T> GetConvertSolution(BaseToken token)
             return $"Value '{token.RawRep}' cannot represent {InputDescription}";
         }
 
-        return new(() => get());
+        return new(get);
     }
 }

Code/ArgumentSystem/ProvidedArguments.cs

@@ -1,5 +1,6 @@
 using LabApi.Features.Wrappers;
 using SER.Code.ArgumentSystem.Arguments;
+using SER.Code.ArgumentSystem.BaseArguments;
 using SER.Code.ArgumentSystem.Structures;
 using SER.Code.FileSystem.Structures;
 using SER.Code.Helpers;
@@ -194,12 +195,12 @@ public CollectionVariable GetCollectionVariable(string argName)
     /// Retrieves a list of remaining arguments based on the specified argument name.
     /// The method resolves provided arguments into a typed list of values.
     /// </summary>
-    public TValue[] GetRemainingArguments<TValue, TArg>(string argName)
+    public TValue[] GetRemainingArguments<TValue, TArg>(string argName) where TArg : Argument
     {
         return GetEvaluators<TValue, TArg>(argName).Select(dtg => dtg.Invoke().Value!).ToArray();
     }
 
-    public TValue GetValue<TValue, TArg>(string argName)
+    public TValue GetValue<TValue, TArg>(string argName) where TArg : Argument
     {
         return GetEvaluators<TValue, TArg>(argName).First().Invoke().Value!;
     }
@@ -244,7 +245,7 @@ private List<DynamicTryGet> GetValueInternal<TValue, TArg>(string argName)
 
         if (foundArg.DefaultValue is null)
         {
-            throw new CustomScriptRuntimeError($"{method} is missing a required argument '{argName}'.");
+            throw new ScriptRuntimeError(method, $"Method is missing a required argument '{argName}'.");
         }
 
         return foundArg.DefaultValue.Value switch

Code/ContextSystem/Contexts/Control/ElifStatementContext.cs

@@ -7,7 +7,6 @@
 using SER.Code.Helpers.Extensions;
 using SER.Code.Helpers.ResultSystem;
 using SER.Code.TokenSystem.Tokens;
-using UnityEngine;
 
 namespace SER.Code.ContextSystem.Contexts.Control;
 

Code/ContextSystem/Contexts/MethodContext.cs

@@ -7,10 +7,14 @@
 using SER.Code.Helpers.Extensions;
 using SER.Code.Helpers.ResultSystem;
 using SER.Code.MethodSystem.BaseMethods;
+using SER.Code.MethodSystem.BaseMethods.Interfaces;
+using SER.Code.MethodSystem.BaseMethods.Synchronous;
+using SER.Code.MethodSystem.BaseMethods.Yielding;
 using SER.Code.Plugin;
 using SER.Code.TokenSystem.Tokens;
 using SER.Code.ValueSystem;
 using MethodToken = SER.Code.TokenSystem.Tokens.MethodToken;
+using ReturningMethod = SER.Code.MethodSystem.BaseMethods.Synchronous.ReturningMethod;
 
 namespace SER.Code.ContextSystem.Contexts;
 
@@ -20,7 +24,7 @@ public class MethodContext(MethodToken methodToken) : YieldingContext, IMayRetur
     public readonly MethodArgumentDispatcher Dispatcher = new(methodToken.Method);
     private int _providedArguments = 0;
 
-    public TypeOfValue? Returns => Method is ReturningMethod returningMethod 
+    public TypeOfValue? Returns => Method is IReturningMethod returningMethod 
         ? returningMethod.Returns 
         : null;
 
@@ -78,7 +82,7 @@ protected override IEnumerator<float> Execute()
                 break;
         }
 
-        ReturnedValue = Method is ReturningMethod returningMethod
+        ReturnedValue = Method is IReturningMethod returningMethod
             ? returningMethod.ReturnValue
             : null;
     }

Code/ContextSystem/Contexts/VariableDefinition/LiteralVariableDefinitionContext.cs

@@ -14,7 +14,7 @@ public LiteralVariableDefinitionContext(VariableToken<LiteralVariable, LiteralVa
         {
             if (token is TextToken textToken)
             {
-                return () => new TextValue(textToken.ParsedValue());
+                return () => textToken.Value;
             }
 
             return null;

Code/Examples/Example.cs

@@ -1,5 +1,4 @@
 using System.Reflection;
-using Cassie.Interpreters;
 using JetBrains.Annotations;
 using SER.Code.Helpers.ResultSystem;
 using SER.Code.ScriptSystem;

Code/Helpers/Extensions/SerExtensions.cs

@@ -48,7 +48,10 @@ public static bool CanReturn<T>(this IValueToken valToken, out Func<TryGet<T>> g
     {
         get = valToken.TryGet<T>;
 
+        // if unknown, its always assumed that it may return T
         if (!valToken.PossibleValues.AreKnown(out var knownReturnTypes)) return true;
+        
+        // if any of known types is assignable to T, or T to type, then it may return T
         return knownReturnTypes.Any(type => typeof(T).IsAssignableFrom(type) || type.IsAssignableFrom(typeof(T)));
     }
 

Code/MethodSystem/BaseMethods/Interfaces/IReferenceReturningMethod.cs

@@ -0,0 +1,11 @@
+namespace SER.Code.MethodSystem.BaseMethods.Interfaces;
+
+public interface IReferenceReturningMethod
+{
+    public Type ReturnType { get; }
+}
+
+public interface IReferenceReturningMethod<out T> : IReferenceReturningMethod
+{
+    public new T ReturnType { get; }
+}

Code/MethodSystem/BaseMethods/Interfaces/IReturningMethod.cs

@@ -0,0 +1,14 @@
+using SER.Code.ValueSystem;
+
+namespace SER.Code.MethodSystem.BaseMethods.Interfaces;
+
+public interface IReturningMethod
+{
+    public Value? ReturnValue { get; }
+    public abstract TypeOfValue Returns { get; }
+}
+
+public interface IReturningMethod<out T> : IReturningMethod where T : Value
+{
+    public new T ReturnValue { get; }
+}

Code/MethodSystem/BaseMethods/Method.cs

@@ -4,6 +4,8 @@
 using SER.Code.Helpers;
 using SER.Code.Helpers.Exceptions;
 using SER.Code.Helpers.Extensions;
+using SER.Code.MethodSystem.BaseMethods.Synchronous;
+using SER.Code.MethodSystem.BaseMethods.Yielding;
 using SER.Code.ScriptSystem;
 
 namespace SER.Code.MethodSystem.BaseMethods;