update

Elektryk-Andrzej · Elektryk-Andrzej · commit 7c3bb8a40c1a · 2026-03-29T13:16:30.000+02:00
diff --git a/Code/ContextSystem/BaseContexts/Context.cs b/Code/ContextSystem/BaseContexts/Context.cs
@@ -9,7 +9,7 @@ public abstract class Context
 {
     public required Script Script { get; set; } = null!;
 
-    protected abstract string FriendlyName { get; }
+    public abstract string FriendlyName { get; }
 
     public abstract TryAddTokenRes TryAddToken(BaseToken token);
 
diff --git a/Code/ContextSystem/BaseContexts/LoopContext.cs b/Code/ContextSystem/BaseContexts/LoopContext.cs
@@ -26,7 +26,7 @@ public abstract class LoopContext : StatementContext, IExtendableStatement, IKey
     protected bool ReceivedContinue;
     protected bool ReceivedBreak;
 
-    protected sealed override string FriendlyName => $"'{KeywordName}' loop statement";
+    public sealed override string FriendlyName => $"'{KeywordName}' loop statement";
 
     protected override void OnReceivedControlMessageFromChild(ParentContextControlMessage msg)
     {
diff --git a/Code/ContextSystem/Contexts/Control/AttemptStatement.cs b/Code/ContextSystem/Contexts/Control/AttemptStatement.cs
@@ -28,7 +28,7 @@ public class AttemptStatement : StatementContext, IExtendableStatement, IKeyword
 
     public IExtendableStatement.Signal AllowedSignals => IExtendableStatement.Signal.ThrewException;
     public Dictionary<IExtendableStatement.Signal, StatementContext> RegisteredSignals { get; } = [];
-    protected override string FriendlyName => "'attempt' statement";
+    public override string FriendlyName => "'attempt' statement";
 
     private Exception? _exception;
     
diff --git a/Code/ContextSystem/Contexts/Control/ElifStatement.cs b/Code/ContextSystem/Contexts/Control/ElifStatement.cs
@@ -31,7 +31,7 @@ public class ElifStatement : StatementContext, IStatementExtender, IExtendableSt
     
     private NumericExpressionReslover.CompiledExpression _expression;
 
-    protected override string FriendlyName => "'elif' statement";
+    public override string FriendlyName => "'elif' statement";
 
     public override TryAddTokenRes TryAddToken(BaseToken token)
     {
diff --git a/Code/ContextSystem/Contexts/Control/ElseStatement.cs b/Code/ContextSystem/Contexts/Control/ElseStatement.cs
@@ -21,7 +21,7 @@ public class ElseStatement : StatementContext, IStatementExtender, IKeywordConte
 
     public IExtendableStatement.Signal Extends => IExtendableStatement.Signal.DidntExecute;
 
-    protected override string FriendlyName => "'else' statement";
+    public override string FriendlyName => "'else' statement";
 
     public override TryAddTokenRes TryAddToken(BaseToken token)
     {
diff --git a/Code/ContextSystem/Contexts/Control/EndKeyword.cs b/Code/ContextSystem/Contexts/Control/EndKeyword.cs
@@ -11,7 +11,7 @@ namespace SER.Code.ContextSystem.Contexts.Control;
 public class EndKeyword : StandardContext, IKeywordContext
 {
     public string KeywordName => "end";
-    protected override string FriendlyName => "'end' keyword";
+    public override string FriendlyName => "'end' keyword";
     public string Description => "Ends the current statement's body.";
     public string[] Arguments => [];
     public string? Example => null;
diff --git a/Code/ContextSystem/Contexts/Control/IfStatement.cs b/Code/ContextSystem/Contexts/Control/IfStatement.cs
@@ -27,7 +27,7 @@ public class IfStatement : StatementContext, IExtendableStatement, IKeywordConte
     
     private NumericExpressionReslover.CompiledExpression _expression;
 
-    protected override string FriendlyName => "'if' statement";
+    public override string FriendlyName => "'if' statement";
 
     public override TryAddTokenRes TryAddToken(BaseToken token)
     {
diff --git a/Code/ContextSystem/Contexts/Control/Loops/BreakKeyword.cs b/Code/ContextSystem/Contexts/Control/Loops/BreakKeyword.cs
@@ -33,7 +33,7 @@ Wait 1s
         end
         """;
 
-    protected override string FriendlyName => "'break' keyword";
+    public override string FriendlyName => "'break' keyword";
 
     public override TryAddTokenRes TryAddToken(BaseToken token)
     {
diff --git a/Code/ContextSystem/Contexts/Control/Loops/ContinueKeyword.cs b/Code/ContextSystem/Contexts/Control/Loops/ContinueKeyword.cs
@@ -19,7 +19,7 @@ public class ContinueKeyword : StandardContext, IKeywordContext
     
     public string? Example => null;
 
-    protected override string FriendlyName => "'continue' keyword";
+    public override string FriendlyName => "'continue' keyword";
 
     public override TryAddTokenRes TryAddToken(BaseToken token)
     {
diff --git a/Code/ContextSystem/Contexts/Control/OnErrorStatement.cs b/Code/ContextSystem/Contexts/Control/OnErrorStatement.cs
@@ -45,7 +45,7 @@ public class OnErrorStatement : StatementContext, IStatementExtender, IKeywordCo
         """;
 
     public IExtendableStatement.Signal Extends => IExtendableStatement.Signal.ThrewException;
-    protected override string FriendlyName => "'on_error' statement";
+    public override string FriendlyName => "'on_error' statement";
 
     public Exception? Exception
     {
diff --git a/Code/ContextSystem/Contexts/Control/ReturnKeyword.cs b/Code/ContextSystem/Contexts/Control/ReturnKeyword.cs
@@ -22,7 +22,7 @@ public class ReturnKeyword : StandardContext, IKeywordContext
     public string[] Arguments => ["[return value]"];
     public string? Example => null;
 
-    protected override string FriendlyName => "'return' keyword";
+    public override string FriendlyName => "'return' keyword";
     
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
diff --git a/Code/ContextSystem/Contexts/Control/StopKeyword.cs b/Code/ContextSystem/Contexts/Control/StopKeyword.cs
@@ -19,7 +19,7 @@ public class StopKeyword : StandardContext, IKeywordContext
     
     public string? Example => null;
 
-    protected override string FriendlyName => "'stop' keyword";
+    public override string FriendlyName => "'stop' keyword";
     
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
diff --git a/Code/ContextSystem/Contexts/FuncStatement.cs b/Code/ContextSystem/Contexts/FuncStatement.cs
@@ -51,7 +51,7 @@ public TypeOfValue? Returns
     public string MissingValueHint => "Maybe you forgot to use the 'return' keyword?";
     public string UndefinedReturnsHint => "Maybe you forgot to define the return type in the function name?";
 
-    protected override string FriendlyName =>
+    public override string FriendlyName =>
         FunctionName is not null
             ? $"'{FunctionName}' function definition statement"
             : "function definition statement";
diff --git a/Code/ContextSystem/Contexts/GlobalKeyword.cs b/Code/ContextSystem/Contexts/GlobalKeyword.cs
@@ -14,7 +14,7 @@ namespace SER.Code.ContextSystem.Contexts;
 [UsedImplicitly]
 public class GlobalKeyword : YieldingContext, IKeywordContext
 {
-    protected override string FriendlyName =>
+    public override string FriendlyName =>
         $"global{(_variableToken is null ? "" : $" '{_variableToken.RawRep}'")} variable definition";
 
     public string KeywordName => "global";
diff --git a/Code/ContextSystem/Contexts/MethodContext.cs b/Code/ContextSystem/Contexts/MethodContext.cs
@@ -32,7 +32,7 @@ public class MethodContext(MethodToken methodToken) : YieldingContext, IMayRetur
     public string MissingValueHint => "This method did not return a value. This may be a SER bug.";
     public string UndefinedReturnsHint => "This method does not define a return type. This may be a SER bug.";
 
-    protected override string FriendlyName => $"'{Method.Name}' method call";
+    public override string FriendlyName => $"'{Method.Name}' method call";
 
     public override TryAddTokenRes TryAddToken(BaseToken token)
     {
diff --git a/Code/ContextSystem/Contexts/RunKeyword.cs b/Code/ContextSystem/Contexts/RunKeyword.cs
@@ -22,7 +22,7 @@ public class RunKeyword : YieldingContext, IMayReturnValueContext
     public string MissingValueHint => _functionDefinitionContext?.MissingValueHint ?? "Function is not defined.";
     public string UndefinedReturnsHint => _functionDefinitionContext?.UndefinedReturnsHint ?? "Function is not defined.";
 
-    protected override string FriendlyName =>
+    public override string FriendlyName =>
         _functionDefinitionContext is not null
             ? $"'{_functionDefinitionContext.FunctionName}' function call"
             : "function call";
diff --git a/Code/ContextSystem/Contexts/ValueExpressionContext.cs b/Code/ContextSystem/Contexts/ValueExpressionContext.cs
@@ -18,81 +18,112 @@ namespace SER.Code.ContextSystem.Contexts;
 /// </summary>
 public class ValueExpressionContext : AdditionalContext
 {
-    private readonly BaseToken _initial;
-
     public abstract class Handler
     {
         public abstract TryGet<Value> GetReturnValue();
         public abstract TryAddTokenRes TryAddToken(BaseToken token);
         public abstract Result VerifyCurrentState();
         public abstract IEnumerator<float> Run();
+        public abstract string FriendlyName { get; }
+        public abstract TypeOfValue PossibleValues { get; }
     }
 
+    private readonly BaseToken _initial;
+    private readonly IValueToken? _initialValueToken;
     private readonly string? _error;
     private Handler? _handler;
     
     /// <summary>
     /// Used to unify method calls, math expressions and property access into a single context that returns a value.
     /// </summary>
-    public ValueExpressionContext(BaseToken initial, bool allowsYielding, RunnableContext parent)
+    public ValueExpressionContext(BaseToken initial, bool allowsYielding)
     {
         _initial = initial;
         try
         {
             if (initial is MethodToken methodToken)
             {
-                _handler = new MethodHandler(methodToken, allowsYielding, parent);
+                _handler = new MethodHandler(methodToken, allowsYielding, initial.Script);
             }
-            else if (initial is not IValueToken)
+            else if (initial is not IValueToken valToken)
             {
                 _error = $"{initial} is not a valid way to get a value.";
             }
+            else
+            {
+                _initialValueToken = valToken;
+            }
         }
         catch (Exception e)
         {
             _error = e.Message;
         }
     }
 
-    protected override string FriendlyName => "value expression";
+    public override string FriendlyName => _handler?.FriendlyName ?? "value expression";
+    
+    public TypeOfValue PossibleValues => _handler?.PossibleValues ?? new UnknownTypeOfValue();
     
     public override TryAddTokenRes TryAddToken(BaseToken token) 
     {
-        if (_error is not null) return TryAddTokenRes.Error(_error);
+        if (_error is not null)
+        {
+            return TryAddTokenRes.Error(_error);
+        }
 
-        _handler ??= token switch
+        if (_handler is not null)
         {
-            SymbolToken => new GenericValueExpressionResolver(_initial, Script),
-            // we assume that an unknown token means property access, but thats kinda sloppy
-            _ => new ValuePropertyHandler(_initial, (IValueToken)_initial)
+            goto try_add_token;
+        }
+
+        if (token is not SymbolToken symbol)
+        {
+            return TryAddTokenRes.Error($"{token} is not a valid way to get a value with {_initial}");
+        }
+            
+        _handler = symbol switch
+        {
+            { IsArrow: false } => new NumericExpressionHandler(_initial, Script),
+            { IsArrow: true } => new ValuePropertyHandler(_initial, (IValueToken)_initial)
         };
-        
+
+        try_add_token:
         return _handler.TryAddToken(token);
     }
 
     public override Result VerifyCurrentState()
     {
         if (_error is not null) return _error;
-        if (_handler is null) return $"{_initial} is not a valid way to get a value.";
+        if (_handler is null) return true;
         return _handler.VerifyCurrentState();
     }
 
+    /// <summary>
+    /// If the context is not yielding, disregard the return value.
+    /// </summary>
     public IEnumerator<float> Run()
     {
         var coro = _handler!.Run();
         while (coro.MoveNext()) yield return coro.Current;
     }
+    
+    public TryGet<Value> GetValue() => 
+        _handler?.GetReturnValue() 
+        ?? _initialValueToken?.Value() 
+        ?? throw new AndrzejFuckedUpException();
 }
 
 public class MethodHandler : ValueExpressionContext.Handler
 {
-    private readonly RunnableContext _parent;
     private readonly MethodContext _context;
 
-    public MethodHandler(MethodToken token, bool allowsYielding, RunnableContext parent)
+    public MethodHandler(MethodToken token, bool allowsYielding, Script scr)
     {
-        _parent = parent;
-        _context = (MethodContext)token.GetContext(token.Script);
+        _context = new MethodContext(token)
+        {
+            Script = scr,
+            LineNum = null
+        };
         var method = token.Method;
         
         if (method is not IReturningMethod) 
@@ -104,8 +135,17 @@ public MethodHandler(MethodToken token, bool allowsYielding, RunnableContext par
                 $"Consider making a variable and using that variable instead.");
     }
 
-    public override TryGet<Value> GetReturnValue() => _context.ReturnedValue 
-                                                      ?? throw new ScriptRuntimeError(_parent, _context.MissingValueHint);
+    public override string FriendlyName => _context.FriendlyName;
+    
+    public override TypeOfValue PossibleValues =>
+        _context.Returns 
+        ?? throw new AndrzejFuckedUpException("Method has no return type.");
+
+    public override TryGet<Value> GetReturnValue()
+    {
+        if (_context.ReturnedValue is { } value) return value;
+        return _context.MissingValueHint;
+    }
 
     public override TryAddTokenRes TryAddToken(BaseToken token)
     {
@@ -132,14 +172,17 @@ public class ValuePropertyHandler(
     IValueToken valueToken) : ValueExpressionContext.Handler
 {
     private readonly Queue<string> _propertyNames = [];
-    private string _valueRepresentation = baseToken.RawRep;
+    private string _exprRepr = baseToken.RawRep;
     private TypeOfValue _lastValueType = valueToken.PossibleValues;
 
+    public override string FriendlyName => "property access";
+    public override TypeOfValue PossibleValues => _lastValueType;
+
     public override TryGet<Value> GetReturnValue()
     {
         if (valueToken.Value().HasErrored(out var error, out var value))
         {
-            return $"Failed to get value from '{_valueRepresentation}'".AsError()
+            return $"Failed to get value from '{_exprRepr}'".AsError()
                    + error.AsError();
         }
 
@@ -160,27 +203,35 @@ public override TryGet<Value> GetReturnValue()
 
     public override TryAddTokenRes TryAddToken(BaseToken token)
     {
+        if (token is SymbolToken { IsArrow: true })
+        {
+            return TryAddTokenRes.Continue();
+        }
+        
         // type verification
         if (_lastValueType.AreKnown(out var types))
         {
             foreach (var type in types)
             {
                 if (Value.GetPropertiesOfValue(type).TryGetValue(token.RawRep, out var property))
                 {
-                    _valueRepresentation += $" {token.RawRep}";
+                    _exprRepr += $" {token.RawRep}";
                     _lastValueType = property.ReturnType;
                     break;
                 }
             }
             
-            return TryAddTokenRes.Error($"'{token.RawRep}' is not a valid property of '{_valueRepresentation}' value.");
+            return TryAddTokenRes.Error($"'{token.RawRep}' is not a valid property of '{_exprRepr}' value.");
         }
         
         _propertyNames.Enqueue(token.RawRep);
         return TryAddTokenRes.Continue();
     }
 
-    public override Result VerifyCurrentState() => true;
+    public override Result VerifyCurrentState() => Result.Assert(
+        _propertyNames.Count > 0, 
+        $"The '{SymbolToken.Arrow}' operator was used, but no property to be accessed was specified."
+    );
 
     public override IEnumerator<float> Run()
     {
@@ -191,12 +242,16 @@ public override IEnumerator<float> Run()
 /// <summary>
 /// Used for math expressions.
 /// </summary>
-public class GenericValueExpressionResolver(BaseToken initial, Script scr)
+public class NumericExpressionHandler(BaseToken initial, Script scr)
     : ValueExpressionContext.Handler
 {
     private readonly List<BaseToken> _tokens = [initial];
     private Safe<NumericExpressionReslover.CompiledExpression> _expression;
-    
+
+    public override string FriendlyName => $"numeric expression";
+
+    public override TypeOfValue PossibleValues => new UnknownTypeOfValue();
+
     public override TryGet<Value> GetReturnValue()
     {
         return _expression.Value.Evaluate().OnSuccess(obj => Value.Parse(obj, scr));
diff --git a/Code/ContextSystem/Contexts/VariableDefinition/VariableDefinitionContext.cs b/Code/ContextSystem/Contexts/VariableDefinition/VariableDefinitionContext.cs
@@ -36,7 +36,7 @@ protected virtual (TryAddTokenRes result, Func<TValue> parser) AdditionalParsing
     private (RunnableContext main, IMayReturnValueContext returner)? _returnContext = null; 
     private Func<TValue>? _parser = null;
 
-    protected override string FriendlyName => $"'{varToken.RawRep}' variable definition";
+    public override string FriendlyName => $"'{varToken.RawRep}' variable definition";
 
     public override TryAddTokenRes TryAddToken(BaseToken token)
     {
diff --git a/Code/ContextSystem/Contexts/WithKeyword.cs b/Code/ContextSystem/Contexts/WithKeyword.cs
@@ -56,7 +56,7 @@ public Result AcceptStatement(StatementContext context)
         return true;
     }
 
-    protected override string FriendlyName => "'with' keyword";
+    public override string FriendlyName => "'with' keyword";
 
     public override TryAddTokenRes TryAddToken(BaseToken token)
     {
diff --git a/Code/MethodSystem/Methods/ItemMethods/ItemInfoMethod.cs b/Code/MethodSystem/Methods/ItemMethods/ItemInfoMethod.cs
diff --git a/Code/MethodSystem/Methods/PlayerVariableMethods/FilterPlayersMethod.cs b/Code/MethodSystem/Methods/PlayerVariableMethods/FilterPlayersMethod.cs
diff --git a/Code/MethodSystem/Methods/PlayerVariableMethods/ShowMethod.cs b/Code/MethodSystem/Methods/PlayerVariableMethods/ShowMethod.cs
diff --git a/Code/Plugin/Commands/HelpSystem/DocsProvider.cs b/Code/Plugin/Commands/HelpSystem/DocsProvider.cs
diff --git a/Code/Plugin/Commands/HelpSystem/HelpInfoStorage.cs b/Code/Plugin/Commands/HelpSystem/HelpInfoStorage.cs
diff --git a/Code/TokenSystem/Tokenizer.cs b/Code/TokenSystem/Tokenizer.cs
diff --git a/Code/TokenSystem/Tokens/ExpressionTokens/ExpressionToken.cs b/Code/TokenSystem/Tokens/ExpressionTokens/ExpressionToken.cs
diff --git a/Code/TokenSystem/Tokens/SymbolToken.cs b/Code/TokenSystem/Tokens/SymbolToken.cs

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public abstract class Context`
`9`	`9`	`{`
`10`	`10`	`public required Script Script { get; set; } = null!;`
`11`	`11`
`12`		`- protected abstract string FriendlyName { get; }`
	`12`	`+ public abstract string FriendlyName { get; }`
`13`	`13`
`14`	`14`	`public abstract TryAddTokenRes TryAddToken(BaseToken token);`
`15`	`15`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public abstract class LoopContext : StatementContext, IExtendableStatement, IKey`
`26`	`26`	`protected bool ReceivedContinue;`
`27`	`27`	`protected bool ReceivedBreak;`
`28`	`28`
`29`		`- protected sealed override string FriendlyName => $"'{KeywordName}' loop statement";`
	`29`	`+ public sealed override string FriendlyName => $"'{KeywordName}' loop statement";`
`30`	`30`
`31`	`31`	`protected override void OnReceivedControlMessageFromChild(ParentContextControlMessage msg)`
`32`	`32`	`{`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public class ElifStatement : StatementContext, IStatementExtender, IExtendableSt`
`31`	`31`
`32`	`32`	`private NumericExpressionReslover.CompiledExpression _expression;`
`33`	`33`
`34`		`- protected override string FriendlyName => "'elif' statement";`
	`34`	`+ public override string FriendlyName => "'elif' statement";`
`35`	`35`
`36`	`36`	`public override TryAddTokenRes TryAddToken(BaseToken token)`
`37`	`37`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public class ElseStatement : StatementContext, IStatementExtender, IKeywordConte`
`21`	`21`
`22`	`22`	`public IExtendableStatement.Signal Extends => IExtendableStatement.Signal.DidntExecute;`
`23`	`23`
`24`		`- protected override string FriendlyName => "'else' statement";`
	`24`	`+ public override string FriendlyName => "'else' statement";`
`25`	`25`
`26`	`26`	`public override TryAddTokenRes TryAddToken(BaseToken token)`
`27`	`27`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace SER.Code.ContextSystem.Contexts.Control;`
`11`	`11`	`public class EndKeyword : StandardContext, IKeywordContext`
`12`	`12`	`{`
`13`	`13`	`public string KeywordName => "end";`
`14`		`- protected override string FriendlyName => "'end' keyword";`
	`14`	`+ public override string FriendlyName => "'end' keyword";`
`15`	`15`	`public string Description => "Ends the current statement's body.";`
`16`	`16`	`public string[] Arguments => [];`
`17`	`17`	`public string? Example => null;`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public class IfStatement : StatementContext, IExtendableStatement, IKeywordConte`
`27`	`27`
`28`	`28`	`private NumericExpressionReslover.CompiledExpression _expression;`
`29`	`29`
`30`		`- protected override string FriendlyName => "'if' statement";`
	`30`	`+ public override string FriendlyName => "'if' statement";`
`31`	`31`
`32`	`32`	`public override TryAddTokenRes TryAddToken(BaseToken token)`
`33`	`33`	`{`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ Wait 1s`
`33`	`33`	`end`
`34`	`34`	`""";`
`35`	`35`
`36`		`- protected override string FriendlyName => "'break' keyword";`
	`36`	`+ public override string FriendlyName => "'break' keyword";`
`37`	`37`
`38`	`38`	`public override TryAddTokenRes TryAddToken(BaseToken token)`
`39`	`39`	`{`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public class ContinueKeyword : StandardContext, IKeywordContext`
`19`	`19`
`20`	`20`	`public string? Example => null;`
`21`	`21`
`22`		`- protected override string FriendlyName => "'continue' keyword";`
	`22`	`+ public override string FriendlyName => "'continue' keyword";`
`23`	`23`
`24`	`24`	`public override TryAddTokenRes TryAddToken(BaseToken token)`
`25`	`25`	`{`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public class OnErrorStatement : StatementContext, IStatementExtender, IKeywordCo`
`45`	`45`	`""";`
`46`	`46`
`47`	`47`	`public IExtendableStatement.Signal Extends => IExtendableStatement.Signal.ThrewException;`
`48`		`- protected override string FriendlyName => "'on_error' statement";`
	`48`	`+ public override string FriendlyName => "'on_error' statement";`
`49`	`49`
`50`	`50`	`public Exception? Exception`
`51`	`51`	`{`