From 288d54388047cb97600f6afc88122ed098133e69 Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Wed, 22 Apr 2020 00:55:19 -0400
Subject: [PATCH 01/16] :sparkles: Add parsing rules and AST members

- Add parsing rules to recognise generic method args

- Add AST members to MemberExpressionAst / InvokeMemberExpressionAst so
that the parsed information can be stored in the AST.

Co-authored-by: Dave Wyatt <dlwyatt115@gmail.com>
---
 .../engine/parser/Parser.cs                   | 136 ++++++++++++++----
 .../engine/parser/ast.cs                      |  71 +++++++--
 2 files changed, 171 insertions(+), 36 deletions(-)

diff --git a/src/System.Management.Automation/engine/parser/Parser.cs b/src/System.Management.Automation/engine/parser/Parser.cs
index 3afc55e9861..400fdeca599 100644
--- a/src/System.Management.Automation/engine/parser/Parser.cs
+++ b/src/System.Management.Automation/engine/parser/Parser.cs
@@ -1437,7 +1437,7 @@ private ITypeName GetSingleGenericArgument(Token firstToken)
             return typeName;
         }
 
-        private ITypeName GenericTypeArgumentsRule(Token genericTypeName, Token firstToken, bool unBracketedGenericArg)
+        private List<ITypeName> GenericArgumentsRule(Token firstToken, bool unBracketedGenericArg, out Token lastToken)
         {
             Diagnostics.Assert(firstToken.Kind == TokenKind.Identifier || firstToken.Kind == TokenKind.LBracket, "unexpected first token");
             RuntimeHelpers.EnsureSufficientExecutionStack();
@@ -1446,13 +1446,12 @@ private ITypeName GenericTypeArgumentsRule(Token genericTypeName, Token firstTok
             ITypeName typeName = GetSingleGenericArgument(firstToken);
             genericArguments.Add(typeName);
 
-            Token commaOrRBracketToken;
             Token token;
             while (true)
             {
                 SkipNewlines();
-                commaOrRBracketToken = NextToken();
-                if (commaOrRBracketToken.Kind != TokenKind.Comma)
+                lastToken = NextToken();
+                if (lastToken.Kind != TokenKind.Comma)
                 {
                     break;
                 }
@@ -1467,30 +1466,41 @@ private ITypeName GenericTypeArgumentsRule(Token genericTypeName, Token firstTok
                 }
                 else
                 {
-                    ReportIncompleteInput(After(commaOrRBracketToken),
+                    ReportIncompleteInput(
+                        After(lastToken),
                         nameof(ParserStrings.MissingTypename),
                         ParserStrings.MissingTypename);
-                    typeName = new TypeName(commaOrRBracketToken.Extent, ":ErrorTypeName:");
+                    typeName = new TypeName(lastToken.Extent, ":ErrorTypeName:");
                 }
 
                 genericArguments.Add(typeName);
             }
 
-            if (commaOrRBracketToken.Kind != TokenKind.RBracket)
+            return genericArguments;
+        }
+
+        private ITypeName GenericTypeArgumentsRule(Token genericTypeName, Token firstToken, bool unBracketedGenericArg)
+        {
+            List<ITypeName> genericArguments = GenericArgumentsRule(firstToken, unBracketedGenericArg, out Token rBracketToken);
+
+            if (rBracketToken.Kind != TokenKind.RBracket)
             {
                 // ErrorRecovery: pretend we had the closing bracket and just continue on.
-
-                UngetToken(commaOrRBracketToken);
-                ReportIncompleteInput(Before(commaOrRBracketToken),
-                    nameof(ParserStrings.EndSquareBracketExpectedAtEndOfAttribute),
-                    ParserStrings.EndSquareBracketExpectedAtEndOfAttribute);
-                commaOrRBracketToken = null;
+                UngetToken(rBracketToken);
+                ReportIncompleteInput(
+                    Before(rBracketToken),
+                    nameof(ParserStrings.UnexpectedToken),
+                    ParserStrings.UnexpectedToken);
+                rBracketToken = null;
             }
 
             var openGenericType = new TypeName(genericTypeName.Extent, genericTypeName.Text);
-            var result = new GenericTypeName(ExtentOf(genericTypeName.Extent, ExtentFromFirstOf(commaOrRBracketToken, genericArguments.LastOrDefault(), firstToken)),
-                openGenericType, genericArguments);
-            token = PeekToken();
+            var result = new GenericTypeName(
+                ExtentOf(genericTypeName.Extent, ExtentFromFirstOf(rBracketToken, genericArguments.LastOrDefault(), firstToken)),
+                openGenericType,
+                genericArguments);
+
+            Token token = PeekToken();
             if (token.Kind == TokenKind.LBracket)
             {
                 SkipToken();
@@ -7703,6 +7713,8 @@ private ExpressionAst MemberAccessRule(ExpressionAst targetExpr, Token operatorT
             // On entry, we've verified that operatorToken is not preceded by whitespace.
 
             CommandElementAst member = MemberNameRule();
+            List<ITypeName> genericTypeArguments = null;
+            Token rBracket = null;
 
             if (member == null)
             {
@@ -7715,27 +7727,96 @@ private ExpressionAst MemberAccessRule(ExpressionAst targetExpr, Token operatorT
                 member = GetSingleCommandArgument(CommandArgumentContext.CommandArgument) ??
                     new ErrorExpressionAst(ExtentOf(targetExpr, operatorToken));
             }
-            else
+            // Member name may be an incomplete token like `$a.$(Command-Name`; do not look for generic args or
+            // invocation token(s) if the member name token is recognisably incomplete.
+            else if (_ungotToken == null)
             {
+                genericTypeArguments = GenericMethodTypeArgumentsRule(out rBracket);
                 Token lParen = NextInvokeMemberToken();
+
                 if (lParen != null)
                 {
+                    // Fall through to the last available token expected in a member name for calculating the expected
+                    // position of the lParen. This accounts for things like `[Array]::Empty[int[]()` so that we don't
+                    // get unhandled behaviour when input is expected but incomplete.
+                    int endColumnNumber = rBracket?.Extent?.EndColumnNumber
+                        ?? genericTypeArguments?.LastOrDefault()?.Extent?.EndColumnNumber
+                        ?? member.Extent.EndColumnNumber;
+
                     Diagnostics.Assert(lParen.Kind == TokenKind.LParen || lParen.Kind == TokenKind.LCurly, "token kind incorrect");
-                    Diagnostics.Assert(member.Extent.EndColumnNumber == lParen.Extent.StartColumnNumber,
-                                       "member and paren must be adjacent");
-                    return MemberInvokeRule(targetExpr, lParen, operatorToken, member);
+                    Diagnostics.Assert(
+                        endColumnNumber == lParen.Extent.StartColumnNumber,
+                        "member and paren must be adjacent when the method is not generic");
+                    return MemberInvokeRule(targetExpr, lParen, operatorToken, member, genericTypeArguments);
                 }
             }
 
             return new MemberExpressionAst(
-                    ExtentOf(targetExpr, member),
-                    targetExpr,
-                    member,
-                    @static: operatorToken.Kind == TokenKind.ColonColon,
-                    nullConditional: operatorToken.Kind == TokenKind.QuestionDot);
+                ExtentOf(targetExpr, member),
+                targetExpr,
+                member,
+                @static: operatorToken.Kind == TokenKind.ColonColon,
+                nullConditional: operatorToken.Kind == TokenKind.QuestionDot,
+                genericTypeArguments);
+        }
+
+        private List<ITypeName> GenericMethodTypeArgumentsRule(out Token rBracketToken)
+        {
+            List<ITypeName> genericTypes = null;
+
+            int resyncIndex = _tokenizer.GetRestorePoint();
+            Token lBracket = NextToken();
+            rBracketToken = null;
+
+            if (lBracket.Kind == TokenKind.LBracket)
+            {
+                // This is either a member expression with generic type arguments, or some sort of collection index
+                // on a property.
+                var oldTokenizerMode = _tokenizer.Mode;
+                try
+                {
+                    // Switch to typename mode to avoid aggressive argument tokenization.
+                    SetTokenizerMode(TokenizerMode.TypeName);
+
+                    SkipNewlines();
+                    Token firstToken = NextToken();
+                    if (firstToken.Kind != TokenKind.Number
+                        && (firstToken.Kind == TokenKind.Identifier || firstToken.Kind == TokenKind.LBracket))
+                    {
+                        resyncIndex = -1;
+                        genericTypes = GenericArgumentsRule(firstToken, false, out rBracketToken);
+
+                        if (rBracketToken.Kind != TokenKind.RBracket)
+                        {
+                            UngetToken(rBracketToken);
+                            ReportIncompleteInput(
+                                Before(rBracketToken),
+                                nameof(ParserStrings.EndSquareBracketExpectedAtEndOfType),
+                                ParserStrings.EndSquareBracketExpectedAtEndOfType);
+                            rBracketToken = null;
+                        }
+                    }
+                }
+                finally
+                {
+                    SetTokenizerMode(oldTokenizerMode);
+                }
+            }
+
+            if (resyncIndex > 0)
+            {
+                Resync(resyncIndex);
+            }
+
+            return genericTypes;
         }
 
-        private ExpressionAst MemberInvokeRule(ExpressionAst targetExpr, Token lBracket, Token operatorToken, CommandElementAst member)
+        private ExpressionAst MemberInvokeRule(
+            ExpressionAst targetExpr,
+            Token lBracket,
+            Token operatorToken,
+            CommandElementAst member,
+            IEnumerable<ITypeName> genericTypes)
         {
             // G  invocation-expression: target-expression passed as a parameter. lBracket can be '(' or '{'.
             // G      target-expression   member-name   invoke-param-list
@@ -7766,7 +7847,8 @@ private ExpressionAst MemberInvokeRule(ExpressionAst targetExpr, Token lBracket,
                 member,
                 arguments,
                 operatorToken.Kind == TokenKind.ColonColon,
-                operatorToken.Kind == TokenKind.QuestionDot);
+                operatorToken.Kind == TokenKind.QuestionDot,
+                genericTypes);
         }
 
         private List<ExpressionAst> InvokeParamParenListRule(Token lParen, out IScriptExtent lastExtent)
diff --git a/src/System.Management.Automation/engine/parser/ast.cs b/src/System.Management.Automation/engine/parser/ast.cs
index 3e1f9ce60a5..8c506888bca 100644
--- a/src/System.Management.Automation/engine/parser/ast.cs
+++ b/src/System.Management.Automation/engine/parser/ast.cs
@@ -7873,10 +7873,16 @@ public class MemberExpressionAst : ExpressionAst, ISupportsAssignment
         /// <param name="static">True if the '::' operator was used, false if '.' is used.
         /// True if the member access is for a static member, using '::', false if accessing a member on an instance using '.'.
         /// </param>
+        /// <param name="genericTypes">The generic type arguments passed to the member.</param>
         /// <exception cref="PSArgumentNullException">
         /// If <paramref name="extent"/>, <paramref name="expression"/>, or <paramref name="member"/> is null.
         /// </exception>
-        public MemberExpressionAst(IScriptExtent extent, ExpressionAst expression, CommandElementAst member, bool @static)
+        public MemberExpressionAst(
+            IScriptExtent extent,
+            ExpressionAst expression,
+            CommandElementAst member,
+            bool @static,
+            IEnumerable<ITypeName> genericTypes = null)
             : base(extent)
         {
             if (expression == null || member == null)
@@ -7889,6 +7895,11 @@ public MemberExpressionAst(IScriptExtent extent, ExpressionAst expression, Comma
             this.Member = member;
             SetParent(member);
             this.Static = @static;
+
+            if (genericTypes?.Any() == true)
+            {
+                this.GenericTypeArguments = new ReadOnlyCollection<ITypeName>(genericTypes.ToArray());
+            }
         }
 
         /// <summary>
@@ -7902,11 +7913,18 @@ public MemberExpressionAst(IScriptExtent extent, ExpressionAst expression, Comma
         /// <param name="member">The name or expression naming the member to access.</param>
         /// <param name="static">True if the '::' operator was used, false if '.' or '?.' is used.</param>
         /// <param name="nullConditional">True if '?.' used.</param>
+        /// <param name="genericTypes">The generic type arguments passed to the member.</param>
         /// <exception cref="PSArgumentNullException">
         /// If <paramref name="extent"/>, <paramref name="expression"/>, or <paramref name="member"/> is null.
         /// </exception>
-        public MemberExpressionAst(IScriptExtent extent, ExpressionAst expression, CommandElementAst member, bool @static, bool nullConditional)
-            : this(extent, expression, member, @static)
+        public MemberExpressionAst(
+            IScriptExtent extent,
+            ExpressionAst expression,
+            CommandElementAst member,
+            bool @static,
+            bool nullConditional,
+            IEnumerable<ITypeName> genericTypes = null)
+            : this(extent, expression, member, @static, genericTypes)
         {
             this.NullConditional = nullConditional;
         }
@@ -7931,6 +7949,11 @@ public MemberExpressionAst(IScriptExtent extent, ExpressionAst expression, Comma
         /// </summary>
         public bool NullConditional { get; protected set; }
 
+        /// <summary>
+        /// List of generic type arguments passed to this member.
+        /// </summary>
+        public ReadOnlyCollection<ITypeName> GenericTypeArguments { get; private set; }
+
         /// <summary>
         /// Copy the MemberExpressionAst instance.
         /// </summary>
@@ -7938,7 +7961,14 @@ public override Ast Copy()
         {
             var newExpression = CopyElement(this.Expression);
             var newMember = CopyElement(this.Member);
-            return new MemberExpressionAst(this.Extent, newExpression, newMember, this.Static, this.NullConditional);
+
+            return new MemberExpressionAst(
+                this.Extent,
+                newExpression,
+                newMember,
+                this.Static,
+                this.NullConditional,
+                this.GenericTypeArguments);
         }
 
         #region Visitors
@@ -7986,11 +8016,18 @@ public class InvokeMemberExpressionAst : MemberExpressionAst, ISupportsAssignmen
         /// <param name="static">
         /// True if the invocation is for a static method, using '::', false if invoking a method on an instance using '.'.
         /// </param>
+        /// <param name="genericTypes">The generic type arguments passed to the method.</param>
         /// <exception cref="PSArgumentNullException">
         /// If <paramref name="extent"/> is null.
         /// </exception>
-        public InvokeMemberExpressionAst(IScriptExtent extent, ExpressionAst expression, CommandElementAst method, IEnumerable<ExpressionAst> arguments, bool @static)
-            : base(extent, expression, method, @static)
+        public InvokeMemberExpressionAst(
+            IScriptExtent extent,
+            ExpressionAst expression,
+            CommandElementAst method,
+            IEnumerable<ExpressionAst> arguments,
+            bool @static,
+            IEnumerable<ITypeName> genericTypes = null)
+            : base(extent, expression, method, @static, genericTypes)
         {
             if (arguments != null && arguments.Any())
             {
@@ -8013,11 +8050,19 @@ public InvokeMemberExpressionAst(IScriptExtent extent, ExpressionAst expression,
         /// True if the invocation is for a static method, using '::', false if invoking a method on an instance using '.' or '?.'.
         /// </param>
         /// <param name="nullConditional">True if the operator used is '?.'.</param>
+        /// <param name="genericTypes">The generic type arguments passed to the method.</param>
         /// <exception cref="PSArgumentNullException">
         /// If <paramref name="extent"/> is null.
         /// </exception>
-        public InvokeMemberExpressionAst(IScriptExtent extent, ExpressionAst expression, CommandElementAst method, IEnumerable<ExpressionAst> arguments, bool @static, bool nullConditional)
-            : this(extent, expression, method, arguments, @static)
+        public InvokeMemberExpressionAst(
+            IScriptExtent extent,
+            ExpressionAst expression,
+            CommandElementAst method,
+            IEnumerable<ExpressionAst> arguments,
+            bool @static,
+            bool nullConditional,
+            IEnumerable<ITypeName> genericTypes = null)
+            : this(extent, expression, method, arguments, @static, genericTypes)
         {
             this.NullConditional = nullConditional;
         }
@@ -8035,7 +8080,15 @@ public override Ast Copy()
             var newExpression = CopyElement(this.Expression);
             var newMethod = CopyElement(this.Member);
             var newArguments = CopyElements(this.Arguments);
-            return new InvokeMemberExpressionAst(this.Extent, newExpression, newMethod, newArguments, this.Static, this.NullConditional);
+
+            return new InvokeMemberExpressionAst(
+                this.Extent,
+                newExpression,
+                newMethod,
+                newArguments,
+                this.Static,
+                this.NullConditional,
+                this.GenericTypeArguments);
         }
 
         #region Visitors

From 7ced98cf9fd2391170f00472ce88497590990478 Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Wed, 22 Apr 2020 01:02:56 -0400
Subject: [PATCH 02/16] :sparkles: Add member binding logic

- Adds member binding logic which works via invocation constraints

- Ensures that only an appropriate generic method can be bound if
generic type arguments are specified.
---
 .../engine/CoreAdapter.cs                     | 37 ++++++++++++----
 .../engine/MshMemberInfo.cs                   | 40 ++++++++++++++++--
 .../engine/parser/Compiler.cs                 | 42 ++++++++++++-------
 3 files changed, 94 insertions(+), 25 deletions(-)

diff --git a/src/System.Management.Automation/engine/CoreAdapter.cs b/src/System.Management.Automation/engine/CoreAdapter.cs
index bf9775b35ef..fa8d6015d9e 100644
--- a/src/System.Management.Automation/engine/CoreAdapter.cs
+++ b/src/System.Management.Automation/engine/CoreAdapter.cs
@@ -1394,32 +1394,37 @@ private static MethodInformation FindBestMethodImpl(
             // be turned into an array.
             // We also skip the optimization if the number of arguments and parameters is different
             // so we let the loop deal with possible optional parameters.
-            if ((methods.Length == 1) &&
-                (!methods[0].hasVarArgs) &&
-                (!methods[0].isGeneric) &&
-                (methods[0].method == null || !(methods[0].method.DeclaringType.IsGenericTypeDefinition)) &&
+            if (methods.Length == 1
+                && !methods[0].hasVarArgs
                 // generic methods need to be double checked in a loop below - generic methods can be rejected if type inference fails
-                (methods[0].parameters.Length == arguments.Length))
+                && !methods[0].isGeneric
+                && (methods[0].method == null || !(methods[0].method.DeclaringType.IsGenericTypeDefinition))
+                && methods[0].parameters.Length == arguments.Length)
             {
                 return methods[0];
             }
 
             Type[] argumentTypes = arguments.Select(EffectiveArgumentType).ToArray();
+            Type[] genericParameters = invocationConstraints?.GenericTypeParameters ?? Array.Empty<Type>();
             List<OverloadCandidate> candidates = new List<OverloadCandidate>();
             for (int i = 0; i < methods.Length; i++)
             {
                 MethodInformation method = methods[i];
 
-                if (method.method != null && method.method.DeclaringType.IsGenericTypeDefinition)
+                if (method.method != null && method.method.DeclaringType.IsGenericTypeDefinition
+                    || !method.isGeneric && genericParameters.Length > 0)
                 {
-                    continue; // skip methods defined by an *open* generic type
+                    // If method is defined by an *open* generic type, or
+                    // if generic parameters were provided and this method isn't generic, skip it.
+                    continue;
                 }
 
                 if (method.isGeneric)
                 {
                     Type[] argumentTypesForTypeInference = new Type[argumentTypes.Length];
                     Array.Copy(argumentTypes, argumentTypesForTypeInference, argumentTypes.Length);
-                    if (invocationConstraints != null && invocationConstraints.ParameterTypes != null)
+
+                    if (invocationConstraints?.ParameterTypes != null)
                     {
                         int parameterIndex = 0;
                         foreach (Type typeConstraintFromCallSite in invocationConstraints.ParameterTypes)
@@ -1433,6 +1438,22 @@ private static MethodInformation FindBestMethodImpl(
                         }
                     }
 
+                    if (genericParameters?.Length > 0 && method.method is MethodInfo originalMethod)
+                    {
+                        try
+                        {
+                            method = new MethodInformation(
+                                originalMethod.MakeGenericMethod(genericParameters),
+                                parametersToIgnore: 0);
+                        }
+                        catch (ArgumentException)
+                        {
+                            // Just skip this possibility if the generic type parameters can't be used to make
+                            // a valid generic method here.
+                            continue;
+                        }
+                    }
+
                     method = TypeInference.Infer(method, argumentTypesForTypeInference);
                     if (method == null)
                     {
diff --git a/src/System.Management.Automation/engine/MshMemberInfo.cs b/src/System.Management.Automation/engine/MshMemberInfo.cs
index 73ee243f6e8..4d58863a9f7 100644
--- a/src/System.Management.Automation/engine/MshMemberInfo.cs
+++ b/src/System.Management.Automation/engine/MshMemberInfo.cs
@@ -1909,9 +1909,18 @@ internal class PSMethodInvocationConstraints
         internal PSMethodInvocationConstraints(
             Type methodTargetType,
             Type[] parameterTypes)
+            : this(methodTargetType, genericTypeParameters: null, parameterTypes)
         {
-            this.MethodTargetType = methodTargetType;
+        }
+
+        internal PSMethodInvocationConstraints(
+            Type methodTargetType,
+            Type[] genericTypeParameters,
+            Type[] parameterTypes)
+        {
+            MethodTargetType = methodTargetType;
             _parameterTypes = parameterTypes;
+            GenericTypeParameters = genericTypeParameters?.ToArray() ?? Array.Empty<Type>();
         }
 
         /// <remarks>
@@ -1926,6 +1935,11 @@ internal PSMethodInvocationConstraints(
 
         private readonly Type[] _parameterTypes;
 
+        /// <summary>
+        /// Gets the generic type parameters for the method invocation.
+        /// </summary>
+        public Type[] GenericTypeParameters { get; private set; }
+
         internal static bool EqualsForCollection<T>(ICollection<T> xs, ICollection<T> ys)
         {
             if (xs == null)
@@ -1946,8 +1960,6 @@ internal static bool EqualsForCollection<T>(ICollection<T> xs, ICollection<T> ys
             return xs.SequenceEqual(ys);
         }
 
-        // TODO: IEnumerable<Type> genericTypeParameters { get; private set; }
-
         public bool Equals(PSMethodInvocationConstraints other)
         {
             if (other is null)
@@ -1970,6 +1982,11 @@ public bool Equals(PSMethodInvocationConstraints other)
                 return false;
             }
 
+            if (!EqualsForCollection(GenericTypeParameters, other.GenericTypeParameters))
+            {
+                return false;
+            }
+
             return true;
         }
 
@@ -2002,6 +2019,7 @@ public override int GetHashCode()
 
                 result = result * 397 + (MethodTargetType != null ? MethodTargetType.GetHashCode() : 0);
                 result = result * 397 + ParameterTypes.SequenceGetHashCode();
+                result = result * 397 + GenericTypeParameters.SequenceGetHashCode();
 
                 return result;
             }
@@ -2018,6 +2036,22 @@ public override string ToString()
                 separator = " ";
             }
 
+            if (GenericTypeParameters.Length != 0)
+            {
+                sb.Append(separator);
+                sb.Append("genericTypeParams: ");
+
+                separator = string.Empty;
+                foreach (Type parameter in GenericTypeParameters)
+                {
+                    sb.Append(separator);
+                    sb.Append(ToStringCodeMethods.Type(parameter, dropNamespaces: true));
+                    separator = ", ";
+                }
+
+                separator = " ";
+            }
+
             if (_parameterTypes != null)
             {
                 sb.Append(separator);
diff --git a/src/System.Management.Automation/engine/parser/Compiler.cs b/src/System.Management.Automation/engine/parser/Compiler.cs
index 14057f05f68..fc9c1ba1627 100644
--- a/src/System.Management.Automation/engine/parser/Compiler.cs
+++ b/src/System.Management.Automation/engine/parser/Compiler.cs
@@ -1172,24 +1172,30 @@ internal static Type GetTypeConstraintForMethodResolution(ExpressionAst expr)
             return firstConvert?.Type.TypeName.GetReflectionType();
         }
 
-        internal static PSMethodInvocationConstraints CombineTypeConstraintForMethodResolution(Type targetType, Type argType)
+        internal static PSMethodInvocationConstraints CombineTypeConstraintForMethodResolution(
+            Type targetType,
+            Type argType,
+            Type[] genericArguments = null)
         {
-            if (targetType == null && argType == null)
+            if (targetType == null && argType == null && !(genericArguments?.Length > 0))
             {
                 return null;
             }
 
-            return new PSMethodInvocationConstraints(targetType, new[] { argType });
+            return new PSMethodInvocationConstraints(targetType, genericArguments, new[] { argType });
         }
 
-        internal static PSMethodInvocationConstraints CombineTypeConstraintForMethodResolution(Type targetType, Type[] argTypes)
+        internal static PSMethodInvocationConstraints CombineTypeConstraintForMethodResolution(
+            Type targetType,
+            Type[] argTypes,
+            Type[] genericArguments = null)
         {
-            if (targetType == null && (argTypes == null || argTypes.Length == 0))
+            if (targetType == null && !(argTypes?.Length > 0) && !(genericArguments?.Length > 0))
             {
                 return null;
             }
 
-            return new PSMethodInvocationConstraints(targetType, argTypes);
+            return new PSMethodInvocationConstraints(targetType, genericArguments, argTypes);
         }
 
         internal static Expression ConvertValue(TypeConstraintAst typeConstraint, Expression expr)
@@ -6310,18 +6316,28 @@ public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
 
         internal static PSMethodInvocationConstraints GetInvokeMemberConstraints(InvokeMemberExpressionAst invokeMemberExpressionAst)
         {
-            var arguments = invokeMemberExpressionAst.Arguments;
+            var arguments = invokeMemberExpressionAst.Arguments
+                ?.Select(Compiler.GetTypeConstraintForMethodResolution)
+                .ToArray();
             var targetTypeConstraint = GetTypeConstraintForMethodResolution(invokeMemberExpressionAst.Expression);
-            return CombineTypeConstraintForMethodResolution(
-                    targetTypeConstraint,
-                    arguments?.Select(Compiler.GetTypeConstraintForMethodResolution).ToArray());
+            var genericArguments = invokeMemberExpressionAst.GenericTypeArguments
+                ?.Select(t => t.GetReflectionType())
+                .ToArray();
+
+            return CombineTypeConstraintForMethodResolution(targetTypeConstraint, arguments, genericArguments);
         }
 
         internal static PSMethodInvocationConstraints GetInvokeMemberConstraints(BaseCtorInvokeMemberExpressionAst invokeMemberExpressionAst)
         {
             Type targetTypeConstraint = null;
-            var arguments = invokeMemberExpressionAst.Arguments;
+            var arguments = invokeMemberExpressionAst.Arguments
+                ?.Select(Compiler.GetTypeConstraintForMethodResolution)
+                .ToArray();
             TypeDefinitionAst typeDefinitionAst = Ast.GetAncestorTypeDefinitionAst(invokeMemberExpressionAst);
+            var genericArguments = invokeMemberExpressionAst.GenericTypeArguments
+                ?.Select(t => t.GetReflectionType())
+                .ToArray();
+
             if (typeDefinitionAst != null)
             {
                 targetTypeConstraint = (typeDefinitionAst as TypeDefinitionAst).Type.BaseType;
@@ -6331,9 +6347,7 @@ internal static PSMethodInvocationConstraints GetInvokeMemberConstraints(BaseCto
                 Diagnostics.Assert(false, "BaseCtorInvokeMemberExpressionAst must be used only inside TypeDefinitionAst");
             }
 
-            return CombineTypeConstraintForMethodResolution(
-                    targetTypeConstraint,
-                    arguments?.Select(Compiler.GetTypeConstraintForMethodResolution).ToArray());
+            return CombineTypeConstraintForMethodResolution(targetTypeConstraint, arguments, genericArguments);
         }
 
         internal Expression InvokeMember(

From b0cf91d950d0326f252580c88a0a38ad3d45e051 Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Wed, 22 Apr 2020 01:05:53 -0400
Subject: [PATCH 03/16] :art: Add tab completion support

- Enables tab completion of types for generic method args
---
 .../engine/CommandCompletion/CompletionAnalysis.cs          | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs b/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs
index 76be6418805..528e57b8333 100644
--- a/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs
+++ b/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs
@@ -2102,6 +2102,12 @@ private List<CompletionResult> GetResultForIdentifier(CompletionContext completi
             result = CompletionCompleters.CompleteCommandArgument(completionContext);
             replacementIndex = completionContext.ReplacementIndex;
             replacementLength = completionContext.ReplacementLength;
+
+            if (result.Count == 0 && completionContext.TokenAtCursor.TokenFlags.HasFlag(TokenFlags.TypeName))
+            {
+                result = CompletionCompleters.CompleteType(completionContext.TokenAtCursor.Text).ToList();
+            }
+
             return result;
         }
 

From 4d70f8c6ffd445ce868cdf4a4038fb57a22b2ff6 Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Wed, 22 Apr 2020 09:02:39 -0400
Subject: [PATCH 04/16] :wrench: Narrow completion to MemberExpressionAst

---
 .../engine/CommandCompletion/CompletionAnalysis.cs            | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs b/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs
index 528e57b8333..4e8a526757f 100644
--- a/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs
+++ b/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs
@@ -2103,7 +2103,9 @@ private List<CompletionResult> GetResultForIdentifier(CompletionContext completi
             replacementIndex = completionContext.ReplacementIndex;
             replacementLength = completionContext.ReplacementLength;
 
-            if (result.Count == 0 && completionContext.TokenAtCursor.TokenFlags.HasFlag(TokenFlags.TypeName))
+            if (result.Count == 0
+                && lastAst?.Find(a => a is MemberExpressionAst, searchNestedScriptBlocks: false) != null
+                && completionContext.TokenAtCursor.TokenFlags.HasFlag(TokenFlags.TypeName))
             {
                 result = CompletionCompleters.CompleteType(completionContext.TokenAtCursor.Text).ToList();
             }

From 2c79dc15b376cb1ae4067a7631a4c822ea6e7cc6 Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Wed, 22 Apr 2020 01:06:38 -0400
Subject: [PATCH 05/16] :white_check_mark: Add tests for generic methods

---
 .../Parser/MethodInvocation.Tests.ps1         | 79 +++++++++++++++++++
 1 file changed, 79 insertions(+)

diff --git a/test/powershell/Language/Parser/MethodInvocation.Tests.ps1 b/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
index f28b6801389..02b7b9d290d 100644
--- a/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
+++ b/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
@@ -81,3 +81,82 @@ namespace MSFT_716893
         ([MSFT_716893.IInterface1]$proxy).BaseOperation(22) | Should -Be "3 - 22"
     }
 }
+
+Describe 'Generic Method invocation' {
+
+    BeforeAll {
+        $EmptyArrayCases = @(
+            @{
+                Script       = '[Array]::Empty[string]()'
+                ExpectedType = [string[]]
+            }
+            @{
+                Script       = '[Array]::Empty[System.Collections.Generic.Dictionary[System.Numerics.BigInteger, System.Collections.Generic.List[string[,]]]]()'
+                ExpectedType = [System.Collections.Generic.Dictionary[System.Numerics.BigInteger, System.Collections.Generic.List[string[, ]]][]]
+            }
+            @{
+                Script       = '[Array]::$("Empty")[[System.Collections.Generic.Dictionary[[System.String, System.Private.CoreLib],[System.Numerics.BigInteger, System.Runtime.Numerics]], System.Private.CoreLib]]()'
+                ExpectedType = [System.Collections.Generic.Dictionary`2[[System.String, System.Private.CoreLib], [System.Numerics.BigInteger, System.Runtime.Numerics]][], System.Private.CoreLib]
+            }
+        )
+    }
+
+    It 'does not throw a parse error for "<Script>"' -TestCases $EmptyArrayCases {
+        param($Script)
+
+        { [scriptblock]::Create($script) } | Should -Not -Throw
+    }
+
+    It 'can call a generic method "<Script>" with no arguments' -TestCases $EmptyArrayCases {
+        param($Script, $ExpectedType)
+
+        $Result = & [scriptblock]::Create($Script)
+        $Result.GetType() | Should -Be $ExpectedType
+
+        $Result.Length | Should -Be 0
+    }
+
+    It 'can call generic instance methods' {
+        $dictionary = [System.Collections.Concurrent.ConcurrentDictionary[string, int]]::new()
+
+        $addEntryScript = {
+            param($key, $float)
+
+            if ($float -gt 0.5) {
+                return 10
+            }
+            else {
+                return 1
+            }
+        }
+
+        $updateEntryScript = {
+            param($key, $currentValue, $float)
+
+            if ($currentValue / $float -gt 2) {
+                return 5
+            }
+            else {
+                return 0
+            }
+        }
+
+        $FloatValue = 0.4
+        $Key = 'Test'
+
+        # Add entry
+        $dictionary.AddOrUpdate[float]($Key, $addEntryScript, $updateEntryScript, $FloatValue)
+        $dictionary.$Key | Should -Be 1
+
+        # Update entry
+        $dictionary.AddOrUpdate[float]($Key, $addEntryScript, $updateEntryScript, $FloatValue)
+        $dictionary.$Key | Should -Be 5
+    }
+
+    It 'can call generic static methods with arguments' {
+        [System.Linq.Enumerable]::Select[int, int](
+            [int[]](0..10),
+            [func[int, int]]{ $args[0] + 2 }
+        ) | Should -Be @(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+    }
+}

From 46becfd913bbe55f3c03429743430e37fe333f7a Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Wed, 10 Jun 2020 19:51:25 -0400
Subject: [PATCH 06/16] :white_check_mark: Add tests for incomplete input

---
 .../Parser/MethodInvocation.Tests.ps1         | 30 ++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/test/powershell/Language/Parser/MethodInvocation.Tests.ps1 b/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
index 02b7b9d290d..ab8c583dd73 100644
--- a/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
+++ b/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
@@ -99,6 +99,24 @@ Describe 'Generic Method invocation' {
                 ExpectedType = [System.Collections.Generic.Dictionary`2[[System.String, System.Private.CoreLib], [System.Numerics.BigInteger, System.Runtime.Numerics]][], System.Private.CoreLib]
             }
         )
+
+        $ExpectedParseErrors = @(
+            @{
+                Script          = '$object.Method[incompl'
+                ExpectedErrors  = 'EndSquareBracketExpectedAtEndOfType'
+                ErrorCount      = 1
+            }
+            @{
+                Script          = '[type]::Member[incompl'
+                ExpectedErrors  = 'EndSquareBracketExpectedAtEndOfType'
+                ErrorCount      = 1
+            }
+            @{
+                Script          = '$object.Method[Type1[Type2'
+                ExpectedErrors  = 'UnexpectedToken','EndSquareBracketExpectedAtEndOfType'
+                ErrorCount      = 2
+            }
+        )
     }
 
     It 'does not throw a parse error for "<Script>"' -TestCases $EmptyArrayCases {
@@ -107,6 +125,16 @@ Describe 'Generic Method invocation' {
         { [scriptblock]::Create($script) } | Should -Not -Throw
     }
 
+    It 'reports a parse error for "<Script>"' -TestCases $ExpectedParseErrors {
+        param($Script, $ExpectedError, $ErrorCount)
+
+        $parseErrors = $null
+        [System.Management.Automation.Language.Parser]::ParseInput($Script, [ref]$null, [ref]$parseErrors)
+
+        $parseErrors.Count | Should -Be $ErrorCount
+        $parseErrors.ErrorId | Should -BeIn $ExpectedError
+    }
+
     It 'can call a generic method "<Script>" with no arguments' -TestCases $EmptyArrayCases {
         param($Script, $ExpectedType)
 
@@ -156,7 +184,7 @@ Describe 'Generic Method invocation' {
     It 'can call generic static methods with arguments' {
         [System.Linq.Enumerable]::Select[int, int](
             [int[]](0..10),
-            [func[int, int]]{ $args[0] + 2 }
+            [func[int, int]] { $args[0] + 2 }
         ) | Should -Be @(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
     }
 }

From a41cd197203db018e2743f87a20020b38dc7ff12 Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Wed, 3 Jun 2020 00:19:53 -0400
Subject: [PATCH 07/16] :recycle: Address review comments

---
 .../CommandCompletion/CompletionAnalysis.cs   |  4 +-
 .../engine/CoreAdapter.cs                     | 30 +++----
 .../engine/MshMemberInfo.cs                   | 18 ++--
 .../engine/parser/Compiler.cs                 | 67 ++++++++++----
 .../engine/parser/Parser.cs                   | 87 ++++++++++---------
 .../engine/parser/ast.cs                      | 22 ++---
 .../Parser/MethodInvocation.Tests.ps1         |  2 +-
 7 files changed, 134 insertions(+), 96 deletions(-)

diff --git a/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs b/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs
index 4e8a526757f..7fbd7b751b3 100644
--- a/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs
+++ b/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs
@@ -2104,8 +2104,8 @@ private List<CompletionResult> GetResultForIdentifier(CompletionContext completi
             replacementLength = completionContext.ReplacementLength;
 
             if (result.Count == 0
-                && lastAst?.Find(a => a is MemberExpressionAst, searchNestedScriptBlocks: false) != null
-                && completionContext.TokenAtCursor.TokenFlags.HasFlag(TokenFlags.TypeName))
+                && completionContext.TokenAtCursor.TokenFlags.HasFlag(TokenFlags.TypeName)
+                && lastAst?.Find(a => a is MemberExpressionAst, searchNestedScriptBlocks: false) is not null)
             {
                 result = CompletionCompleters.CompleteType(completionContext.TokenAtCursor.Text).ToList();
             }
diff --git a/src/System.Management.Automation/engine/CoreAdapter.cs b/src/System.Management.Automation/engine/CoreAdapter.cs
index fa8d6015d9e..d9cd243add5 100644
--- a/src/System.Management.Automation/engine/CoreAdapter.cs
+++ b/src/System.Management.Automation/engine/CoreAdapter.cs
@@ -1398,7 +1398,7 @@ private static MethodInformation FindBestMethodImpl(
                 && !methods[0].hasVarArgs
                 // generic methods need to be double checked in a loop below - generic methods can be rejected if type inference fails
                 && !methods[0].isGeneric
-                && (methods[0].method == null || !(methods[0].method.DeclaringType.IsGenericTypeDefinition))
+                && (methods[0].method is null || !(methods[0].method.DeclaringType.IsGenericTypeDefinition))
                 && methods[0].parameters.Length == arguments.Length)
             {
                 return methods[0];
@@ -1409,17 +1409,17 @@ private static MethodInformation FindBestMethodImpl(
             List<OverloadCandidate> candidates = new List<OverloadCandidate>();
             for (int i = 0; i < methods.Length; i++)
             {
-                MethodInformation method = methods[i];
+                MethodInformation methodInfo = methods[i];
 
-                if (method.method != null && method.method.DeclaringType.IsGenericTypeDefinition
-                    || !method.isGeneric && genericParameters.Length > 0)
+                if ((methodInfo.method is not null && methodInfo.method.DeclaringType.IsGenericTypeDefinition)
+                    || (!methodInfo.isGeneric && genericParameters.Length > 0))
                 {
                     // If method is defined by an *open* generic type, or
                     // if generic parameters were provided and this method isn't generic, skip it.
                     continue;
                 }
 
-                if (method.isGeneric)
+                if (methodInfo.isGeneric)
                 {
                     Type[] argumentTypesForTypeInference = new Type[argumentTypes.Length];
                     Array.Copy(argumentTypes, argumentTypesForTypeInference, argumentTypes.Length);
@@ -1438,11 +1438,11 @@ private static MethodInformation FindBestMethodImpl(
                         }
                     }
 
-                    if (genericParameters?.Length > 0 && method.method is MethodInfo originalMethod)
+                    if (genericParameters.Length > 0 && methodInfo.method is MethodInfo originalMethod)
                     {
                         try
                         {
-                            method = new MethodInformation(
+                            methodInfo = new MethodInformation(
                                 originalMethod.MakeGenericMethod(genericParameters),
                                 parametersToIgnore: 0);
                         }
@@ -1454,20 +1454,20 @@ private static MethodInformation FindBestMethodImpl(
                         }
                     }
 
-                    method = TypeInference.Infer(method, argumentTypesForTypeInference);
-                    if (method == null)
+                    methodInfo = TypeInference.Infer(methodInfo, argumentTypesForTypeInference);
+                    if (methodInfo == null)
                     {
                         // Skip generic methods for which we cannot infer type arguments
                         continue;
                     }
                 }
 
-                if (!IsInvocationTargetConstraintSatisfied(method, invocationConstraints))
+                if (!IsInvocationTargetConstraintSatisfied(methodInfo, invocationConstraints))
                 {
                     continue;
                 }
 
-                ParameterInformation[] parameters = method.parameters;
+                ParameterInformation[] parameters = methodInfo.parameters;
                 if (arguments.Length != parameters.Length)
                 {
                     // Skip methods w/ an incorrect # of arguments.
@@ -1475,7 +1475,7 @@ private static MethodInformation FindBestMethodImpl(
                     if (arguments.Length > parameters.Length)
                     {
                         // If too many args,it's only OK if the method is varargs.
-                        if (!method.hasVarArgs)
+                        if (!methodInfo.hasVarArgs)
                         {
                             continue;
                         }
@@ -1483,12 +1483,12 @@ private static MethodInformation FindBestMethodImpl(
                     else
                     {
                         // Too few args, OK if there are optionals, or varargs with the param array omitted
-                        if (!method.hasOptional && (!method.hasVarArgs || (arguments.Length + 1) != parameters.Length))
+                        if (!methodInfo.hasOptional && (!methodInfo.hasVarArgs || (arguments.Length + 1) != parameters.Length))
                         {
                             continue;
                         }
 
-                        if (method.hasOptional)
+                        if (methodInfo.hasOptional)
                         {
                             // Count optionals.  This code is rarely hit, mainly when calling code in the
                             // assembly Microsoft.VisualBasic.  If it were more frequent, the optional count
@@ -1511,7 +1511,7 @@ private static MethodInformation FindBestMethodImpl(
                     }
                 }
 
-                OverloadCandidate candidate = new OverloadCandidate(method, arguments.Length);
+                OverloadCandidate candidate = new OverloadCandidate(methodInfo, arguments.Length);
                 for (int j = 0; candidate != null && j < parameters.Length; j++)
                 {
                     ParameterInformation parameter = parameters[j];
diff --git a/src/System.Management.Automation/engine/MshMemberInfo.cs b/src/System.Management.Automation/engine/MshMemberInfo.cs
index 4d58863a9f7..11fbe552ec1 100644
--- a/src/System.Management.Automation/engine/MshMemberInfo.cs
+++ b/src/System.Management.Automation/engine/MshMemberInfo.cs
@@ -1920,7 +1920,7 @@ internal PSMethodInvocationConstraints(
         {
             MethodTargetType = methodTargetType;
             _parameterTypes = parameterTypes;
-            GenericTypeParameters = genericTypeParameters?.ToArray() ?? Array.Empty<Type>();
+            GenericTypeParameters = genericTypeParameters ?? Array.Empty<Type>();
         }
 
         /// <remarks>
@@ -1938,7 +1938,7 @@ internal PSMethodInvocationConstraints(
         /// <summary>
         /// Gets the generic type parameters for the method invocation.
         /// </summary>
-        public Type[] GenericTypeParameters { get; private set; }
+        public Type[] GenericTypeParameters { get; }
 
         internal static bool EqualsForCollection<T>(ICollection<T> xs, ICollection<T> ys)
         {
@@ -2017,9 +2017,9 @@ public override int GetHashCode()
             {
                 int result = 61;
 
-                result = result * 397 + (MethodTargetType != null ? MethodTargetType.GetHashCode() : 0);
-                result = result * 397 + ParameterTypes.SequenceGetHashCode();
-                result = result * 397 + GenericTypeParameters.SequenceGetHashCode();
+                result = (result * 397) + (MethodTargetType != null ? MethodTargetType.GetHashCode() : 0);
+                result = (result * 397) + ParameterTypes.SequenceGetHashCode();
+                result = (result * 397) + GenericTypeParameters.SequenceGetHashCode();
 
                 return result;
             }
@@ -5069,7 +5069,7 @@ internal struct Enumerator : IEnumerator<T>
             private readonly PSMemberInfoInternalCollection<T> _allMembers;
 
             /// <summary>
-            /// Constructs this instance to enumerate over members.
+            /// Initializes a new instance of the <see cref="Enumerator"/> class to enumerate over members.
             /// </summary>
             /// <param name="integratingCollection">Members we are enumerating.</param>
             internal Enumerator(PSMemberInfoIntegratingCollection<T> integratingCollection)
@@ -5097,8 +5097,8 @@ internal Enumerator(PSMemberInfoIntegratingCollection<T> integratingCollection)
             /// Moves to the next element in the enumeration.
             /// </summary>
             /// <returns>
-            /// false if there are no more elements to enumerate
-            /// true otherwise
+            /// If there are no more elements to enumerate, returns false.
+            /// Returns true otherwise.
             /// </returns>
             public bool MoveNext()
             {
@@ -5127,7 +5127,7 @@ public bool MoveNext()
             }
 
             /// <summary>
-            /// Current PSMemberInfo in the enumeration.
+            /// Gets the current PSMemberInfo in the enumeration.
             /// </summary>
             /// <exception cref="ArgumentException">For invalid arguments.</exception>
             T IEnumerator<T>.Current
diff --git a/src/System.Management.Automation/engine/parser/Compiler.cs b/src/System.Management.Automation/engine/parser/Compiler.cs
index fc9c1ba1627..7f2b7bf57e3 100644
--- a/src/System.Management.Automation/engine/parser/Compiler.cs
+++ b/src/System.Management.Automation/engine/parser/Compiler.cs
@@ -1177,7 +1177,9 @@ internal static PSMethodInvocationConstraints CombineTypeConstraintForMethodReso
             Type argType,
             Type[] genericArguments = null)
         {
-            if (targetType == null && argType == null && !(genericArguments?.Length > 0))
+            if (targetType is null
+                && argType is null
+                && (genericArguments is null || genericArguments.Length == 0))
             {
                 return null;
             }
@@ -1190,7 +1192,9 @@ internal static PSMethodInvocationConstraints CombineTypeConstraintForMethodReso
             Type[] argTypes,
             Type[] genericArguments = null)
         {
-            if (targetType == null && !(argTypes?.Length > 0) && !(genericArguments?.Length > 0))
+            if (targetType is null
+                && (argTypes is null || argTypes.Length == 0)
+                && (genericArguments is null || genericArguments.Length == 0))
             {
                 return null;
             }
@@ -6316,27 +6320,58 @@ public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
 
         internal static PSMethodInvocationConstraints GetInvokeMemberConstraints(InvokeMemberExpressionAst invokeMemberExpressionAst)
         {
-            var arguments = invokeMemberExpressionAst.Arguments
-                ?.Select(Compiler.GetTypeConstraintForMethodResolution)
-                .ToArray();
+            ReadOnlyCollection<ExpressionAst> arguments = invokeMemberExpressionAst.Arguments;
+            Type[] argumentTypes = null;
+            if (arguments is not null)
+            {
+                argumentTypes = new Type[arguments.Count];
+                for (var i = 0; i < arguments.Count; i++)
+                {
+                    argumentTypes[i] = GetTypeConstraintForMethodResolution(arguments[i]);
+                }
+            }
+
             var targetTypeConstraint = GetTypeConstraintForMethodResolution(invokeMemberExpressionAst.Expression);
-            var genericArguments = invokeMemberExpressionAst.GenericTypeArguments
-                ?.Select(t => t.GetReflectionType())
-                .ToArray();
 
-            return CombineTypeConstraintForMethodResolution(targetTypeConstraint, arguments, genericArguments);
+            ReadOnlyCollection<ITypeName> genericArguments = invokeMemberExpressionAst.GenericTypeArguments;
+            Type[] genericTypeArguments = null;
+            if (genericArguments is not null)
+            {
+                genericTypeArguments = new Type[genericArguments.Count];
+
+                for (var i = 0; i < genericArguments.Count; i++)
+                {
+                    genericTypeArguments[i] = genericArguments[i].GetReflectionType();
+                }
+            }
+
+            return CombineTypeConstraintForMethodResolution(targetTypeConstraint, argumentTypes, genericTypeArguments);
         }
 
         internal static PSMethodInvocationConstraints GetInvokeMemberConstraints(BaseCtorInvokeMemberExpressionAst invokeMemberExpressionAst)
         {
             Type targetTypeConstraint = null;
-            var arguments = invokeMemberExpressionAst.Arguments
-                ?.Select(Compiler.GetTypeConstraintForMethodResolution)
-                .ToArray();
+            Type[] argumentTypes = null;
+            if (invokeMemberExpressionAst.Arguments is not null)
+            {
+                argumentTypes = new Type[invokeMemberExpressionAst.Arguments.Count];
+                for (var i = 0; i < invokeMemberExpressionAst.Arguments.Count; i++)
+                {
+                    argumentTypes[i] = GetTypeConstraintForMethodResolution(invokeMemberExpressionAst.Arguments[i]);
+                }
+            }
+
             TypeDefinitionAst typeDefinitionAst = Ast.GetAncestorTypeDefinitionAst(invokeMemberExpressionAst);
-            var genericArguments = invokeMemberExpressionAst.GenericTypeArguments
-                ?.Select(t => t.GetReflectionType())
-                .ToArray();
+
+            Type[] genericArguments = null;
+            if (invokeMemberExpressionAst.GenericTypeArguments.Count > 0)
+            {
+                genericArguments = new Type[invokeMemberExpressionAst.GenericTypeArguments.Count];
+                for (var i = 0; i < invokeMemberExpressionAst.GenericTypeArguments.Count; i++)
+                {
+                    genericArguments[i] = invokeMemberExpressionAst.GenericTypeArguments[i].GetReflectionType();
+                }
+            }
 
             if (typeDefinitionAst != null)
             {
@@ -6347,7 +6382,7 @@ internal static PSMethodInvocationConstraints GetInvokeMemberConstraints(BaseCto
                 Diagnostics.Assert(false, "BaseCtorInvokeMemberExpressionAst must be used only inside TypeDefinitionAst");
             }
 
-            return CombineTypeConstraintForMethodResolution(targetTypeConstraint, arguments, genericArguments);
+            return CombineTypeConstraintForMethodResolution(targetTypeConstraint, argumentTypes, genericArguments);
         }
 
         internal Expression InvokeMember(
diff --git a/src/System.Management.Automation/engine/parser/Parser.cs b/src/System.Management.Automation/engine/parser/Parser.cs
index 400fdeca599..43173aeec5f 100644
--- a/src/System.Management.Automation/engine/parser/Parser.cs
+++ b/src/System.Management.Automation/engine/parser/Parser.cs
@@ -1357,7 +1357,7 @@ private ITypeName FinishTypeNameRule(Token typeName, bool unBracketedGenericArg
 
                     case TokenKind.LBracket:
                     case TokenKind.Identifier:
-                        return GenericTypeArgumentsRule(typeName, token, unBracketedGenericArg);
+                        return GenericTypeNameRule(typeName, token, unBracketedGenericArg);
 
                     default:
                         // ErrorRecovery: sync to ']', and return non-null to avoid cascading errors.
@@ -1437,7 +1437,7 @@ private ITypeName GetSingleGenericArgument(Token firstToken)
             return typeName;
         }
 
-        private List<ITypeName> GenericArgumentsRule(Token firstToken, bool unBracketedGenericArg, out Token lastToken)
+        private List<ITypeName> GenericTypeArgumentsRule(Token firstToken, bool unbracketedGenericArg, out Token lastToken)
         {
             Diagnostics.Assert(firstToken.Kind == TokenKind.Identifier || firstToken.Kind == TokenKind.LBracket, "unexpected first token");
             RuntimeHelpers.EnsureSufficientExecutionStack();
@@ -1479,9 +1479,9 @@ private List<ITypeName> GenericArgumentsRule(Token firstToken, bool unBracketedG
             return genericArguments;
         }
 
-        private ITypeName GenericTypeArgumentsRule(Token genericTypeName, Token firstToken, bool unBracketedGenericArg)
+        private ITypeName GenericTypeNameRule(Token genericTypeName, Token firstToken, bool unbracketedGenericArg)
         {
-            List<ITypeName> genericArguments = GenericArgumentsRule(firstToken, unBracketedGenericArg, out Token rBracketToken);
+            List<ITypeName> genericArguments = GenericTypeArgumentsRule(firstToken, unbracketedGenericArg, out Token rBracketToken);
 
             if (rBracketToken.Kind != TokenKind.RBracket)
             {
@@ -1490,7 +1490,8 @@ private ITypeName GenericTypeArgumentsRule(Token genericTypeName, Token firstTok
                 ReportIncompleteInput(
                     Before(rBracketToken),
                     nameof(ParserStrings.UnexpectedToken),
-                    ParserStrings.UnexpectedToken);
+                    ParserStrings.UnexpectedToken,
+                    rBracketToken.Text);
                 rBracketToken = null;
             }
 
@@ -1507,13 +1508,14 @@ private ITypeName GenericTypeArgumentsRule(Token genericTypeName, Token firstTok
                 return CompleteArrayTypeName(result, openGenericType, NextToken());
             }
 
-            if (token.Kind == TokenKind.Comma && !unBracketedGenericArg)
+            if (token.Kind == TokenKind.Comma && !unbracketedGenericArg)
             {
                 SkipToken();
                 string assemblyNameSpec = _tokenizer.GetAssemblyNameSpec();
                 if (string.IsNullOrEmpty(assemblyNameSpec))
                 {
-                    ReportError(After(token),
+                    ReportError(
+                        After(token),
                         nameof(ParserStrings.MissingAssemblyNameSpecification),
                         ParserStrings.MissingAssemblyNameSpecification);
                 }
@@ -7727,11 +7729,11 @@ private ExpressionAst MemberAccessRule(ExpressionAst targetExpr, Token operatorT
                 member = GetSingleCommandArgument(CommandArgumentContext.CommandArgument) ??
                     new ErrorExpressionAst(ExtentOf(targetExpr, operatorToken));
             }
-            // Member name may be an incomplete token like `$a.$(Command-Name`; do not look for generic args or
-            // invocation token(s) if the member name token is recognisably incomplete.
             else if (_ungotToken == null)
             {
-                genericTypeArguments = GenericMethodTypeArgumentsRule(out rBracket);
+                // Member name may be an incomplete token like `$a.$(Command-Name`; we do not look for generic args or
+                // invocation token(s) if the member name token is recognisably incomplete.
+                genericTypeArguments = GenericMethodArgumentsRule(out rBracket);
                 Token lParen = NextInvokeMemberToken();
 
                 if (lParen != null)
@@ -7760,7 +7762,7 @@ private ExpressionAst MemberAccessRule(ExpressionAst targetExpr, Token operatorT
                 genericTypeArguments);
         }
 
-        private List<ITypeName> GenericMethodTypeArgumentsRule(out Token rBracketToken)
+        private List<ITypeName> GenericMethodArgumentsRule(out Token rBracketToken)
         {
             List<ITypeName> genericTypes = null;
 
@@ -7768,39 +7770,44 @@ private List<ITypeName> GenericMethodTypeArgumentsRule(out Token rBracketToken)
             Token lBracket = NextToken();
             rBracketToken = null;
 
-            if (lBracket.Kind == TokenKind.LBracket)
+            if (lBracket.Kind != TokenKind.LBracket)
             {
-                // This is either a member expression with generic type arguments, or some sort of collection index
-                // on a property.
-                var oldTokenizerMode = _tokenizer.Mode;
-                try
+                // We cannot avoid this Resync(); if we use PeekToken() to try to avoid a Resync(), the method called
+                // after this (NextInvokeMemberToken()) will note that an _ungotToken is present and assume an error
+                // state. That will cause any property accesses or non-generic method calls to throw a parse error.
+                Resync(resyncIndex);
+                return null;
+            }
+
+            // This is either a member expression with generic type arguments, or some sort of collection index
+            // on a property.
+            TokenizerMode oldTokenizerMode = _tokenizer.Mode;
+            try
+            {
+                // Switch to typename mode to avoid aggressive argument tokenization.
+                SetTokenizerMode(TokenizerMode.TypeName);
+
+                SkipNewlines();
+                Token firstToken = NextToken();
+                if (firstToken.Kind == TokenKind.Identifier || firstToken.Kind == TokenKind.LBracket)
                 {
-                    // Switch to typename mode to avoid aggressive argument tokenization.
-                    SetTokenizerMode(TokenizerMode.TypeName);
+                    resyncIndex = -1;
+                    genericTypes = GenericTypeArgumentsRule(firstToken, unbracketedGenericArg: false, out rBracketToken);
 
-                    SkipNewlines();
-                    Token firstToken = NextToken();
-                    if (firstToken.Kind != TokenKind.Number
-                        && (firstToken.Kind == TokenKind.Identifier || firstToken.Kind == TokenKind.LBracket))
+                    if (rBracketToken.Kind != TokenKind.RBracket)
                     {
-                        resyncIndex = -1;
-                        genericTypes = GenericArgumentsRule(firstToken, false, out rBracketToken);
-
-                        if (rBracketToken.Kind != TokenKind.RBracket)
-                        {
-                            UngetToken(rBracketToken);
-                            ReportIncompleteInput(
-                                Before(rBracketToken),
-                                nameof(ParserStrings.EndSquareBracketExpectedAtEndOfType),
-                                ParserStrings.EndSquareBracketExpectedAtEndOfType);
-                            rBracketToken = null;
-                        }
+                        UngetToken(rBracketToken);
+                        ReportIncompleteInput(
+                            Before(rBracketToken),
+                            nameof(ParserStrings.EndSquareBracketExpectedAtEndOfType),
+                            ParserStrings.EndSquareBracketExpectedAtEndOfType);
+                        rBracketToken = null;
                     }
                 }
-                finally
-                {
-                    SetTokenizerMode(oldTokenizerMode);
-                }
+            }
+            finally
+            {
+                SetTokenizerMode(oldTokenizerMode);
             }
 
             if (resyncIndex > 0)
@@ -7816,14 +7823,13 @@ private ExpressionAst MemberInvokeRule(
             Token lBracket,
             Token operatorToken,
             CommandElementAst member,
-            IEnumerable<ITypeName> genericTypes)
+            IList<ITypeName> genericTypes)
         {
             // G  invocation-expression: target-expression passed as a parameter. lBracket can be '(' or '{'.
             // G      target-expression   member-name   invoke-param-list
             // G  invoke-param-list:
             // G      '('   invoke-param-paren-list
             // G      script-block
-
             IScriptExtent lastExtent = null;
 
             List<ExpressionAst> arguments;
@@ -7834,6 +7840,7 @@ private ExpressionAst MemberInvokeRule(
             else
             {
                 arguments = new List<ExpressionAst>();
+
                 // handle the construct $x.methodName{2+2} as through it had been written $x.methodName({2+2})
                 SkipNewlines();
                 ExpressionAst argument = ScriptBlockExpressionRule(lBracket);
diff --git a/src/System.Management.Automation/engine/parser/ast.cs b/src/System.Management.Automation/engine/parser/ast.cs
index 8c506888bca..9f1d57ac27b 100644
--- a/src/System.Management.Automation/engine/parser/ast.cs
+++ b/src/System.Management.Automation/engine/parser/ast.cs
@@ -7862,7 +7862,7 @@ internal bool IsRef()
     public class MemberExpressionAst : ExpressionAst, ISupportsAssignment
     {
         /// <summary>
-        /// Construct an ast to reference a property.
+        /// Initializes a new instance of the <see cref="MemberExpressionAst"/> class.
         /// </summary>
         /// <param name="extent">
         /// The extent of the expression, starting with the expression before the operator '.' or '::' and ending after
@@ -7882,7 +7882,7 @@ public MemberExpressionAst(
             ExpressionAst expression,
             CommandElementAst member,
             bool @static,
-            IEnumerable<ITypeName> genericTypes = null)
+            IList<ITypeName> genericTypes = null)
             : base(extent)
         {
             if (expression == null || member == null)
@@ -7895,11 +7895,7 @@ public MemberExpressionAst(
             this.Member = member;
             SetParent(member);
             this.Static = @static;
-
-            if (genericTypes?.Any() == true)
-            {
-                this.GenericTypeArguments = new ReadOnlyCollection<ITypeName>(genericTypes.ToArray());
-            }
+            this.GenericTypeArguments = new ReadOnlyCollection<ITypeName>(genericTypes ?? Array.Empty<ITypeName>());
         }
 
         /// <summary>
@@ -7923,7 +7919,7 @@ public MemberExpressionAst(
             CommandElementAst member,
             bool @static,
             bool nullConditional,
-            IEnumerable<ITypeName> genericTypes = null)
+            IList<ITypeName> genericTypes = null)
             : this(extent, expression, member, @static, genericTypes)
         {
             this.NullConditional = nullConditional;
@@ -7950,9 +7946,9 @@ public MemberExpressionAst(
         public bool NullConditional { get; protected set; }
 
         /// <summary>
-        /// List of generic type arguments passed to this member.
+        /// Gets a list of generic type arguments passed to this member.
         /// </summary>
-        public ReadOnlyCollection<ITypeName> GenericTypeArguments { get; private set; }
+        public ReadOnlyCollection<ITypeName> GenericTypeArguments { get; }
 
         /// <summary>
         /// Copy the MemberExpressionAst instance.
@@ -8004,7 +8000,7 @@ IAssignableValue ISupportsAssignment.GetAssignableValue()
     public class InvokeMemberExpressionAst : MemberExpressionAst, ISupportsAssignment
     {
         /// <summary>
-        /// Construct an instance of a method invocation expression.
+        /// Initializes a new instance of the <see cref="InvokeMemberExpressionAst"/> class.
         /// </summary>
         /// <param name="extent">
         /// The extent of the expression, starting with the expression before the invocation operator and ending with the
@@ -8026,7 +8022,7 @@ public InvokeMemberExpressionAst(
             CommandElementAst method,
             IEnumerable<ExpressionAst> arguments,
             bool @static,
-            IEnumerable<ITypeName> genericTypes = null)
+            IList<ITypeName> genericTypes = null)
             : base(extent, expression, method, @static, genericTypes)
         {
             if (arguments != null && arguments.Any())
@@ -8061,7 +8057,7 @@ public InvokeMemberExpressionAst(
             IEnumerable<ExpressionAst> arguments,
             bool @static,
             bool nullConditional,
-            IEnumerable<ITypeName> genericTypes = null)
+            IList<ITypeName> genericTypes = null)
             : this(extent, expression, method, arguments, @static, genericTypes)
         {
             this.NullConditional = nullConditional;
diff --git a/test/powershell/Language/Parser/MethodInvocation.Tests.ps1 b/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
index ab8c583dd73..cad0ff0cb2e 100644
--- a/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
+++ b/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
@@ -82,7 +82,7 @@ namespace MSFT_716893
     }
 }
 
-Describe 'Generic Method invocation' {
+Describe 'Generic Method invocation' -Tags 'CI' {
 
     BeforeAll {
         $EmptyArrayCases = @(

From 249e05fa535d9f878232e2a720774fece2a6622c Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Wed, 4 Aug 2021 23:45:03 -0400
Subject: [PATCH 08/16] :white_check_mark: Additional tests

---
 .../Parser/MethodInvocation.Tests.ps1         | 104 ++++++++++++++++--
 1 file changed, 95 insertions(+), 9 deletions(-)

diff --git a/test/powershell/Language/Parser/MethodInvocation.Tests.ps1 b/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
index cad0ff0cb2e..af729da9036 100644
--- a/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
+++ b/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
@@ -102,19 +102,54 @@ Describe 'Generic Method invocation' -Tags 'CI' {
 
         $ExpectedParseErrors = @(
             @{
-                Script          = '$object.Method[incompl'
-                ExpectedErrors  = 'EndSquareBracketExpectedAtEndOfType'
-                ErrorCount      = 1
+                Script         = '$object.Method[incompl'
+                ExpectedErrors = 'EndSquareBracketExpectedAtEndOfType'
+                ErrorCount     = 1
             }
             @{
-                Script          = '[type]::Member[incompl'
-                ExpectedErrors  = 'EndSquareBracketExpectedAtEndOfType'
-                ErrorCount      = 1
+                Script         = '[type]::Member[incompl'
+                ExpectedErrors = 'EndSquareBracketExpectedAtEndOfType'
+                ErrorCount     = 1
             }
             @{
-                Script          = '$object.Method[Type1[Type2'
-                ExpectedErrors  = 'UnexpectedToken','EndSquareBracketExpectedAtEndOfType'
-                ErrorCount      = 2
+                Script         = '$object.Method[Type1[Type2'
+                ExpectedErrors = 'UnexpectedToken','EndSquareBracketExpectedAtEndOfType'
+                ErrorCount     = 2
+            }
+            @{
+                Script         = '[array]::empty[type]]()'
+                ExpectedErrors = 'UnexpectedToken', 'ExpectedExpression'
+                ErrorCount     = 2
+            }
+            @{
+                Script         = '$object.Method[type,]()'
+                ExpectedErrors = 'MissingTypeName'
+                ErrorCount     = 1
+            }
+            @{
+                Script         = '$object.Method[]()'
+                ExpectedErrors = 'MissingArrayIndexExpression', 'UnexpectedToken', 'ExpectedExpression'
+                ErrorCount     = 3
+            }
+            @{
+                Script         = '$object.Method[,]()'
+                ExpectedErrors = 'MissingExpressionAfterOperator', 'UnexpectedToken', 'ExprectedExpression'
+                ErrorCount     = 3
+            }
+            @{
+                Script         = '$object.Method[,type]()'
+                ExpectedErrors = 'MissingExpressionAfterOperator', 'UnexpectedToken', 'ExpectedExpression'
+                ErrorCount     = 3
+            }
+            @{
+                Script         = '$object.Method[type()'
+                ExpectedErrors = 'UnexpectedToken', 'ExpectedExpression'
+                ErrorCount     = 2
+            }
+            @{
+                Script         = '$object.Method[type)'
+                ExpectedErrors = 'EndSquareBracketExpectedAtEndOfType', 'UnexpectedToken'
+                ErrorCount     = 2
             }
         )
     }
@@ -187,4 +222,55 @@ Describe 'Generic Method invocation' -Tags 'CI' {
             [func[int, int]] { $args[0] + 2 }
         ) | Should -Be @(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
     }
+
+    It 'gives a runtime error if too many type parameters are given' {
+        try {
+            [array]::Empty[string, int]()
+        }
+        catch {
+            $_.Exception.Message | Should -BeExactly 'Cannot find an overload for "Empty" and the argument count: "0".'
+            $_.FullyQualifiedErrorId | Should -BeExactly 'MethodCountCouldNotFindBest'
+        }
+    }
+
+    It 'gives a runtime error if a nonexistent type is specified' {
+        try {
+            [array]::Empty[thisdoesnotexist]()
+        }
+        catch {
+            $_.Exception.Message | Should -BeExactly 'Cannot find an overload for "empty" and the argument count: "0".'
+            $_.FullyQualifiedErrorId | Should -BeExactly 'MethodCountCouldNotFindBest'
+        }
+    }
+
+    It 'lists the same method group information with and without type parameters' {
+        $dict = [System.Collections.Concurrent.ConcurrentDictionary[string, int]]::new()
+        $noTypeParams = $dict.AddOrUpdate
+        $typeParams = $dict.AddOrUpdate[string]
+        $extraTypeParams = $dict.AddOrUpdate[string, int]
+
+        $typeParams.OverloadDefinitions | Should -BeExactly $noTypeParams.OverloadDefinitions
+        $extraTypeParams.OverloadDefinitions | Should -BeExactly $typeParams.OverloadDefinitions
+    }
+
+    It 'successfully invokes common Linq generic methods' {
+        [System.Collections.Generic.List[int]]$list = @( 1, 2, 3, 4, 5 )
+        $result = [System.Linq.Enumerable]::Select[int, float](
+            $list,
+            [Func[int, float]]{
+                param($item)
+                [math]::Pow($item, 3)
+            }
+        )
+
+        $result.GetType().Name | Should -BeExactly 'SelectListIterator`2'
+        $typeArgs = $result.GetType().GenericTypeArguments
+        $typeArgs[0] | Should -Be ([int])
+        $typeArgs[1] | Should -Be ([float])
+
+        $resultList = $result.ToList()
+        $resultList.GetType().Name | Should -Be 'List`1'
+        $resultList.GetType().GenericTypeArguments | Should -Be ([float])
+        $resultList | Should -Be @( 1, 8, 27, 64, 125)
+    }
 }

From f332eab494e1ec5e7db8d3cb3d39f5c04aa9fb54 Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Wed, 4 Aug 2021 23:55:17 -0400
Subject: [PATCH 09/16] :recycle: Address review comments

---
 .../engine/CoreAdapter.cs                          |  2 +-
 .../engine/MshMemberInfo.cs                        | 14 +-------------
 2 files changed, 2 insertions(+), 14 deletions(-)

diff --git a/src/System.Management.Automation/engine/CoreAdapter.cs b/src/System.Management.Automation/engine/CoreAdapter.cs
index d9cd243add5..5d328f2d4f1 100644
--- a/src/System.Management.Automation/engine/CoreAdapter.cs
+++ b/src/System.Management.Automation/engine/CoreAdapter.cs
@@ -1424,7 +1424,7 @@ private static MethodInformation FindBestMethodImpl(
                     Type[] argumentTypesForTypeInference = new Type[argumentTypes.Length];
                     Array.Copy(argumentTypes, argumentTypesForTypeInference, argumentTypes.Length);
 
-                    if (invocationConstraints?.ParameterTypes != null)
+                    if (invocationConstraints?.ParameterTypes is not null)
                     {
                         int parameterIndex = 0;
                         foreach (Type typeConstraintFromCallSite in invocationConstraints.ParameterTypes)
diff --git a/src/System.Management.Automation/engine/MshMemberInfo.cs b/src/System.Management.Automation/engine/MshMemberInfo.cs
index 11fbe552ec1..fe9410042ae 100644
--- a/src/System.Management.Automation/engine/MshMemberInfo.cs
+++ b/src/System.Management.Automation/engine/MshMemberInfo.cs
@@ -2011,19 +2011,7 @@ public override bool Equals(object obj)
         }
 
         public override int GetHashCode()
-        {
-            // algorithm based on https://stackoverflow.com/questions/263400/what-is-the-best-algorithm-for-an-overridden-system-object-gethashcode
-            unchecked
-            {
-                int result = 61;
-
-                result = (result * 397) + (MethodTargetType != null ? MethodTargetType.GetHashCode() : 0);
-                result = (result * 397) + ParameterTypes.SequenceGetHashCode();
-                result = (result * 397) + GenericTypeParameters.SequenceGetHashCode();
-
-                return result;
-            }
-        }
+            => HashCode.Combine(MethodTargetType, ParameterTypes, GenericTypeParameters);
 
         public override string ToString()
         {

From 43e775bd80d00b4208b36563e2f286b7668eb7d0 Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Thu, 5 Aug 2021 00:50:14 -0400
Subject: [PATCH 10/16] :recycle: Use more descriptive error messages

The default error message for failing to find a resolvable method here
is very unhelpful for some common oops cases with generic methods.
Added some extra error messages that can turn up here for better UX.
---
 .../engine/CoreAdapter.cs                        | 16 ++++++++++++++++
 .../resources/ExtendedTypeSystem.resx            |  6 ++++++
 .../Language/Parser/MethodInvocation.Tests.ps1   |  8 ++++----
 3 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/src/System.Management.Automation/engine/CoreAdapter.cs b/src/System.Management.Automation/engine/CoreAdapter.cs
index 5d328f2d4f1..f84d2863c58 100644
--- a/src/System.Management.Automation/engine/CoreAdapter.cs
+++ b/src/System.Management.Automation/engine/CoreAdapter.cs
@@ -1611,6 +1611,22 @@ private static MethodInformation FindBestMethodImpl(
                         methods[0].method.DeclaringType.FullName);
                     return null;
                 }
+                else if (genericParameters.Length != 0 && genericParameters.Contains(null))
+                {
+                    errorId = "TypeNotFoundForGenericMethod";
+                    errorMsg = ExtendedTypeSystem.MethodGenericArgumentTypeNotFoundException;
+                    return null;
+                }
+                else if (genericParameters.Length != 0)
+                {
+                    errorId = "MethodCountCouldNotFindBestGeneric";
+                    errorMsg = string.Format(
+                        ExtendedTypeSystem.MethodGenericArgumentCountException,
+                        methods[0].method.Name,
+                        genericParameters.Length,
+                        arguments.Length);
+                    return null;
+                }
                 else
                 {
                     errorId = "MethodCountCouldNotFindBest";
diff --git a/src/System.Management.Automation/resources/ExtendedTypeSystem.resx b/src/System.Management.Automation/resources/ExtendedTypeSystem.resx
index 6a697cba888..d617cbf7a38 100644
--- a/src/System.Management.Automation/resources/ExtendedTypeSystem.resx
+++ b/src/System.Management.Automation/resources/ExtendedTypeSystem.resx
@@ -156,6 +156,12 @@
   <data name="MethodArgumentCountException" xml:space="preserve">
     <value>Cannot find an overload for "{0}" and the argument count: "{1}".</value>
   </data>
+  <data name="MethodGenericArgumentCountException" xml:space="preserve">
+    <value>Could not find a suitable generic method overload for "{0}" with "{1}" type parameters, and the argument count: "{2}".</value>
+  </data>
+  <data name="MethodGenericArgumentTypeNotFoundException" xml:space="preserve">
+    <value>One or more of the generic type parameters provided for the method "{0}" refers to a type which cannot be found.</value>
+  </data>
   <data name="MethodAmbiguousException" xml:space="preserve">
     <value>Multiple ambiguous overloads found for "{0}" and the argument count: "{1}".</value>
   </data>
diff --git a/test/powershell/Language/Parser/MethodInvocation.Tests.ps1 b/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
index af729da9036..e6a91891174 100644
--- a/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
+++ b/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
@@ -228,8 +228,8 @@ Describe 'Generic Method invocation' -Tags 'CI' {
             [array]::Empty[string, int]()
         }
         catch {
-            $_.Exception.Message | Should -BeExactly 'Cannot find an overload for "Empty" and the argument count: "0".'
-            $_.FullyQualifiedErrorId | Should -BeExactly 'MethodCountCouldNotFindBest'
+            $_.Exception.Message | Should -BeExactly 'Could not find a suitable generic method overload for "Empty" with "2" type parameters, and the argument count: "0".'
+            $_.FullyQualifiedErrorId | Should -BeExactly 'MethodCountCouldNotFindBestGeneric'
         }
     }
 
@@ -238,8 +238,8 @@ Describe 'Generic Method invocation' -Tags 'CI' {
             [array]::Empty[thisdoesnotexist]()
         }
         catch {
-            $_.Exception.Message | Should -BeExactly 'Cannot find an overload for "empty" and the argument count: "0".'
-            $_.FullyQualifiedErrorId | Should -BeExactly 'MethodCountCouldNotFindBest'
+            $_.Exception.Message | Should -BeExactly 'One or more of the generic type parameters provided for the method "Empty" refers to a type which cannot be found.'
+            $_.FullyQualifiedErrorId | Should -BeExactly 'TypeNotFoundForGenericMethod'
         }
     }
 

From 6e7e8b588fb641f85db4c10f3a917f82cd636820 Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Thu, 5 Aug 2021 23:47:08 -0400
Subject: [PATCH 11/16] :recycle: Add constructor overloads

To avoid using default values in public API methods, added some extra
constructor overloads for the relevant AST types here.
---
 .../engine/parser/ast.cs                      | 110 +++++++++++++++++-
 1 file changed, 106 insertions(+), 4 deletions(-)

diff --git a/src/System.Management.Automation/engine/parser/ast.cs b/src/System.Management.Automation/engine/parser/ast.cs
index 9f1d57ac27b..ba6d905cd5d 100644
--- a/src/System.Management.Automation/engine/parser/ast.cs
+++ b/src/System.Management.Automation/engine/parser/ast.cs
@@ -7882,7 +7882,7 @@ public MemberExpressionAst(
             ExpressionAst expression,
             CommandElementAst member,
             bool @static,
-            IList<ITypeName> genericTypes = null)
+            IList<ITypeName> genericTypes)
             : base(extent)
         {
             if (expression == null || member == null)
@@ -7898,6 +7898,30 @@ public MemberExpressionAst(
             this.GenericTypeArguments = new ReadOnlyCollection<ITypeName>(genericTypes ?? Array.Empty<ITypeName>());
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MemberExpressionAst"/> class.
+        /// </summary>
+        /// <param name="extent">
+        /// The extent of the expression, starting with the expression before the operator '.' or '::' and ending after
+        /// membername or expression naming the member.
+        /// </param>
+        /// <param name="expression">The expression before the member access operator '.' or '::'.</param>
+        /// <param name="member">The name or expression naming the member to access.</param>
+        /// <param name="static">True if the '::' operator was used, false if '.' is used.
+        /// True if the member access is for a static member, using '::', false if accessing a member on an instance using '.'.
+        /// </param>
+        /// <exception cref="PSArgumentNullException">
+        /// If <paramref name="extent"/>, <paramref name="expression"/>, or <paramref name="member"/> is null.
+        /// </exception>
+        public MemberExpressionAst(
+            IScriptExtent extent,
+            ExpressionAst expression,
+            CommandElementAst member,
+            bool @static)
+            : this(extent, expression, member, @static, genericTypes: null)
+        {
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="MemberExpressionAst"/> class.
         /// </summary>
@@ -7919,12 +7943,36 @@ public MemberExpressionAst(
             CommandElementAst member,
             bool @static,
             bool nullConditional,
-            IList<ITypeName> genericTypes = null)
+            IList<ITypeName> genericTypes)
             : this(extent, expression, member, @static, genericTypes)
         {
             this.NullConditional = nullConditional;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MemberExpressionAst"/> class.
+        /// </summary>
+        /// <param name="extent">
+        /// The extent of the expression, starting with the expression before the operator '.', '::' or '?.' and ending after
+        /// membername or expression naming the member.
+        /// </param>
+        /// <param name="expression">The expression before the member access operator '.', '::' or '?.'.</param>
+        /// <param name="member">The name or expression naming the member to access.</param>
+        /// <param name="static">True if the '::' operator was used, false if '.' or '?.' is used.</param>
+        /// <param name="nullConditional">True if '?.' used.</param>
+        /// <exception cref="PSArgumentNullException">
+        /// If <paramref name="extent"/>, <paramref name="expression"/>, or <paramref name="member"/> is null.
+        /// </exception>
+        public MemberExpressionAst(
+            IScriptExtent extent,
+            ExpressionAst expression,
+            CommandElementAst member,
+            bool @static,
+            bool nullConditional)
+            : this(extent, expression, member, @static, genericTypes: null)
+        {
+        }
+
         /// <summary>
         /// The expression that produces the value to retrieve the member from.  This property is never null.
         /// </summary>
@@ -8022,7 +8070,7 @@ public InvokeMemberExpressionAst(
             CommandElementAst method,
             IEnumerable<ExpressionAst> arguments,
             bool @static,
-            IList<ITypeName> genericTypes = null)
+            IList<ITypeName> genericTypes)
             : base(extent, expression, method, @static, genericTypes)
         {
             if (arguments != null && arguments.Any())
@@ -8032,6 +8080,32 @@ public InvokeMemberExpressionAst(
             }
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvokeMemberExpressionAst"/> class.
+        /// </summary>
+        /// <param name="extent">
+        /// The extent of the expression, starting with the expression before the invocation operator and ending with the
+        /// closing paren after the arguments.
+        /// </param>
+        /// <param name="expression">The expression before the invocation operator ('.', '::').</param>
+        /// <param name="method">The method to invoke.</param>
+        /// <param name="arguments">The arguments to pass to the method.</param>
+        /// <param name="static">
+        /// True if the invocation is for a static method, using '::', false if invoking a method on an instance using '.'.
+        /// </param>
+        /// <exception cref="PSArgumentNullException">
+        /// If <paramref name="extent"/> is null.
+        /// </exception>
+        public InvokeMemberExpressionAst(
+            IScriptExtent extent,
+            ExpressionAst expression,
+            CommandElementAst method,
+            IEnumerable<ExpressionAst> arguments,
+            bool @static)
+            : this(extent, expression, method, arguments, @static, genericTypes: null)
+        {
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="InvokeMemberExpressionAst"/> class.
         /// </summary>
@@ -8057,12 +8131,40 @@ public InvokeMemberExpressionAst(
             IEnumerable<ExpressionAst> arguments,
             bool @static,
             bool nullConditional,
-            IList<ITypeName> genericTypes = null)
+            IList<ITypeName> genericTypes)
             : this(extent, expression, method, arguments, @static, genericTypes)
         {
             this.NullConditional = nullConditional;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvokeMemberExpressionAst"/> class.
+        /// </summary>
+        /// <param name="extent">
+        /// The extent of the expression, starting with the expression before the invocation operator and ending with the
+        /// closing paren after the arguments.
+        /// </param>
+        /// <param name="expression">The expression before the invocation operator ('.', '::' or '?.').</param>
+        /// <param name="method">The method to invoke.</param>
+        /// <param name="arguments">The arguments to pass to the method.</param>
+        /// <param name="static">
+        /// True if the invocation is for a static method, using '::', false if invoking a method on an instance using '.' or '?.'.
+        /// </param>
+        /// <param name="nullConditional">True if the operator used is '?.'.</param>
+        /// <exception cref="PSArgumentNullException">
+        /// If <paramref name="extent"/> is null.
+        /// </exception>
+        public InvokeMemberExpressionAst(
+            IScriptExtent extent,
+            ExpressionAst expression,
+            CommandElementAst method,
+            IEnumerable<ExpressionAst> arguments,
+            bool @static,
+            bool nullConditional)
+            : this(extent, expression, method, arguments, @static, nullConditional, genericTypes: null)
+        {
+        }
+
         /// <summary>
         /// The non-empty collection of arguments to pass when invoking the method, or null if no arguments were specified.
         /// </summary>

From fa082736b7b3d23833e97c7f39f177c2db62035b Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Tue, 25 Jan 2022 23:55:08 -0500
Subject: [PATCH 12/16] Address review comments

---
 .../engine/CoreAdapter.cs                     |  6 ++---
 .../engine/parser/Compiler.cs                 |  1 -
 .../engine/parser/Parser.cs                   | 24 ++++++++-----------
 .../engine/parser/ast.cs                      |  2 +-
 4 files changed, 14 insertions(+), 19 deletions(-)

diff --git a/src/System.Management.Automation/engine/CoreAdapter.cs b/src/System.Management.Automation/engine/CoreAdapter.cs
index f84d2863c58..60b205336d7 100644
--- a/src/System.Management.Automation/engine/CoreAdapter.cs
+++ b/src/System.Management.Automation/engine/CoreAdapter.cs
@@ -1398,7 +1398,7 @@ private static MethodInformation FindBestMethodImpl(
                 && !methods[0].hasVarArgs
                 // generic methods need to be double checked in a loop below - generic methods can be rejected if type inference fails
                 && !methods[0].isGeneric
-                && (methods[0].method is null || !(methods[0].method.DeclaringType.IsGenericTypeDefinition))
+                && (methods[0].method is null || !methods[0].method.DeclaringType.IsGenericTypeDefinition)
                 && methods[0].parameters.Length == arguments.Length)
             {
                 return methods[0];
@@ -1411,7 +1411,7 @@ private static MethodInformation FindBestMethodImpl(
             {
                 MethodInformation methodInfo = methods[i];
 
-                if ((methodInfo.method is not null && methodInfo.method.DeclaringType.IsGenericTypeDefinition)
+                if ((methodInfo.method?.DeclaringType.IsGenericTypeDefinition == true)
                     || (!methodInfo.isGeneric && genericParameters.Length > 0))
                 {
                     // If method is defined by an *open* generic type, or
@@ -1455,7 +1455,7 @@ private static MethodInformation FindBestMethodImpl(
                     }
 
                     methodInfo = TypeInference.Infer(methodInfo, argumentTypesForTypeInference);
-                    if (methodInfo == null)
+                    if (methodInfo is null)
                     {
                         // Skip generic methods for which we cannot infer type arguments
                         continue;
diff --git a/src/System.Management.Automation/engine/parser/Compiler.cs b/src/System.Management.Automation/engine/parser/Compiler.cs
index 7f2b7bf57e3..b92408fd668 100644
--- a/src/System.Management.Automation/engine/parser/Compiler.cs
+++ b/src/System.Management.Automation/engine/parser/Compiler.cs
@@ -6338,7 +6338,6 @@ internal static PSMethodInvocationConstraints GetInvokeMemberConstraints(InvokeM
             if (genericArguments is not null)
             {
                 genericTypeArguments = new Type[genericArguments.Count];
-
                 for (var i = 0; i < genericArguments.Count; i++)
                 {
                     genericTypeArguments[i] = genericArguments[i].GetReflectionType();
diff --git a/src/System.Management.Automation/engine/parser/Parser.cs b/src/System.Management.Automation/engine/parser/Parser.cs
index 43173aeec5f..32de9cf0409 100644
--- a/src/System.Management.Automation/engine/parser/Parser.cs
+++ b/src/System.Management.Automation/engine/parser/Parser.cs
@@ -1446,7 +1446,6 @@ private List<ITypeName> GenericTypeArgumentsRule(Token firstToken, bool unbracke
             ITypeName typeName = GetSingleGenericArgument(firstToken);
             genericArguments.Add(typeName);
 
-            Token token;
             while (true)
             {
                 SkipNewlines();
@@ -1458,7 +1457,7 @@ private List<ITypeName> GenericTypeArgumentsRule(Token firstToken, bool unbracke
 
                 SkipNewlines();
 
-                token = PeekToken();
+                Token token = PeekToken();
                 if (token.Kind == TokenKind.Identifier || token.Kind == TokenKind.LBracket)
                 {
                     SkipToken();
@@ -1489,8 +1488,8 @@ private ITypeName GenericTypeNameRule(Token genericTypeName, Token firstToken, b
                 UngetToken(rBracketToken);
                 ReportIncompleteInput(
                     Before(rBracketToken),
-                    nameof(ParserStrings.UnexpectedToken),
-                    ParserStrings.UnexpectedToken,
+                    nameof(ParserStrings.EndSquareBracketExpectedAtEndOfAttribute),
+                    ParserStrings.EndSquareBracketExpectedAtEndOfAttribute,
                     rBracketToken.Text);
                 rBracketToken = null;
             }
@@ -7731,17 +7730,18 @@ private ExpressionAst MemberAccessRule(ExpressionAst targetExpr, Token operatorT
             }
             else if (_ungotToken == null)
             {
-                // Member name may be an incomplete token like `$a.$(Command-Name`; we do not look for generic args or
-                // invocation token(s) if the member name token is recognisably incomplete.
-                genericTypeArguments = GenericMethodArgumentsRule(out rBracket);
                 Token lParen = NextInvokeMemberToken();
-
+                if (lParen is null)
+                {
+                    genericTypeArguments = GenericMethodArgumentsRule(out rBracket);
+                    lParen = NextInvokeMemberToken();
+                }
                 if (lParen != null)
                 {
                     // Fall through to the last available token expected in a member name for calculating the expected
                     // position of the lParen. This accounts for things like `[Array]::Empty[int[]()` so that we don't
                     // get unhandled behaviour when input is expected but incomplete.
-                    int endColumnNumber = rBracket?.Extent?.EndColumnNumber
+                    int endColumnNumber = rBracket.Extent?.EndColumnNumber
                         ?? genericTypeArguments?.LastOrDefault()?.Extent?.EndColumnNumber
                         ?? member.Extent.EndColumnNumber;
 
@@ -7767,15 +7767,11 @@ private List<ITypeName> GenericMethodArgumentsRule(out Token rBracketToken)
             List<ITypeName> genericTypes = null;
 
             int resyncIndex = _tokenizer.GetRestorePoint();
-            Token lBracket = NextToken();
+            Token lBracket = PeekToken();
             rBracketToken = null;
 
             if (lBracket.Kind != TokenKind.LBracket)
             {
-                // We cannot avoid this Resync(); if we use PeekToken() to try to avoid a Resync(), the method called
-                // after this (NextInvokeMemberToken()) will note that an _ungotToken is present and assume an error
-                // state. That will cause any property accesses or non-generic method calls to throw a parse error.
-                Resync(resyncIndex);
                 return null;
             }
 
diff --git a/src/System.Management.Automation/engine/parser/ast.cs b/src/System.Management.Automation/engine/parser/ast.cs
index ba6d905cd5d..c75011ed02a 100644
--- a/src/System.Management.Automation/engine/parser/ast.cs
+++ b/src/System.Management.Automation/engine/parser/ast.cs
@@ -7969,7 +7969,7 @@ public MemberExpressionAst(
             CommandElementAst member,
             bool @static,
             bool nullConditional)
-            : this(extent, expression, member, @static, genericTypes: null)
+            : this(extent, expression, member, @static, nullConditional, genericTypes: null)
         {
         }
 

From 335c2ff8aff05bb77bb9eb3f567acd47bc3c320c Mon Sep 17 00:00:00 2001
From: Dongbo Wang <dongbow@microsoft.com>
Date: Wed, 26 Jan 2022 11:31:14 -0800
Subject: [PATCH 13/16] Fix the build break

---
 .../engine/parser/Parser.cs                   | 29 ++++++++++---------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/src/System.Management.Automation/engine/parser/Parser.cs b/src/System.Management.Automation/engine/parser/Parser.cs
index 32de9cf0409..dcc30c8056f 100644
--- a/src/System.Management.Automation/engine/parser/Parser.cs
+++ b/src/System.Management.Automation/engine/parser/Parser.cs
@@ -7715,7 +7715,6 @@ private ExpressionAst MemberAccessRule(ExpressionAst targetExpr, Token operatorT
 
             CommandElementAst member = MemberNameRule();
             List<ITypeName> genericTypeArguments = null;
-            Token rBracket = null;
 
             if (member == null)
             {
@@ -7730,20 +7729,17 @@ private ExpressionAst MemberAccessRule(ExpressionAst targetExpr, Token operatorT
             }
             else if (_ungotToken == null)
             {
+                // Member name may be an incomplete token like `$a.$(Command-Name`; we do not look for generic args or
+                // invocation token(s) if the member name token is recognisably incomplete.
+                genericTypeArguments = GenericMethodArgumentsRule(out Token rBracket);
                 Token lParen = NextInvokeMemberToken();
-                if (lParen is null)
-                {
-                    genericTypeArguments = GenericMethodArgumentsRule(out rBracket);
-                    lParen = NextInvokeMemberToken();
-                }
+
                 if (lParen != null)
                 {
-                    // Fall through to the last available token expected in a member name for calculating the expected
-                    // position of the lParen. This accounts for things like `[Array]::Empty[int[]()` so that we don't
-                    // get unhandled behaviour when input is expected but incomplete.
-                    int endColumnNumber = rBracket.Extent?.EndColumnNumber
-                        ?? genericTypeArguments?.LastOrDefault()?.Extent?.EndColumnNumber
-                        ?? member.Extent.EndColumnNumber;
+                    // When we reach here, we either had a legit section of generic arguments (in which case, `rBracket`
+                    // won't be null), or we saw `lParen` directly following the member token (in which case, `rBracket`
+                    // will be null).
+                    int endColumnNumber = rBracket is null ? member.Extent.EndColumnNumber : rBracket.Extent.EndColumnNumber;
 
                     Diagnostics.Assert(lParen.Kind == TokenKind.LParen || lParen.Kind == TokenKind.LCurly, "token kind incorrect");
                     Diagnostics.Assert(
@@ -7767,15 +7763,20 @@ private List<ITypeName> GenericMethodArgumentsRule(out Token rBracketToken)
             List<ITypeName> genericTypes = null;
 
             int resyncIndex = _tokenizer.GetRestorePoint();
-            Token lBracket = PeekToken();
+            Token lBracket = NextToken();
             rBracketToken = null;
 
             if (lBracket.Kind != TokenKind.LBracket)
             {
+                // We cannot avoid this Resync(); if we use PeekToken() to try to avoid a Resync(), the method called
+                // after this [`NextInvokeMemberToken()` or `NextMemberAccessToken()`] will note that an _ungotToken
+                // is present and assume an error state. That will cause any property accesses or non-generic method
+                // calls to throw a parse error.
+                Resync(resyncIndex);
                 return null;
             }
 
-            // This is either a member expression with generic type arguments, or some sort of collection index
+            // This is either a InvokeMember expression with generic type arguments, or some sort of collection index
             // on a property.
             TokenizerMode oldTokenizerMode = _tokenizer.Mode;
             try

From 52e50d6a61d2e8510edfc28452e4227406825867 Mon Sep 17 00:00:00 2001
From: Dongbo Wang <dongbow@microsoft.com>
Date: Wed, 26 Jan 2022 14:22:20 -0800
Subject: [PATCH 14/16] Address my review comments

---
 .../engine/CoreAdapter.cs                     |  2 +-
 .../engine/MshMemberInfo.cs                   |  4 ++--
 .../engine/parser/Compiler.cs                 | 22 +++++--------------
 .../engine/parser/Parser.cs                   |  9 ++++----
 .../engine/parser/ast.cs                      |  6 ++++-
 5 files changed, 18 insertions(+), 25 deletions(-)

diff --git a/src/System.Management.Automation/engine/CoreAdapter.cs b/src/System.Management.Automation/engine/CoreAdapter.cs
index 60b205336d7..86ed988362e 100644
--- a/src/System.Management.Automation/engine/CoreAdapter.cs
+++ b/src/System.Management.Automation/engine/CoreAdapter.cs
@@ -1411,7 +1411,7 @@ private static MethodInformation FindBestMethodImpl(
             {
                 MethodInformation methodInfo = methods[i];
 
-                if ((methodInfo.method?.DeclaringType.IsGenericTypeDefinition == true)
+                if (methodInfo.method?.DeclaringType.IsGenericTypeDefinition == true
                     || (!methodInfo.isGeneric && genericParameters.Length > 0))
                 {
                     // If method is defined by an *open* generic type, or
diff --git a/src/System.Management.Automation/engine/MshMemberInfo.cs b/src/System.Management.Automation/engine/MshMemberInfo.cs
index fe9410042ae..ef6d185a606 100644
--- a/src/System.Management.Automation/engine/MshMemberInfo.cs
+++ b/src/System.Management.Automation/engine/MshMemberInfo.cs
@@ -1920,7 +1920,7 @@ internal PSMethodInvocationConstraints(
         {
             MethodTargetType = methodTargetType;
             _parameterTypes = parameterTypes;
-            GenericTypeParameters = genericTypeParameters ?? Array.Empty<Type>();
+            GenericTypeParameters = genericTypeParameters;
         }
 
         /// <remarks>
@@ -2024,7 +2024,7 @@ public override string ToString()
                 separator = " ";
             }
 
-            if (GenericTypeParameters.Length != 0)
+            if (GenericTypeParameters != null)
             {
                 sb.Append(separator);
                 sb.Append("genericTypeParams: ");
diff --git a/src/System.Management.Automation/engine/parser/Compiler.cs b/src/System.Management.Automation/engine/parser/Compiler.cs
index b92408fd668..1178d590a55 100644
--- a/src/System.Management.Automation/engine/parser/Compiler.cs
+++ b/src/System.Management.Automation/engine/parser/Compiler.cs
@@ -6350,28 +6350,18 @@ internal static PSMethodInvocationConstraints GetInvokeMemberConstraints(InvokeM
         internal static PSMethodInvocationConstraints GetInvokeMemberConstraints(BaseCtorInvokeMemberExpressionAst invokeMemberExpressionAst)
         {
             Type targetTypeConstraint = null;
+            ReadOnlyCollection<ExpressionAst> arguments = invokeMemberExpressionAst.Arguments;
             Type[] argumentTypes = null;
-            if (invokeMemberExpressionAst.Arguments is not null)
+            if (arguments is not null)
             {
-                argumentTypes = new Type[invokeMemberExpressionAst.Arguments.Count];
-                for (var i = 0; i < invokeMemberExpressionAst.Arguments.Count; i++)
+                argumentTypes = new Type[arguments.Count];
+                for (var i = 0; i < arguments.Count; i++)
                 {
-                    argumentTypes[i] = GetTypeConstraintForMethodResolution(invokeMemberExpressionAst.Arguments[i]);
+                    argumentTypes[i] = GetTypeConstraintForMethodResolution(arguments[i]);
                 }
             }
 
             TypeDefinitionAst typeDefinitionAst = Ast.GetAncestorTypeDefinitionAst(invokeMemberExpressionAst);
-
-            Type[] genericArguments = null;
-            if (invokeMemberExpressionAst.GenericTypeArguments.Count > 0)
-            {
-                genericArguments = new Type[invokeMemberExpressionAst.GenericTypeArguments.Count];
-                for (var i = 0; i < invokeMemberExpressionAst.GenericTypeArguments.Count; i++)
-                {
-                    genericArguments[i] = invokeMemberExpressionAst.GenericTypeArguments[i].GetReflectionType();
-                }
-            }
-
             if (typeDefinitionAst != null)
             {
                 targetTypeConstraint = (typeDefinitionAst as TypeDefinitionAst).Type.BaseType;
@@ -6381,7 +6371,7 @@ internal static PSMethodInvocationConstraints GetInvokeMemberConstraints(BaseCto
                 Diagnostics.Assert(false, "BaseCtorInvokeMemberExpressionAst must be used only inside TypeDefinitionAst");
             }
 
-            return CombineTypeConstraintForMethodResolution(targetTypeConstraint, argumentTypes, genericArguments);
+            return CombineTypeConstraintForMethodResolution(targetTypeConstraint, argumentTypes, genericArguments: null);
         }
 
         internal Expression InvokeMember(
diff --git a/src/System.Management.Automation/engine/parser/Parser.cs b/src/System.Management.Automation/engine/parser/Parser.cs
index dcc30c8056f..6e7e0ab94ac 100644
--- a/src/System.Management.Automation/engine/parser/Parser.cs
+++ b/src/System.Management.Automation/engine/parser/Parser.cs
@@ -1437,7 +1437,7 @@ private ITypeName GetSingleGenericArgument(Token firstToken)
             return typeName;
         }
 
-        private List<ITypeName> GenericTypeArgumentsRule(Token firstToken, bool unbracketedGenericArg, out Token lastToken)
+        private List<ITypeName> GenericTypeArgumentsRule(Token firstToken, out Token lastToken)
         {
             Diagnostics.Assert(firstToken.Kind == TokenKind.Identifier || firstToken.Kind == TokenKind.LBracket, "unexpected first token");
             RuntimeHelpers.EnsureSufficientExecutionStack();
@@ -1480,7 +1480,7 @@ private List<ITypeName> GenericTypeArgumentsRule(Token firstToken, bool unbracke
 
         private ITypeName GenericTypeNameRule(Token genericTypeName, Token firstToken, bool unbracketedGenericArg)
         {
-            List<ITypeName> genericArguments = GenericTypeArgumentsRule(firstToken, unbracketedGenericArg, out Token rBracketToken);
+            List<ITypeName> genericArguments = GenericTypeArgumentsRule(firstToken, out Token rBracketToken);
 
             if (rBracketToken.Kind != TokenKind.RBracket)
             {
@@ -1489,8 +1489,7 @@ private ITypeName GenericTypeNameRule(Token genericTypeName, Token firstToken, b
                 ReportIncompleteInput(
                     Before(rBracketToken),
                     nameof(ParserStrings.EndSquareBracketExpectedAtEndOfAttribute),
-                    ParserStrings.EndSquareBracketExpectedAtEndOfAttribute,
-                    rBracketToken.Text);
+                    ParserStrings.EndSquareBracketExpectedAtEndOfAttribute);
                 rBracketToken = null;
             }
 
@@ -7789,7 +7788,7 @@ private List<ITypeName> GenericMethodArgumentsRule(out Token rBracketToken)
                 if (firstToken.Kind == TokenKind.Identifier || firstToken.Kind == TokenKind.LBracket)
                 {
                     resyncIndex = -1;
-                    genericTypes = GenericTypeArgumentsRule(firstToken, unbracketedGenericArg: false, out rBracketToken);
+                    genericTypes = GenericTypeArgumentsRule(firstToken, out rBracketToken);
 
                     if (rBracketToken.Kind != TokenKind.RBracket)
                     {
diff --git a/src/System.Management.Automation/engine/parser/ast.cs b/src/System.Management.Automation/engine/parser/ast.cs
index c75011ed02a..2e904511bb7 100644
--- a/src/System.Management.Automation/engine/parser/ast.cs
+++ b/src/System.Management.Automation/engine/parser/ast.cs
@@ -7895,7 +7895,11 @@ public MemberExpressionAst(
             this.Member = member;
             SetParent(member);
             this.Static = @static;
-            this.GenericTypeArguments = new ReadOnlyCollection<ITypeName>(genericTypes ?? Array.Empty<ITypeName>());
+
+            if (genericTypes != null && genericTypes.Count > 0)
+            {
+                this.GenericTypeArguments = new ReadOnlyCollection<ITypeName>(genericTypes);
+            }
         }
 
         /// <summary>

From cd03b0994e1c4c5744ee9077909f59f0197f6a15 Mon Sep 17 00:00:00 2001
From: Joel Sallow <32407840+vexx32@users.noreply.github.com>
Date: Wed, 26 Jan 2022 22:56:06 -0500
Subject: [PATCH 15/16] :white_check_mark: Add tests for tab completion

---
 .../Host/TabCompletion/TabCompletion.Tests.ps1   | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/powershell/Host/TabCompletion/TabCompletion.Tests.ps1 b/test/powershell/Host/TabCompletion/TabCompletion.Tests.ps1
index 39ab4968b5e..14ebc5a502e 100644
--- a/test/powershell/Host/TabCompletion/TabCompletion.Tests.ps1
+++ b/test/powershell/Host/TabCompletion/TabCompletion.Tests.ps1
@@ -43,6 +43,22 @@ Describe "TabCompletion" -Tags CI {
         $res.CompletionMatches[0].CompletionText | Should -BeExactly 'CompareTo('
     }
 
+    It 'should complete generic type parameters for static methods' {
+        $script = '[array]::Empty[pscu'
+
+        $results = TabExpansion2 -inputScript $script -cursorColumn $script.Length
+        $results.CompletionMatches.CompletionText | Should -Contain 'pscustomobject'
+    }
+
+    It 'should complete generic type parameters for instance methods' {
+        $script = '
+            $dict = [System.Collections.Concurrent.ConcurrentDictionary[string, int]]::new()
+            $dict.AddOrUpdate[pscu'
+
+        $results = TabExpansion2 -inputScript $script -cursorColumn $script.Length
+        $results.CompletionMatches.CompletionText | Should -Contain 'pscustomobject'
+    }
+
     It 'Should complete Magic foreach' {
         $res = TabExpansion2 -inputScript '(1..10).Fo' -cursorColumn '(1..10).Fo'.Length
         $res.CompletionMatches[0].CompletionText | Should -BeExactly 'ForEach('

From 61a64c4e6b64ced5f8637050355d93c4523c0115 Mon Sep 17 00:00:00 2001
From: "Joel Sallow (/u/ta11ow)" <32407840+vexx32@users.noreply.github.com>
Date: Wed, 26 Jan 2022 23:16:12 -0500
Subject: [PATCH 16/16] Update
 src/System.Management.Automation/engine/parser/ast.cs

Co-authored-by: Ilya <darpa@yandex.ru>
---
 src/System.Management.Automation/engine/parser/ast.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/System.Management.Automation/engine/parser/ast.cs b/src/System.Management.Automation/engine/parser/ast.cs
index 2e904511bb7..2d078581656 100644
--- a/src/System.Management.Automation/engine/parser/ast.cs
+++ b/src/System.Management.Automation/engine/parser/ast.cs
@@ -7896,7 +7896,7 @@ public MemberExpressionAst(
             SetParent(member);
             this.Static = @static;
 
-            if (genericTypes != null && genericTypes.Count > 0)
+            if (genericTypes is not null && genericTypes.Count > 0)
             {
                 this.GenericTypeArguments = new ReadOnlyCollection<ITypeName>(genericTypes);
             }