Adjusted signature ranges.

Author: ItsDeltin

Deltinteger/Deltinteger/Compiler/Parse/Parser.cs

@@ -444,14 +444,14 @@ public IParseExpression GetArrayAndInvokes(IParseExpression expression)
                     expression = EndNodeFrom(new ValueInArray(expression, index, Lexer.Tokens[Token - 1]), expression.Range.Start);
                 }
                 // Invoke
-                else if (ParseOptional(TokenType.Parentheses_Open))
+                else if (ParseOptional(TokenType.Parentheses_Open, out Token leftParentheses))
                 {
                     // Parse parameters.
                     var values = ParseParameterValues();
                     // End the parentheses.
-                    ParseExpected(TokenType.Parentheses_Close);
+                    Token rightParentheses = ParseExpected(TokenType.Parentheses_Close);
                     // Update the expression.
-                    expression = EndNodeFrom(new FunctionExpression(expression, values), expression.Range.Start);
+                    expression = EndNodeFrom(new FunctionExpression(expression, leftParentheses, rightParentheses, values), expression.Range.Start);
                 }
                 // No more array indices or invocations.
                 else break;

Deltinteger/Deltinteger/Compiler/Syntax Tree/Syntax Tree.cs

@@ -315,12 +315,16 @@ public Hook(IParseExpression variable, IParseExpression value)
     public class FunctionExpression : Node, IParseExpression, IParseStatement
     {
         public IParseExpression Target { get; }
+        public Token LeftParentheses { get; }
+        public Token RightParentheses { get; }
         public List<ParameterValue> Parameters { get; }
         public MetaComment Comment { get; set; }
 
-        public FunctionExpression(IParseExpression target, List<ParameterValue> parameters)
+        public FunctionExpression(IParseExpression target, Token leftParentheses, Token rightParentheses, List<ParameterValue> parameters)
         {
             Target = target;
+            LeftParentheses = leftParentheses;
+            RightParentheses = rightParentheses;
             Parameters = parameters;
         }
 

Deltinteger/Deltinteger/Parse/Functions/IInvokeInfo.cs

@@ -106,7 +106,7 @@ public InvokeData(ParseInfo parseInfo, FunctionExpression context, IExpression t
             ParseInfo = parseInfo;
             Context = context;
             TargetRange = context.Target.Range;
-            CallRange = context.Range;
+            CallRange = context.LeftParentheses.Range.Start + context.RightParentheses.Range.Start;
             Target = target;
             Scope = scope;
             Getter = getter;

Deltinteger/Deltinteger/Parse/Parameters/OverloadChooser.cs

@@ -20,9 +20,9 @@ public class OverloadChooser
         private ParseInfo parseInfo { get; }
         private Scope scope { get; }
         private Scope getter { get; }
-        private DocRange genericErrorRange { get; }
         public DocRange CallRange { get; }
-        private OverloadError ErrorMessages { get; }
+        private OverloadError _errorMessages;
+        private readonly DocRange _targetRange;
 
         private IParameterCallable[] AllOverloads { get; }
         private List<IParameterCallable> CurrentOptions { get; set; }
@@ -44,9 +44,9 @@ public OverloadChooser(IParameterCallable[] overloads, ParseInfo parseInfo, Scop
             this.parseInfo = parseInfo;
             this.scope = elementScope;
             this.getter = getter;
-            this.genericErrorRange = genericErrorRange;
+            this._targetRange = genericErrorRange;
             CallRange = callRange;
-            this.ErrorMessages = errorMessages;
+            this._errorMessages = errorMessages;
 
             parseInfo.Script.AddOverloadData(this);
         }
@@ -157,7 +157,7 @@ private OverloadMatch MatchOverload(IParameterCallable option, PickyParameter[]
             for (int i = 0; i < match.OrderedParameters.Length; i++) match.CompareParameterTypes(i);
 
             // Get the missing parameters.
-            match.GetMissingParameters(genericErrorRange, ErrorMessages, context, CallRange);
+            match.GetMissingParameters(_errorMessages, context, _targetRange, CallRange);
 
             return match;
         }
@@ -199,7 +199,7 @@ private void CheckAccessLevel()
             else if (!getter.AccessorMatches(scope, Overload.AccessLevel)) accessable = false;
 
             if (!accessable)
-                parseInfo.Script.Diagnostics.Error(string.Format("'{0}' is inaccessable due to its access level.", Overload.GetLabel(false)), genericErrorRange);
+                parseInfo.Script.Diagnostics.Error(string.Format("'{0}' is inaccessable due to its access level.", Overload.GetLabel(false)), _targetRange);
         }
 
         private bool SetParameterCount(int numberOfParameters)
@@ -215,8 +215,8 @@ private bool SetParameterCount(int numberOfParameters)
             if (CurrentOptions.Count == 0)
             {
                 parseInfo.Script.Diagnostics.Error(
-                    string.Format(ErrorMessages.BadParameterCount, numberOfParameters),
-                    genericErrorRange
+                    string.Format(_errorMessages.BadParameterCount, numberOfParameters),
+                    _targetRange
                 );
                 return false;
             }
@@ -349,33 +349,33 @@ public void CompareParameterTypes(int parameter)
         }
 
         /// <summary>Determines if there are any missing parameters.</summary>
-        public void GetMissingParameters(DocRange genericErrorRange, OverloadError messageHandler, List<ParameterValue> context, DocRange functionCallRange)
+        public void GetMissingParameters(OverloadError messageHandler, List<ParameterValue> context, DocRange targetRange, DocRange signatureRange)
         {
             for (int i = 0; i < OrderedParameters.Length; i++)
                 if (OrderedParameters[i]?.Value == null)
                 {
                     if (OrderedParameters[i] == null) OrderedParameters[i] = new PickyParameter(true);
-                    AddContextualParameter(context, functionCallRange, i);
+                    AddContextualParameter(context, signatureRange, targetRange, i);
 
                     // Default value
                     if (Option.Parameters[i].DefaultValue != null)
                         // Set the default value.
                         OrderedParameters[i].Value = Option.Parameters[i].DefaultValue;
                     else
                         // Parameter is missing.
-                        Error(string.Format(messageHandler.MissingParameter, Option.Parameters[i].Name), genericErrorRange);
+                        Error(string.Format(messageHandler.MissingParameter, Option.Parameters[i].Name), targetRange);
                 }
         }
 
-        private void AddContextualParameter(List<ParameterValue> context, DocRange functionCallRange, int parameter)
+        private void AddContextualParameter(List<ParameterValue> context, DocRange targetRange, DocRange signatureRange, int parameter)
         {
             // No parameters set, set range for first parameter to callRange.
             if (parameter == 0 && OrderedParameters.All(p => p?.Value == null))
-                OrderedParameters[0].ExpressionRange = functionCallRange;
+                OrderedParameters[0].ExpressionRange = targetRange;
             // If this is the last contextual parameter and the context contains comma, set the expression range so signature help works with the last comma when there is no set expression.
             else if (LastContextualParameterIndex == parameter && parameter < context.Count && context[parameter].NextComma != null)
                 // Set the range to be the end of the comma to the start of the call range.
-                OrderedParameters[parameter].ExpressionRange = context[parameter].NextComma.Range.End + functionCallRange.End;
+                OrderedParameters[parameter].ExpressionRange = context[parameter].NextComma.Range.End + signatureRange.End;
         }
 
         public void AddDiagnostics(FileDiagnostics diagnostics)