improve error messages for invalid parameters

Source/Parser/Expressions/ComparisonExpression.cs

@@ -117,9 +117,9 @@ public override bool ReplaceVariables(InterpreterScope scope, out ExpressionBase
                 }
 
                 if (funcRefLeft != null)
-                    result = new ErrorExpression(string.Format("Cannot compare function reference and {0}", right.Type), this.Location);
+                    result = new ErrorExpression(string.Format("Cannot compare function reference and {0}", right.Type.ToLowerString()), this.Location);
                 else
-                    result = new ErrorExpression(string.Format("Cannot compare {0} and function reference", left.Type), this.Location);
+                    result = new ErrorExpression(string.Format("Cannot compare {0} and function reference", left.Type.ToLowerString()), this.Location);
                 return false;
             }
 

Source/Parser/Expressions/ErrorExpression.cs

@@ -1,4 +1,5 @@
 using Jamiras.Components;
+using System;
 using System.Text;
 
 namespace RATools.Parser.Expressions
@@ -116,4 +117,27 @@ public UnknownVariableParseErrorExpression(string message, ExpressionBase expres
         {
         }
     }
+
+    internal class ConversionErrorExpression : ErrorExpression
+    {
+        public ConversionErrorExpression(ExpressionBase value, ExpressionType expectedType)
+            : this(value, expectedType.ToLowerString(), value.Location)
+        {
+        }
+
+        public ConversionErrorExpression(ExpressionBase value, string expectedType, TextRange location)
+            : base(String.Format("Cannot convert {0} to {1}", value.Type.ToLowerString(), expectedType), location)
+        {
+        }
+
+        public ConversionErrorExpression(ExpressionBase value, ExpressionType expectedType, TextRange location, string parameterName)
+            : this(value, expectedType.ToLowerString(), location, parameterName)
+        {
+        }
+
+        public ConversionErrorExpression(ExpressionBase value, string expectedType, TextRange location, string parameterName)
+            : base(String.Format("{0}: Cannot convert {1} to {2}", parameterName, value.Type.ToLowerString(), expectedType), location)
+        {
+        }
+    }
 }

Source/Parser/Expressions/ExpressionBase.cs

@@ -1107,125 +1107,4 @@ public virtual bool ReplaceVariables(InterpreterScope scope, out ExpressionBase
             return null;
         }
     }
-
-    /// <summary>
-    /// The supported expression types.
-    /// </summary>
-    public enum ExpressionType
-    {
-        /// <summary>
-        /// Unspecified
-        /// </summary>
-        None = 0,
-
-        /// <summary>
-        /// A variable definition.
-        /// </summary>
-        Variable,
-
-        /// <summary>
-        /// An integer constant.
-        /// </summary>
-        IntegerConstant,
-
-        /// <summary>
-        /// A string constant.
-        /// </summary>
-        StringConstant,
-
-        /// <summary>
-        /// A boolean constant.
-        /// </summary>
-        BooleanConstant,
-
-        /// <summary>
-        /// A floating point constant.
-        /// </summary>
-        FloatConstant,
-
-        /// <summary>
-        /// A function call.
-        /// </summary>
-        FunctionCall,
-
-        /// <summary>
-        /// A mathematic equation.
-        /// </summary>
-        Mathematic,
-
-        /// <summary>
-        /// A comparison.
-        /// </summary>
-        Comparison,
-
-        /// <summary>
-        /// The conditional
-        /// </summary>
-        Conditional,
-
-        /// <summary>
-        /// An assignment.
-        /// </summary>
-        Assignment,
-
-        /// <summary>
-        /// A function definition.
-        /// </summary>
-        FunctionDefinition,
-
-        /// <summary>
-        /// A return statement.
-        /// </summary>
-        Return,
-
-        /// <summary>
-        /// A dictionary.
-        /// </summary>
-        Dictionary,
-
-        /// <summary>
-        /// An array.
-        /// </summary>
-        Array,
-
-        /// <summary>
-        /// A for loop.
-        /// </summary>
-        For,
-
-        /// <summary>
-        /// An if statement.
-        /// </summary>
-        If,
-
-        /// <summary>
-        /// A comment.
-        /// </summary>
-        Comment,
-
-        /// <summary>
-        /// A keyword.
-        /// </summary>
-        Keyword,
-
-        /// <summary>
-        /// An error.
-        /// </summary>
-        Error,
-
-        /// <summary>
-        /// A reference to a variable.
-        /// </summary>
-        VariableReference,
-
-        /// <summary>
-        /// A memory accessor.
-        /// </summary>
-        MemoryAccessor,
-
-        /// <summary>
-        /// A comparison of MemoryValues with a possible hit target.
-        /// </summary>
-        Requirement,
-    }
 }

Source/Parser/Expressions/ExpressionType.cs

@@ -0,0 +1,174 @@
+namespace RATools.Parser.Expressions
+{
+    /// <summary>
+    /// The supported expression types.
+    /// </summary>
+    public enum ExpressionType
+    {
+        /// <summary>
+        /// Unspecified
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// A variable definition.
+        /// </summary>
+        Variable,
+
+        /// <summary>
+        /// An integer constant.
+        /// </summary>
+        IntegerConstant,
+
+        /// <summary>
+        /// A string constant.
+        /// </summary>
+        StringConstant,
+
+        /// <summary>
+        /// A boolean constant.
+        /// </summary>
+        BooleanConstant,
+
+        /// <summary>
+        /// A floating point constant.
+        /// </summary>
+        FloatConstant,
+
+        /// <summary>
+        /// A function call.
+        /// </summary>
+        FunctionCall,
+
+        /// <summary>
+        /// A mathematic equation.
+        /// </summary>
+        Mathematic,
+
+        /// <summary>
+        /// A comparison.
+        /// </summary>
+        Comparison,
+
+        /// <summary>
+        /// The conditional
+        /// </summary>
+        Conditional,
+
+        /// <summary>
+        /// An assignment.
+        /// </summary>
+        Assignment,
+
+        /// <summary>
+        /// A function definition.
+        /// </summary>
+        FunctionDefinition,
+
+        /// <summary>
+        /// A return statement.
+        /// </summary>
+        Return,
+
+        /// <summary>
+        /// A dictionary.
+        /// </summary>
+        Dictionary,
+
+        /// <summary>
+        /// An array.
+        /// </summary>
+        Array,
+
+        /// <summary>
+        /// A for loop.
+        /// </summary>
+        For,
+
+        /// <summary>
+        /// An if statement.
+        /// </summary>
+        If,
+
+        /// <summary>
+        /// A comment.
+        /// </summary>
+        Comment,
+
+        /// <summary>
+        /// A keyword.
+        /// </summary>
+        Keyword,
+
+        /// <summary>
+        /// An error.
+        /// </summary>
+        Error,
+
+        /// <summary>
+        /// A reference to a variable.
+        /// </summary>
+        VariableReference,
+
+        /// <summary>
+        /// A memory accessor.
+        /// </summary>
+        MemoryAccessor,
+
+        /// <summary>
+        /// A comparison of MemoryValues with a possible hit target.
+        /// </summary>
+        Requirement,
+    }
+
+    internal static class ExpressionTypeExtension
+    {
+        public static string ToLowerString(this ExpressionType expressionType)
+        {
+            switch (expressionType)
+            {
+                case ExpressionType.Array: return "array";
+                case ExpressionType.Assignment: return "assignment";
+                case ExpressionType.BooleanConstant: return "boolean";
+                case ExpressionType.Comment: return "comment";
+                case ExpressionType.Comparison: return "comparison";
+                case ExpressionType.Conditional: return "conditional expression";
+                case ExpressionType.Dictionary: return "dictionary";
+                case ExpressionType.Error: return "error";
+                case ExpressionType.FloatConstant: return "decimal number";
+                case ExpressionType.For: return "for expression";
+                case ExpressionType.FunctionCall: return "function call";
+                case ExpressionType.FunctionDefinition: return "function definition";
+                case ExpressionType.If: return "if statement";
+                case ExpressionType.IntegerConstant: return "integer";
+                case ExpressionType.Keyword: return "keyword";
+                case ExpressionType.Mathematic: return "mathematic expression";
+                case ExpressionType.MemoryAccessor: return "memory accessor";
+                case ExpressionType.Requirement: return "requirement";
+                case ExpressionType.Return: return "return statement";
+                case ExpressionType.StringConstant: return "string";
+                case ExpressionType.Variable: return "variable";
+                case ExpressionType.VariableReference: return "variable reference";
+                default:
+                    return expressionType.ToString().ToLower();
+            }
+        }
+
+        public static string ToArticleString(this ExpressionType expressionType)
+        {
+            var lowerString = ToLowerString(expressionType);
+            switch (lowerString[0])
+            {
+                case 'a':
+                case 'e':
+                case 'i':
+                case 'o':
+                case 'u':
+                    return "an " + lowerString;
+
+                default:
+                    return "a " + lowerString;
+            }
+        }
+    }
+}

Source/Parser/Expressions/FloatConstantExpression.cs

@@ -98,7 +98,7 @@ public static ExpressionBase ConvertFrom(ExpressionBase expression)
                     break;
 
                 default:
-                    return new ErrorExpression("Cannot convert to float", expression);
+                    return new ConversionErrorExpression(expression, ExpressionType.FloatConstant);
             }
 
             expression.CopyLocation(floatExpression);

Source/Parser/Expressions/FunctionCallExpression.cs

@@ -144,16 +144,33 @@ private bool Evaluate(InterpreterScope scope, bool inAssignment, out ExpressionB
                 functionDefinition.Evaluate(functionParametersScope, out result);
             }
 
-            if (result != null && result.Location.Start.Line == 0)
-                CopyLocation(result);
-
             var error = result as ErrorExpression;
             if (error != null)
             {
+                if (error.Location.End.Line == 0)
+                    CopyLocation(error);
+
                 result = ErrorExpression.WrapError(error, FunctionName.Name + " call failed", FunctionName);
                 return false;
             }
 
+            if (result != null)
+            {
+                if (!result.IsReadOnly || result.Location.End.Line == 0)
+                {
+                    CopyLocation(result);
+                }
+                else if (!result.Location.RangeEquals(Location))
+                {
+                    var cloneable = result as ICloneableExpression;
+                    if (cloneable != null)
+                    {
+                        result = cloneable.Clone();
+                        CopyLocation(result);
+                    }
+                }
+            }
+
             var functionCall = result as FunctionCallExpression;
             if (functionCall != null)
             {