Merge pull request #181 from spreadsheetlab/fix-issue-180

Fix: invalid parser reference for range with reference in function

Author: joerivv

src/XLParser.Tests/FormulaAnalysisTest.cs

@@ -1224,7 +1224,18 @@ public void ReferenceFunctionAsArgument()
         }
 
         [TestMethod]
-        public void RangeWithReferenceFunction()
+        public void RangeWithReferenceInFunction()
+        {
+            List<ParserReference> references = new FormulaAnalyzer("SUM(F13:OFFSET(E13,0,12))").ParserReferences().ToList();
+
+            //no reference for the range with the offset function
+            Assert.AreEqual(2, references.Count);
+            Assert.AreEqual("F13", references.First().LocationString);
+            Assert.AreEqual("E13", references.Last().LocationString);
+        }
+
+        [TestMethod]
+        public void RangeWithReferencesInFunction()
         {
             List<ParserReference> references = new FormulaAnalyzer("SUM(A1:INDEX(A:A,1,1:1))").ParserReferences().ToList();
 
@@ -1275,7 +1286,6 @@ public void MultiAreaRangeFormula()
             Assert.AreEqual("Sheet1!$A$1", references[0].LocationString);
             Assert.AreEqual("Sheet1!$B$2", references[1].LocationString);
         }
-
         #endregion
 
         #region Depth() and ConditionalComplexity()

src/XLParser/ExcelFormulaParser.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using Irony.Parsing;
 
 namespace XLParser
@@ -425,57 +424,41 @@ public static IEnumerable<ParserReference> GetParserReferences(this ParseTreeNod
                 default:
                     if (node.IsRange())
                     {
-                        var rangeStart = GetParserReferences(node.ChildNodes[0].SkipToRelevant()).ToArray();
-                        var rangeEnd = GetParserReferences(node.ChildNodes[2].SkipToRelevant()).ToArray();
-                        if (IsCellReference(rangeStart) && IsCellReference(rangeEnd))
+                        var rangeStart = GetParserReferences(node.ChildNodes[0].SkipToRelevant()).First();
+                        var rangeEnd = GetParserReferences(node.ChildNodes[2].SkipToRelevant()).First();
+                        if (rangeStart.ReferenceType == ReferenceType.Cell && rangeEnd.ReferenceType == ReferenceType.Cell)
                         {
-                            ParserReference range = rangeStart.First();
-                            range.MaxLocation = rangeEnd.First().MinLocation;
+                            ParserReference range = rangeStart;
+                            range.MaxLocation = rangeEnd.MinLocation;
                             range.ReferenceType = ReferenceType.CellRange;
                             range.ReferenceNode = node;
                             range.LocationString = node.Print();
                             list.Add(range);
+                            break;
                         }
-                        else if (IsTableReference(rangeStart) && IsTableReference(rangeEnd) && rangeStart.First().Name == rangeEnd.First().Name && rangeStart.First().TableColumns.Length == 1 && rangeEnd.First().TableColumns.Length == 1)
+                        if (rangeStart.ReferenceType == ReferenceType.Table && rangeEnd.ReferenceType == ReferenceType.Table && rangeStart.Name == rangeEnd.Name && rangeStart.TableColumns.Length == 1 && rangeEnd.TableColumns.Length == 1)
                         {
-                            ParserReference range = rangeStart.First();
-                            range.TableColumns = rangeStart.First().TableColumns.Concat(rangeEnd.First().TableColumns).ToArray();
-                            range.TableSpecifiers = rangeStart.First().TableSpecifiers.SequenceEqual(rangeEnd.First().TableSpecifiers) ? range.TableSpecifiers : new string[0];
+                            ParserReference range = rangeStart;
+                            range.TableColumns = rangeStart.TableColumns.Concat(rangeEnd.TableColumns).ToArray();
+                            range.TableSpecifiers = rangeStart.TableSpecifiers.SequenceEqual(rangeEnd.TableSpecifiers) ? range.TableSpecifiers : new string[0];
                             range.ReferenceNode = node;
                             range.LocationString = node.Print();
                             list.Add(range);
-                        }
-                        else
-                        {
-                            list.AddRange(rangeStart);
-                            list.AddRange(rangeEnd);
+                            break;
                         }
                     }
-                    else
-                    {
-                        list.AddRange(node.GetReferenceNodes().SelectMany(x => x.GetParserReferences()));
-                    }
+                    list.AddRange(node.GetReferenceNodes().SelectMany(x => x.GetParserReferences()));
                     break;
             }
             return list;
         }
 
-        private static bool IsCellReference(IList<ParserReference> references)
-        {
-            return references.Count == 1 && references.First().ReferenceType == ReferenceType.Cell;
-        }
-
-        private static bool IsTableReference(IList<ParserReference> references)
-        {
-            return references.Count == 1 && references.First().ReferenceType == ReferenceType.Table;
-        }
-
         /// <summary>
         /// Whether or not this node represents a range
         /// </summary>
         public static bool IsRange(this ParseTreeNode input)
         {
-            return input.IsBinaryReferenceOperation() && input.ChildNodes[1].Is(":");
+            return input.IsBinaryReferenceOperation() && input.ChildNodes[1].Is(":") && input.ChildNodes[0].ChildNodes.Last().Type() == input.ChildNodes[2].ChildNodes.Last().Type();
         }
 
         /// <summary>