update MethodExperssion PlayerExperssion and Parentheses tokens

Author: Elektryk-Andrzej

Code/TokenSystem/Tokens/ExpressionTokens/MethodExpressionToken.cs

@@ -1,5 +1,6 @@
 using SER.Code.ContextSystem;
 using SER.Code.Exceptions;
+using SER.Code.Helpers;
 using SER.Code.Helpers.ResultSystem;
 using SER.Code.MethodSystem.BaseMethods.Synchronous;
 using SER.Code.MethodSystem.BaseMethods.Yielding;
@@ -9,10 +10,10 @@ namespace SER.Code.TokenSystem.Tokens.ExpressionTokens;
 
 public class MethodExpressionToken : ExpressionToken
 {
-    private ReturningMethod? _method = null!;
+    private Safe<ReturningMethod> _method;
 
     //public override TypeOfValue PossibleValues => new UnknownTypeOfValue();
-    public override TypeOfValue PossibleValues => _method!.Returns;
+    public override TypeOfValue PossibleValues => _method.Value.Returns;
 
     protected override IParseResult InternalParse(BaseToken[] tokens)
     {
@@ -42,9 +43,7 @@ protected override IParseResult InternalParse(BaseToken[] tokens)
 
     public override TryGet<Value> Value()
     {
-        if (_method is null) throw new AndrzejFuckedUpException();
-        
-        _method.Execute();
-        return _method.ReturnValue ?? throw new AndrzejFuckedUpException();
+        _method.Value.Execute();
+        return _method.Value.ReturnValue ?? throw new AndrzejFuckedUpException();
     }
 }

Code/TokenSystem/Tokens/ExpressionTokens/PlayerExpressionToken.cs

@@ -182,6 +182,7 @@ public class Info<T>(Func<Player, T> handler, string? description) : Info
 
     protected override IParseResult InternalParse(BaseToken[] tokens)
     {
+        var rs = $"{RawRep} expression is invalid".AsError();
         if (tokens.First() is not PlayerVariableToken pvarToken)
         {
             return new Ignore();
@@ -192,16 +193,17 @@ protected override IParseResult InternalParse(BaseToken[] tokens)
         switch (tokens.Length)
         {
             case < 2:
-                return new Error("A player expression expects to have an argument, but none was provided.");
+                return new Error(rs + "A player expression expects to have an argument, " +
+                                 "but none was provided.");
             case > 2:
-                return new Error(
-                    $"A player expression expects to have only one argument, but {tokens.Length - 1} were provided.");
+                return new Error(rs + "A player expression expects to have only one argument, " +
+                                 $"but {tokens.Length - 1} were provided.");
         }
 
         if (EnumArgument<PlayerProperty>.Convert(tokens.Last(), Script)
             .HasErrored(out var error, out var property))
         {
-            return new Error(error);
+            return new Error(rs + error);
         }
 
         _property = property;

Code/TokenSystem/Tokens/ParenthesesToken.cs

@@ -1,4 +1,4 @@
-using SER.Code.Exceptions;
+using SER.Code.Extensions;
 using SER.Code.Helpers;
 using SER.Code.Helpers.ResultSystem;
 using SER.Code.ScriptSystem;
@@ -11,51 +11,35 @@ namespace SER.Code.TokenSystem.Tokens;
 
 public class ParenthesesToken : BaseToken, IValueToken
 {
-    private BaseToken[]? _tokens = null;
+    public TypeOfValue PossibleValues => typeof(LiteralValue);
+    
+    public bool IsConstant => false;
+    
+    public BaseToken[] Tokens { get; private set; } = [];
 
     public string RawContent { get; private set; } = null!;
-    
-    public TryGet<BaseToken[]> TryGetTokens()
-    {
-        if (_tokens is not null)
-        {
-            return _tokens;
-        }
 
-        if (Slice is null)
+    protected override IParseResult InternalParse(Script scr)
+    {
+        if (Slice is not CollectionSlice { Type: CollectionBrackets.Round } slice)
         {
-            throw new AndrzejFuckedUpException();
+            return new Ignore();
         }
 
-        Result error = $"Failed to get underlying tokens in the '{Slice.RawRep}' parentheses.";
+        RawContent = slice.Value;
         if (Tokenizer.TokenizeLine(Slice.Value, Script, LineNum)
             .HasErrored(out var tokenizeError, out var tokens))
         {
-            return error + tokenizeError;
-        }
-
-        return _tokens = tokens.ToArray();
-    }
-
-    protected override IParseResult InternalParse(Script scr)
-    {
-        if (Slice is CollectionSlice { Type: CollectionBrackets.Round } slice)
-        {
-            RawContent = slice.Value;
-            return new Success();
+            return new Error($"In parentheses {RawRep}".AsError() + tokenizeError.AsError());
         }
 
-        return new Ignore();
+        Tokens = tokens;
+        return new Success();
     }
 
     public TryGet<object> ParseExpression()
     {
-        if (TryGetTokens().HasErrored(out var error, out var tokens))
-        {
-            return error;
-        }
-
-        if (NumericExpressionReslover.CompileExpression(tokens).HasErrored(out var error2, out var expression))
+        if (NumericExpressionReslover.CompileExpression(Tokens).HasErrored(out var error2, out var expression))
         {
             return error2;
         }
@@ -77,7 +61,4 @@ public TryGet<Value> Value()
 
         return literalValue;
     }
-
-    public TypeOfValue PossibleValues => new TypeOfValue<LiteralValue>();
-    public bool IsConstant => false;
 }

Code/ValueSystem/TypeOfValue.cs

@@ -18,6 +18,8 @@ protected TypeOfValue(Type? required)
     public bool AreKnown(out Type[] known) => (known = Required!) is not null;
 
     public abstract override string ToString();
+    
+    public static implicit operator TypeOfValue(Type type) => new SingleTypeOfValue(type);
 }
 
 public class TypesOfValue : TypeOfValue