Generic function call tokens fixed

riganti · Oct 24, 2023 · e072f63 · e072f63
1 parent d2d6cdb
commit e072f63
Show file tree

Hide file tree

Showing 4 changed files with 82 additions and 10 deletions.
diff --git a/src/Framework/Framework/Compilation/Parser/Binding/Parser/BindingParser.cs b/src/Framework/Framework/Compilation/Parser/Binding/Parser/BindingParser.cs
@@ -638,7 +638,7 @@ private BindingParserNode ReadIdentifierExpression(bool onlyTypeName)
                     Read();
                     var member = ReadIdentifierNameExpression();
                     if (expression is TypeOrFunctionReferenceBindingParserNode typeOrFunction)
-                        expression = typeOrFunction.ToTypeReference();
+                        expression = CreateNode(typeOrFunction.ToTypeReference(), startIndex);
 
                     expression = CreateNode(new MemberAccessBindingParserNode(expression, member), startIndex);
                 }
@@ -653,7 +653,7 @@ private BindingParserNode ReadIdentifierExpression(bool onlyTypeName)
                 else if (!onlyTypeName && next.Type == BindingTokenType.OpenParenthesis)
                 {
                     if (expression is TypeOrFunctionReferenceBindingParserNode typeOrFunction)
-                        expression = typeOrFunction.ToFunctionReference();
+                        expression = CreateNode(typeOrFunction.ToFunctionReference(), startIndex);
 
                     expression = ReadFunctionCall(startIndex, expression);
                 }

diff --git a/src/Framework/Framework/Compilation/Parser/Binding/Parser/BindingParserNode.cs b/src/Framework/Framework/Compilation/Parser/Binding/Parser/BindingParserNode.cs
@@ -47,14 +47,24 @@ public virtual IEnumerable<BindingParserNode> EnumerateNodes()
 
         public abstract string ToDisplayString();
 
-        internal void TransferTokens(BindingParserNode sourceNode)
+        internal void TransferTokens(BindingParserNode sourceNode, int? startPosition = null)
         {
-            Length = sourceNode.Length;
-            StartPosition = sourceNode.StartPosition;
+
+            StartPosition = startPosition ?? sourceNode.StartPosition;
+            Length = 0;
+
             Tokens.Clear();
             Tokens.Capacity = sourceNode.Tokens.Capacity;
+
             for (int i = 0; i < sourceNode.Tokens.Count; i++)
-                Tokens.Add(sourceNode.Tokens[i]);
+            {
+                var token = sourceNode.Tokens[i];
+                if ((startPosition ?? 0) <= token.StartPosition)
+                {
+                    Length += token.Length;
+                    Tokens.Add(token);
+                }
+            }
         }
     }
 }
diff --git a/...k/Framework/Compilation/Parser/Binding/Parser/TypeOrFunctionReferenceBindingParserNode.cs b/...k/Framework/Compilation/Parser/Binding/Parser/TypeOrFunctionReferenceBindingParserNode.cs
@@ -54,7 +54,10 @@ public BindingParserNode ToFunctionReference()
                 if (TypeArguments.Count == 0)
                     return memberAccess;
 
-                var genericName = new GenericNameBindingParserNode(memberAccess.MemberNameExpression.NameToken, TypeArguments);
+                var name = memberAccess.MemberNameExpression.NameToken;
+                var genericName = new GenericNameBindingParserNode(name, TypeArguments);
+                genericName.TransferTokens(this, name.StartPosition);
+
                 memberAccess.MemberNameExpression = genericName;
                 return memberAccess;
             }

diff --git a/src/Tests/Parser/Binding/BindingParserTests.cs b/src/Tests/Parser/Binding/BindingParserTests.cs
@@ -937,9 +937,10 @@ public void BindingParser_Lambda_WithTypeInfo_SingleParameter(string expr, strin
             var parameters = lambda.ParameterExpressions;
 
             Assert.AreEqual(1, parameters.Count);
-            Assert.AreEqual(type, parameters[0].Type.ToDisplayString());
-            Assert.AreEqual("arg", parameters[0].Name.ToDisplayString());
-            Assert.AreEqual("Method(arg)", body.ToDisplayString());
+
+            AssertNode(parameters[0].Type, type, 1, type.Length+1);
+            AssertNode(parameters[0].Name, "arg", type.Length + 2, 3);
+            AssertNode(body, "Method(arg)", type.Length + 10, 11);
         }
 
         [TestMethod]
@@ -1346,6 +1347,64 @@ public void BindingParser_GenericTypePropertyDeclaration()
             AssertNode(arg2, "System.String", 17, 13);
         }
 
+        [TestMethod]
+        public void BindingParser_GenericMethodCall_SimpleName()
+        {
+            var source = "GetType<string>(StringProp)";
+            var parser = bindingParserNodeFactory.SetupParser(source);
+            var root = parser.ReadExpression().As<FunctionCallBindingParserNode>();
+
+            var generic = root.TargetExpression.As<GenericNameBindingParserNode>();
+            var typeArgument = generic.TypeArguments[0].As<TypeReferenceBindingParserNode>();
+
+            AssertNode(root, source, 0, source.Length);
+            AssertNode(generic, "GetType<string>", 0, source.Length-12);
+            AssertNode(typeArgument, "string", 8, 6);
+        }
+
+        [TestMethod]
+        public void BindingParser_GenericMethodCall_MemberAccessName()
+        {
+            var source = "service.GetType<string?>(StringProp)";
+
+            var parser = bindingParserNodeFactory.SetupParser(source);
+            var root = parser.ReadExpression().As<FunctionCallBindingParserNode>();
+
+            var memberAccess = root.TargetExpression.As<MemberAccessBindingParserNode>();
+            var generic = memberAccess.MemberNameExpression.As<GenericNameBindingParserNode>();
+            var typeArgument = generic.TypeArguments[0].As<TypeReferenceBindingParserNode>();
+
+            AssertNode(root, source, 0, source.Length);
+            AssertNode(memberAccess, "service.GetType<string?>", 0, source.Length-12);
+            AssertNode(generic, "GetType<string?>", 8, source.Length - 20);
+
+            AssertNode(typeArgument, "string?", 16, 7);
+
+        }
+
+        [TestMethod]
+        public void BindingParser_GenericMethodCall_MultipleGenericArguments()
+        {
+            var source = "_this.Modal.GetType<string?, System.String>(StringProp)";
+
+            var parser = bindingParserNodeFactory.SetupParser(source);
+            var root = parser.ReadExpression().As<FunctionCallBindingParserNode>();
+
+            var memberAccess1 = root.TargetExpression.As<MemberAccessBindingParserNode>();
+            var memberAccess2 = memberAccess1.TargetExpression.As<MemberAccessBindingParserNode>();
+            var generic = memberAccess1.MemberNameExpression.As<GenericNameBindingParserNode>();
+            var typeArgument1 = generic.TypeArguments[0].As<TypeReferenceBindingParserNode>();
+            var typeArgument2 = generic.TypeArguments[1].As<TypeReferenceBindingParserNode>();
+
+            AssertNode(root, source, 0, source.Length);
+            AssertNode(memberAccess1, "_this.Modal.GetType<string?, System.String>", 0, source.Length - 12);
+            AssertNode(memberAccess2, "_this.Modal", 0, 11);
+            AssertNode(generic, "GetType<string?, System.String>", 12, 31);
+
+            AssertNode(typeArgument1, "string?", 20, 7);
+            AssertNode(typeArgument2, "System.String", 29, 13);
+        }
+
         private static void AssertNode(BindingParserNode elementType, string expectedDisplayString, int start, int length)
         {
             Assert.AreEqual(expectedDisplayString, elementType.ToDisplayString(), $"Node {elementType.GetType().Name}: display string incorrect.");