fix global-local variable name collisions

Elektryk-Andrzej · Elektryk-Andrzej · commit 7a13a8e79df4 · 2026-02-16T21:34:56.000+01:00
diff --git a/Code/ContextSystem/BaseContexts/LoopContextWithSingleIterationVariable.cs b/Code/ContextSystem/BaseContexts/LoopContextWithSingleIterationVariable.cs
@@ -34,14 +34,14 @@ protected void SetVariable(TVal value)
         if (_iterationVariableToken is null) return;
         
         _iterationVariable = Variable.Create(_iterationVariableToken.Name, value);
-        Script.AddVariable(_iterationVariable);
+        Script.AddLocalVariable(_iterationVariable);
     }
 
     protected void RemoveVariable()
     {
         if (_iterationVariable is null) return;
         
-        Script.RemoveVariable(_iterationVariable);
+        Script.RemoveLocalVariable(_iterationVariable);
         _iterationVariable = null;
     }
 }
diff --git a/Code/ContextSystem/Contexts/Control/Loops/OverLoop.cs b/Code/ContextSystem/Contexts/Control/Loops/OverLoop.cs
@@ -160,13 +160,13 @@ protected override IEnumerator<float> Execute()
             if (_itemIterationVariableToken is not null)
             {
                 _itemIterationVariable = Variable.Create(_itemIterationVariableToken.Name, value);
-                Script.AddVariable(_itemIterationVariable);
+                Script.AddLocalVariable(_itemIterationVariable);
             }
 
             if (_indexIterationVariableToken is not null)
             {
                 _indexIterationVariable = Variable.Create(_indexIterationVariableToken.Name, new NumberValue(index+1));
-                Script.AddVariable(_indexIterationVariable);
+                Script.AddLocalVariable(_indexIterationVariable);
             }
 
             var coro = RunChildren();
@@ -175,8 +175,8 @@ protected override IEnumerator<float> Execute()
                 yield return coro.Current;
             }
 
-            if (_itemIterationVariable is not null) Script.RemoveVariable(_itemIterationVariable);
-            if (_indexIterationVariable is not null) Script.RemoveVariable(_indexIterationVariable);
+            if (_itemIterationVariable is not null) Script.RemoveLocalVariable(_itemIterationVariable);
+            if (_indexIterationVariable is not null) Script.RemoveLocalVariable(_indexIterationVariable);
 
             if (ReceivedBreak)
             {
diff --git a/Code/ContextSystem/Contexts/FunctionDefinitionContext.cs b/Code/ContextSystem/Contexts/FunctionDefinitionContext.cs
@@ -111,7 +111,7 @@ public IEnumerator<float> RunProperly(params Value[] values)
             _localVariables.Add(Variable.Create(variableToken.Name, value));
         }
         
-        Script.AddVariables(_localVariables.ToArray());
+        Script.AddLocalVariables(_localVariables.ToArray());
         return Execute();
     }
 
@@ -153,6 +153,6 @@ protected override IEnumerator<float> Execute()
         }
         
         Exit:
-        _localVariables.ForEach(v => Script.RemoveVariable(v));
+        _localVariables.ForEach(v => Script.RemoveLocalVariable(v));
     }
 }
diff --git a/Code/ContextSystem/Contexts/VariableDefinition/VariableDefinitionContext.cs b/Code/ContextSystem/Contexts/VariableDefinition/VariableDefinitionContext.cs
@@ -134,12 +134,12 @@ protected override IEnumerator<float> Execute()
             }
 
             DefinedVariable = Variable.Create(varToken.Name, tValue);
-            Script.AddVariable(DefinedVariable);
+            Script.AddLocalVariable(DefinedVariable);
         }
         else if (_parser is not null)
         {
             DefinedVariable = Variable.Create(varToken.Name, Value.Parse(_parser(), Script));
-            Script.AddVariable(DefinedVariable);
+            Script.AddLocalVariable(DefinedVariable);
         }
         else
         {
diff --git a/Code/EventSystem/EventHandler.cs b/Code/EventSystem/EventHandler.cs
@@ -178,7 +178,7 @@ private static void OnArgumentedEvent<T>(string evName, T ev) where T : EventArg
                 continue;
             }
             
-            script.AddVariables(variables);
+            script.AddLocalVariables(variables);
             var isAllowed = script.RunForEvent(RunContext.Event);
             if (isAllowed.HasValue && ev is ICancellableEvent cancellable1)
                 cancellable1.IsAllowed = isAllowed.Value;
diff --git a/Code/FlagSystem/Flags/CustomCommandFlag.cs b/Code/FlagSystem/Flags/CustomCommandFlag.cs
@@ -238,12 +238,12 @@ public static Result RunAttachedScript(CustomCommand cmd, ScriptExecutor sender,
             {
                 if (token.TryGetLiteralValue<LiteralValue>().WasSuccessful(out var value))
                 {
-                    script.AddVariable(Variable.Create(name, value));
+                    script.AddLocalVariable(Variable.Create(name, value));
                     continue;
                 }
             }
             
-            script.AddVariable(new LiteralVariable<TextValue>(name, new StaticTextValue(slice.Value)));
+            script.AddLocalVariable(new LiteralVariable<TextValue>(name, new StaticTextValue(slice.Value)));
         }
 
         script.Run(RunContext.Command);
diff --git a/Code/FlagSystem/Flags/FunctionFlag.cs b/Code/FlagSystem/Flags/FunctionFlag.cs
@@ -46,7 +46,7 @@ public class FunctionFlag : Flag
     public override Result OnScriptRunning(Script scr)
     {
         (VariableToken token, Variable var)[] provided = _expectedVarTokens
-            .Select(token => (token, scr.Variables.FirstOrDefault(var => var.Name == token.Name)))
+            .Select(token => (token, scr.LocalVariables.FirstOrDefault(var => var.Name == token.Name)))
             .OfType<(VariableToken, Variable)>()
             .ToArray();
 
diff --git a/Code/FlagSystem/Flags/InteractableToyEventFlag.cs b/Code/FlagSystem/Flags/InteractableToyEventFlag.cs
@@ -54,7 +54,7 @@ public static void RunBoundScripts(Player player, InteractableToy interactableTo
                 continue;
             }
 
-            script.AddVariables(variables);
+            script.AddLocalVariables(variables);
             script.Run(RunContext.Event);
         }
     }
diff --git a/Code/MethodSystem/Methods/CollectionVariableMethods/CollectionInsertMethod.cs b/Code/MethodSystem/Methods/CollectionVariableMethods/CollectionInsertMethod.cs
@@ -27,7 +27,7 @@ public override void Execute()
     {
         var collVar = Args.GetCollectionVariable("collection variable");
         
-        Script.AddVariable(
+        Script.AddLocalVariable(
             new CollectionVariable(
                 collVar.Name, 
                 CollectionValue.Insert(collVar, Args.GetAnyValue("value"))
diff --git a/Code/MethodSystem/Methods/CollectionVariableMethods/CollectionRemoveAtMethod.cs b/Code/MethodSystem/Methods/CollectionVariableMethods/CollectionRemoveAtMethod.cs
@@ -26,7 +26,7 @@ public override void Execute()
         var collVar = Args.GetCollectionVariable("collection variable");
         var index = Args.GetInt("index");
 
-        Script.AddVariable(
+        Script.AddLocalVariable(
             new CollectionVariable(
                 collVar.Name,
                 CollectionValue.RemoveAt(collVar, index)
diff --git a/Code/MethodSystem/Methods/CollectionVariableMethods/CollectionRemoveMethod.cs b/Code/MethodSystem/Methods/CollectionVariableMethods/CollectionRemoveMethod.cs
@@ -29,7 +29,7 @@ public override void Execute()
         var amountToRemove = Args.GetInt("amount of matches to remove");
         var value = Args.GetAnyValue("value to remove");
         
-        Script.AddVariable(
+        Script.AddLocalVariable(
             new CollectionVariable(
                 collectionVar.Name,
                 CollectionValue.Remove(collectionVar.Value, value, amountToRemove)
diff --git a/Code/MethodSystem/Methods/ScriptMethods/RunFuncMethod.cs b/Code/MethodSystem/Methods/ScriptMethods/RunFuncMethod.cs
@@ -80,7 +80,7 @@ public override void Execute()
                 throw new AndrzejFuckedUpException();
             }
             
-            scriptToRun.AddVariable(variable);
+            scriptToRun.AddLocalVariable(variable);
         }
         
         scriptToRun.Run(RunContext.Script, Script);
diff --git a/Code/MethodSystem/Methods/ScriptMethods/RunScriptAndWaitMethod.cs b/Code/MethodSystem/Methods/ScriptMethods/RunScriptAndWaitMethod.cs
@@ -29,7 +29,7 @@ public override IEnumerator<float> Execute()
         var script = Args.GetCreatedScript("script to create");
         var variables = Args.GetRemainingArguments<Variable, VariableArgument>("variables to pass");
         
-        script.AddVariables(variables);
+        script.AddLocalVariables(variables);
         script.Run(RunContext.Script, Script);
         
         // ReSharper disable once ConditionIsAlwaysTrueOrFalse
diff --git a/Code/MethodSystem/Methods/ScriptMethods/RunScriptMethod.cs b/Code/MethodSystem/Methods/ScriptMethods/RunScriptMethod.cs
@@ -28,7 +28,7 @@ public override void Execute()
         var script = Args.GetCreatedScript("script to create");
         var variables = Args.GetRemainingArguments<Variable, VariableArgument>("variables to pass");
         
-        script.AddVariables(variables);
+        script.AddLocalVariables(variables);
         script.Run(RunContext.Script, Script);
     }
 }
diff --git a/Code/MethodSystem/Methods/ScriptMethods/ThisMethod.cs b/Code/MethodSystem/Methods/ScriptMethods/ThisMethod.cs
@@ -44,7 +44,7 @@ public override void Execute()
             "duration" => new DurationValue(Script.TimeRunning),
             "name" => new StaticTextValue(Script.Name),
             "path" => new StaticTextValue(FileSystem.FileSystem.GetScriptPath(Script)),
-            "variables" => new CollectionValue(Script.Variables.Select(v => v.Prefix + v.Name)),
+            "variables" => new CollectionValue(Script.LocalVariables.Select(v => v.Prefix + v.Name)),
             _ => throw new TosoksFuckedUpException("out of order")
         };
     }
diff --git a/Code/MethodSystem/Methods/ScriptMethods/TransferVariablesMethod.cs b/Code/MethodSystem/Methods/ScriptMethods/TransferVariablesMethod.cs
@@ -25,6 +25,6 @@ public override void Execute()
         var script = Args.GetRunningScript("target script");
         var variables = Args.GetRemainingArguments<Variable, VariableArgument>("variables");
         
-        script.AddVariables(variables);
+        script.AddLocalVariables(variables);
     }
 }
diff --git a/Code/MethodSystem/Methods/TextMethods/ReplaceTextInVariableMethod.cs b/Code/MethodSystem/Methods/TextMethods/ReplaceTextInVariableMethod.cs
@@ -35,7 +35,7 @@ public override void Execute()
         if (variable.Value is not TextValue textValue)
             throw new ScriptRuntimeError(this, ErrorReasons[0]);
         
-        Script.AddVariable(
+        Script.AddLocalVariable(
             new LiteralVariable(
                 variable.Name,
                 new DynamicTextValue(textValue.Value.Replace(text, replacement), Script)
diff --git a/Code/MethodSystem/Methods/VariableMethods/PopVariableMethod.cs b/Code/MethodSystem/Methods/VariableMethods/PopVariableMethod.cs
@@ -29,7 +29,7 @@ public override void Execute()
         switch (Args.GetOption("target"))
         {
             case "local": 
-                Script.RemoveVariable(variable);
+                Script.RemoveLocalVariable(variable);
                 break;
             case "global":
                 VariableIndex.RemoveGlobalVariable(variable);
diff --git a/Code/ScriptSystem/Script.cs b/Code/ScriptSystem/Script.cs
@@ -44,10 +44,10 @@ public required ScriptExecutor Executor
             switch (value)
             {
                 case RemoteAdminExecutor { Sender: { } sender } when Player.TryGet(sender, out var player):
-                    AddVariable(new PlayerVariable("sender", new([player])));
+                    AddLocalVariable(new PlayerVariable("sender", new([player])));
                     break;
                 case PlayerConsoleExecutor { Sender: { } hub }:
-                    AddVariable(new PlayerVariable("sender", new([Player.Get(hub)])));
+                    AddLocalVariable(new PlayerVariable("sender", new([Player.Get(hub)])));
                     break;
             }
 
@@ -71,8 +71,8 @@ public required ScriptExecutor Executor
     private static readonly List<Script> RunningScriptsList = [];
     public static readonly ReadOnlyCollection<Script> RunningScripts = RunningScriptsList.AsReadOnly();
     
-    private readonly HashSet<Variable> _variables = [];
-    public ReadOnlyCollection<Variable> Variables => _variables.ToList().AsReadOnly();
+    private readonly HashSet<Variable> _localVariables = [];
+    public ReadOnlyCollection<Variable> LocalVariables => _localVariables.ToList().AsReadOnly();
 
     public DateTime StartTime { get; private set; }
 
@@ -342,7 +342,7 @@ public TryGet<T> TryGetVariable<T>(VariableToken variable) where T : Variable
 
     public TryGet<T> TryGetVariable<T>(string name) where T : Variable
     {
-        var variable = _variables.FirstOrDefault(v => v.Name == name);
+        var variable = _localVariables.FirstOrDefault(v => v.Name == name);
         if (variable is not null)
         {
             if (variable is not T casted)
@@ -362,28 +362,37 @@ public TryGet<T> TryGetVariable<T>(string name) where T : Variable
         return $"There is no variable called {name}.";
     }
 
-    public void AddVariable(Variable variable)
+    public static void CheckForVariableNameCollisions(Variable newVariable, IEnumerable<Variable> existingVariables)
     {
+        if ((existingVariables as Variable[] ?? existingVariables.ToArray())
+            .Any(gv => Variable.AreSyntacticallySame(gv, newVariable)))
+        {
+            throw new CustomScriptRuntimeError(
+                $"Tried to create a local variable '{newVariable}', " +
+                $"but there is already a global variable with the same name."
+            );
+        }
+    }
+
+    public void AddLocalVariable(Variable variable)
+    {
+        CheckForVariableNameCollisions(variable, _localVariables);
+        
         Log.Debug($"Added variable {variable.Name} to script {Name}");
-        RemoveVariable(variable.Name);
-        _variables.Add(variable);
+        RemoveLocalVariable(variable);
+        _localVariables.Add(variable);
     }
 
-    public void AddVariables(params Variable[] variables)
+    public void AddLocalVariables(params Variable[] variables)
     {
         foreach (var variable in variables)
         {
-            AddVariable(variable);
+            AddLocalVariable(variable);
         }
     }
 
-    public void RemoveVariable(Variable variable)
-    {
-        RemoveVariable(variable.Name);
-    }
-    
-    public void RemoveVariable(string name)
+    public void RemoveLocalVariable(Variable variable)
     {
-        _variables.RemoveWhere(var => var.Name == name);
+        _localVariables.RemoveWhere(lv => Variable.AreSyntacticallySame(lv, variable));
     }
 }
diff --git a/Code/VariableSystem/Bases/Variable.cs b/Code/VariableSystem/Bases/Variable.cs
@@ -26,7 +26,9 @@ public static Variable Create(string name, Value value)
         };
     }
     
-    public override string ToString() => $"{Prefix}{Name}";
+    public sealed override string ToString() => $"{Prefix}{Name}";
+    
+    public static bool AreSyntacticallySame(Variable a, Variable b) => a.Prefix == b.Prefix && a.Name == b.Name;
 }
 
 public abstract class Variable<TValue> : Variable
diff --git a/Code/VariableSystem/VariableIndex.cs b/Code/VariableSystem/VariableIndex.cs
@@ -2,6 +2,7 @@
 using MapGeneration;
 using PlayerRoles;
 using SER.Code.Extensions;
+using SER.Code.ScriptSystem;
 using SER.Code.VariableSystem.Bases;
 using SER.Code.VariableSystem.Variables;
 
@@ -76,6 +77,11 @@ public static void Initialize()
 
     public static void AddGlobalVariable(Variable variable)
     {
+        foreach (var runningScript in Script.RunningScripts)
+        {
+            Script.CheckForVariableNameCollisions(variable, runningScript.LocalVariables);
+        }
+        
         RemoveGlobalVariable(variable);
         GlobalVariables.Add(variable);
     }

Original file line number	Diff line number	Diff line change
`@@ -34,14 +34,14 @@ protected void SetVariable(TVal value)`
`34`	`34`	`if (_iterationVariableToken is null) return;`
`35`	`35`
`36`	`36`	`_iterationVariable = Variable.Create(_iterationVariableToken.Name, value);`
`37`		`- Script.AddVariable(_iterationVariable);`
	`37`	`+ Script.AddLocalVariable(_iterationVariable);`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`protected void RemoveVariable()`
`41`	`41`	`{`
`42`	`42`	`if (_iterationVariable is null) return;`
`43`	`43`
`44`		`- Script.RemoveVariable(_iterationVariable);`
	`44`	`+ Script.RemoveLocalVariable(_iterationVariable);`
`45`	`45`	`_iterationVariable = null;`
`46`	`46`	`}`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -160,13 +160,13 @@ protected override IEnumerator<float> Execute()`
`160`	`160`	`if (_itemIterationVariableToken is not null)`
`161`	`161`	`{`
`162`	`162`	`_itemIterationVariable = Variable.Create(_itemIterationVariableToken.Name, value);`
`163`		`- Script.AddVariable(_itemIterationVariable);`
	`163`	`+ Script.AddLocalVariable(_itemIterationVariable);`
`164`	`164`	`}`
`165`	`165`
`166`	`166`	`if (_indexIterationVariableToken is not null)`
`167`	`167`	`{`
`168`	`168`	`_indexIterationVariable = Variable.Create(_indexIterationVariableToken.Name, new NumberValue(index+1));`
`169`		`- Script.AddVariable(_indexIterationVariable);`
	`169`	`+ Script.AddLocalVariable(_indexIterationVariable);`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`var coro = RunChildren();`
`@@ -175,8 +175,8 @@ protected override IEnumerator<float> Execute()`
`175`	`175`	`yield return coro.Current;`
`176`	`176`	`}`
`177`	`177`
`178`		`- if (_itemIterationVariable is not null) Script.RemoveVariable(_itemIterationVariable);`
`179`		`- if (_indexIterationVariable is not null) Script.RemoveVariable(_indexIterationVariable);`
	`178`	`+ if (_itemIterationVariable is not null) Script.RemoveLocalVariable(_itemIterationVariable);`
	`179`	`+ if (_indexIterationVariable is not null) Script.RemoveLocalVariable(_indexIterationVariable);`
`180`	`180`
`181`	`181`	`if (ReceivedBreak)`
`182`	`182`	`{`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ public IEnumerator<float> RunProperly(params Value[] values)`
`111`	`111`	`_localVariables.Add(Variable.Create(variableToken.Name, value));`
`112`	`112`	`}`
`113`	`113`
`114`		`- Script.AddVariables(_localVariables.ToArray());`
	`114`	`+ Script.AddLocalVariables(_localVariables.ToArray());`
`115`	`115`	`return Execute();`
`116`	`116`	`}`
`117`	`117`
`@@ -153,6 +153,6 @@ protected override IEnumerator<float> Execute()`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`Exit:`
`156`		`- _localVariables.ForEach(v => Script.RemoveVariable(v));`
	`156`	`+ _localVariables.ForEach(v => Script.RemoveLocalVariable(v));`
`157`	`157`	`}`
`158`	`158`	`}`
Original file line number	Diff line number	Diff line change
`@@ -134,12 +134,12 @@ protected override IEnumerator<float> Execute()`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`DefinedVariable = Variable.Create(varToken.Name, tValue);`
`137`		`- Script.AddVariable(DefinedVariable);`
	`137`	`+ Script.AddLocalVariable(DefinedVariable);`
`138`	`138`	`}`
`139`	`139`	`else if (_parser is not null)`
`140`	`140`	`{`
`141`	`141`	`DefinedVariable = Variable.Create(varToken.Name, Value.Parse(_parser(), Script));`
`142`		`- Script.AddVariable(DefinedVariable);`
	`142`	`+ Script.AddLocalVariable(DefinedVariable);`
`143`	`143`	`}`
`144`	`144`	`else`
`145`	`145`	`{`
Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ private static void OnArgumentedEvent<T>(string evName, T ev) where T : EventArg`
`178`	`178`	`continue;`
`179`	`179`	`}`
`180`	`180`
`181`		`- script.AddVariables(variables);`
	`181`	`+ script.AddLocalVariables(variables);`
`182`	`182`	`var isAllowed = script.RunForEvent(RunContext.Event);`
`183`	`183`	`if (isAllowed.HasValue && ev is ICancellableEvent cancellable1)`
`184`	`184`	`cancellable1.IsAllowed = isAllowed.Value;`
Original file line number	Diff line number	Diff line change
`@@ -238,12 +238,12 @@ public static Result RunAttachedScript(CustomCommand cmd, ScriptExecutor sender,`
`238`	`238`	`{`
`239`	`239`	`if (token.TryGetLiteralValue<LiteralValue>().WasSuccessful(out var value))`
`240`	`240`	`{`
`241`		`- script.AddVariable(Variable.Create(name, value));`
	`241`	`+ script.AddLocalVariable(Variable.Create(name, value));`
`242`	`242`	`continue;`
`243`	`243`	`}`
`244`	`244`	`}`
`245`	`245`
`246`		`- script.AddVariable(new LiteralVariable<TextValue>(name, new StaticTextValue(slice.Value)));`
	`246`	`+ script.AddLocalVariable(new LiteralVariable<TextValue>(name, new StaticTextValue(slice.Value)));`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`script.Run(RunContext.Command);`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public class FunctionFlag : Flag`
`46`	`46`	`public override Result OnScriptRunning(Script scr)`
`47`	`47`	`{`
`48`	`48`	`(VariableToken token, Variable var)[] provided = _expectedVarTokens`
`49`		`- .Select(token => (token, scr.Variables.FirstOrDefault(var => var.Name == token.Name)))`
	`49`	`+ .Select(token => (token, scr.LocalVariables.FirstOrDefault(var => var.Name == token.Name)))`
`50`	`50`	`.OfType<(VariableToken, Variable)>()`
`51`	`51`	`.ToArray();`
`52`	`52`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ public static void RunBoundScripts(Player player, InteractableToy interactableTo`
`54`	`54`	`continue;`
`55`	`55`	`}`
`56`	`56`
`57`		`- script.AddVariables(variables);`
	`57`	`+ script.AddLocalVariables(variables);`
`58`	`58`	`script.Run(RunContext.Event);`
`59`	`59`	`}`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public override void Execute()`
`27`	`27`	`{`
`28`	`28`	`var collVar = Args.GetCollectionVariable("collection variable");`
`29`	`29`
`30`		`- Script.AddVariable(`
	`30`	`+ Script.AddLocalVariable(`
`31`	`31`	`new CollectionVariable(`
`32`	`32`	`collVar.Name,`
`33`	`33`	`CollectionValue.Insert(collVar, Args.GetAnyValue("value"))`