PowerShell · daxian-dbw · Nov 16, 2019 · Oct 3, 2019 · Nov 1, 2019 · Nov 5, 2019
diff --git a/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs b/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs
@@ -404,6 +404,7 @@ internal List<CompletionResult> GetResultHelper(CompletionContext completionCont
 
                     case TokenKind.Dot:
                     case TokenKind.ColonColon:
+                    case TokenKind.QuestionDot:
                         replacementIndex += tokenAtCursor.Text.Length;
                         replacementLength = 0;
                         result = CompletionCompleters.CompleteMember(completionContext, @static: tokenAtCursor.Kind == TokenKind.ColonColon);

diff --git a/src/System.Management.Automation/engine/ExperimentalFeature/ExperimentalFeature.cs b/src/System.Management.Automation/engine/ExperimentalFeature/ExperimentalFeature.cs
@@ -127,6 +127,9 @@ static ExperimentalFeature()
                 new ExperimentalFeature(
                     name: "PSPipelineChainOperators",
                     description: "Allow use of && and || as operators between pipeline invocations"),
+                new ExperimentalFeature(
+                    name: "PSNullConditionalOperators",
+                    description: "Support the null conditional member access operators in PowerShell language")
             };
             EngineExperimentalFeatures = new ReadOnlyCollection<ExperimentalFeature>(engineFeatures);
 

@@ -6174,15 +6174,14 @@ public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
             }
 
             var target = CompileExpressionOperand(memberExpressionAst.Expression);
+
+            // If the ?. operator is used for null conditional check, add the null conditional expression.
             var memberNameAst = memberExpressionAst.Member as StringConstantExpressionAst;
-            if (memberNameAst != null)
-            {
-                string name = memberNameAst.Value;
-                return DynamicExpression.Dynamic(PSGetMemberBinder.Get(name, _memberFunctionType, memberExpressionAst.Static), typeof(object), target);
-            }
+            Expression memberAccessExpr = memberNameAst != null
+                ? DynamicExpression.Dynamic(PSGetMemberBinder.Get(memberNameAst.Value, _memberFunctionType, memberExpressionAst.Static), typeof(object), target)
+                : DynamicExpression.Dynamic(PSGetDynamicMemberBinder.Get(_memberFunctionType, memberExpressionAst.Static), typeof(object), target, Compile(memberExpressionAst.Member));
 
-            var memberNameExpr = Compile(memberExpressionAst.Member);
-            return DynamicExpression.Dynamic(PSGetDynamicMemberBinder.Get(_memberFunctionType, memberExpressionAst.Static), typeof(object), target, memberNameExpr);
+            return memberExpressionAst.NullConditional ? GetNullConditionalWrappedExpression(target, memberAccessExpr) : memberAccessExpr;
         }
 
         internal static PSMethodInvocationConstraints GetInvokeMemberConstraints(InvokeMemberExpressionAst invokeMemberExpressionAst)
@@ -6219,14 +6218,18 @@ internal Expression InvokeMember(
             Expression target,
             IEnumerable<Expression> args,
             bool @static,
-            bool propertySet)
+            bool propertySet,
+            bool nullConditional = false)
         {
             var callInfo = new CallInfo(args.Count());
             var classScope = _memberFunctionType != null ? _memberFunctionType.Type : null;
             var binder = name.Equals("new", StringComparison.OrdinalIgnoreCase) && @static
                 ? (CallSiteBinder)PSCreateInstanceBinder.Get(callInfo, constraints, publicTypeOnly: true)
                 : PSInvokeMemberBinder.Get(name, callInfo, @static, propertySet, constraints, classScope);
-            return DynamicExpression.Dynamic(binder, typeof(object), args.Prepend(target));
+
+            var dynamicExprFromBinder = DynamicExpression.Dynamic(binder, typeof(object), args.Prepend(target));
+
+            return nullConditional ? GetNullConditionalWrappedExpression(target, dynamicExprFromBinder) : dynamicExprFromBinder;
         }
 
         private Expression InvokeBaseCtorMethod(PSMethodInvocationConstraints constraints, Expression target, IEnumerable<Expression> args)
@@ -6242,10 +6245,13 @@ internal Expression InvokeDynamicMember(
             Expression target,
             IEnumerable<Expression> args,
             bool @static,
-            bool propertySet)
+            bool propertySet,
+            bool nullConditional = false)
         {
             var binder = PSInvokeDynamicMemberBinder.Get(new CallInfo(args.Count()), _memberFunctionType, @static, propertySet, constraints);
-            return DynamicExpression.Dynamic(binder, typeof(object), args.Prepend(memberNameExpr).Prepend(target));
+            var dynamicExprFromBinder = DynamicExpression.Dynamic(binder, typeof(object), args.Prepend(memberNameExpr).Prepend(target));
+
+            return nullConditional ? GetNullConditionalWrappedExpression(target, dynamicExprFromBinder) : dynamicExprFromBinder;
         }
 
         public object VisitInvokeMemberExpression(InvokeMemberExpressionAst invokeMemberExpressionAst)
@@ -6258,11 +6264,18 @@ public object VisitInvokeMemberExpression(InvokeMemberExpressionAst invokeMember
             var memberNameAst = invokeMemberExpressionAst.Member as StringConstantExpressionAst;
             if (memberNameAst != null)
             {
-                return InvokeMember(memberNameAst.Value, constraints, target, args, invokeMemberExpressionAst.Static, false);
+                return InvokeMember(
+                    memberNameAst.Value,
+                    constraints,
+                    target,
+                    args,
+                    invokeMemberExpressionAst.Static,
+                    propertySet: false,
+                    invokeMemberExpressionAst.NullConditional);
             }
 
             var memberNameExpr = Compile(invokeMemberExpressionAst.Member);
-            return InvokeDynamicMember(memberNameExpr, constraints, target, args, invokeMemberExpressionAst.Static, false);
+            return InvokeDynamicMember(memberNameExpr, constraints, target, args, invokeMemberExpressionAst.Static, propertySet: false, invokeMemberExpressionAst.NullConditional);
         }
 
         public object VisitArrayExpression(ArrayExpressionAst arrayExpressionAst)
@@ -6422,15 +6435,26 @@ public object VisitIndexExpression(IndexExpressionAst indexExpressionAst)
             // In the former case, the user is requesting an array slice.  In the latter case, they index expression is likely
             // an array (dynamically determined) and they don't want an array slice, they want to use the array as the index
             // expression.
-            if (arrayLiteral != null && arrayLiteral.Elements.Count > 1)
-            {
-                return DynamicExpression.Dynamic(
-                                            PSGetIndexBinder.Get(arrayLiteral.Elements.Count, constraints),
-                                            typeof(object),
-                                            arrayLiteral.Elements.Select(CompileExpressionOperand).Prepend(targetExpr));
-            }
+            Expression indexingExpr = arrayLiteral != null && arrayLiteral.Elements.Count > 1
+                ? DynamicExpression.Dynamic(
+                    PSGetIndexBinder.Get(arrayLiteral.Elements.Count, constraints),
+                    typeof(object),
+                    arrayLiteral.Elements.Select(CompileExpressionOperand).Prepend(targetExpr))
+                : DynamicExpression.Dynamic(
+                    PSGetIndexBinder.Get(argCount: 1, constraints),
+                    typeof(object),
+                    targetExpr,
+                    CompileExpressionOperand(index));
 
-            return DynamicExpression.Dynamic(PSGetIndexBinder.Get(1, constraints), typeof(object), targetExpr, CompileExpressionOperand(index));
+            return indexExpressionAst.NullConditional ? GetNullConditionalWrappedExpression(targetExpr, indexingExpr) : indexingExpr;
+        }
+
+        private static Expression GetNullConditionalWrappedExpression(Expression targetExpr, Expression memberAccessExpression)
+        {
+            return Expression.Condition(
+                Expression.Call(CachedReflectionInfo.LanguagePrimitives_IsNullLike, targetExpr.Cast(typeof(object))),
+                ExpressionCache.NullConstant,
+                memberAccessExpression);
         }
 
         public object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)

@@ -7347,11 +7347,11 @@ private ExpressionAst CheckPostPrimaryExpressionOperators(Token token, Expressio
                 // To support fluent style programming, allow newlines after the member access operator.
                 SkipNewlines();
 
-                if (token.Kind == TokenKind.Dot || token.Kind == TokenKind.ColonColon)
+                if (token.Kind == TokenKind.Dot || token.Kind == TokenKind.ColonColon || token.Kind == TokenKind.QuestionDot)
                 {
                     expr = MemberAccessRule(expr, token);
                 }
-                else if (token.Kind == TokenKind.LBracket)
+                else if (token.Kind == TokenKind.LBracket || token.Kind == TokenKind.QuestionLBracket)
                 {
                     expr = ElementAccessRule(expr, token);
                 }
@@ -7772,8 +7772,12 @@ private ExpressionAst MemberAccessRule(ExpressionAst targetExpr, Token operatorT
                 }
             }
 
-            return new MemberExpressionAst(ExtentOf(targetExpr, member),
-                targetExpr, member, operatorToken.Kind == TokenKind.ColonColon);
+            return new MemberExpressionAst(
+                    ExtentOf(targetExpr, member),
+                    targetExpr,
+                    member,
+                    @static: operatorToken.Kind == TokenKind.ColonColon,
+                    nullConditional: operatorToken.Kind == TokenKind.QuestionDot);
         }
 
         private ExpressionAst MemberInvokeRule(ExpressionAst targetExpr, Token lBracket, Token operatorToken, CommandElementAst member)
@@ -7801,7 +7805,13 @@ private ExpressionAst MemberInvokeRule(ExpressionAst targetExpr, Token lBracket,
                 lastExtent = argument.Extent;
             }
 
-            return new InvokeMemberExpressionAst(ExtentOf(targetExpr, lastExtent), targetExpr, member, arguments, operatorToken.Kind == TokenKind.ColonColon);
+            return new InvokeMemberExpressionAst(
+                ExtentOf(targetExpr, lastExtent),
+                targetExpr,
+                member,
+                arguments,
+                operatorToken.Kind == TokenKind.ColonColon,
+                operatorToken.Kind == TokenKind.QuestionDot);
         }
 
         private List<ExpressionAst> InvokeParamParenListRule(Token lParen, out IScriptExtent lastExtent)
@@ -7923,7 +7933,7 @@ private ExpressionAst ElementAccessRule(ExpressionAst primaryExpression, Token l
                 rBracket = null;
             }
 
-            return new IndexExpressionAst(ExtentOf(primaryExpression, ExtentFromFirstOf(rBracket, indexExpr)), primaryExpression, indexExpr);
+            return new IndexExpressionAst(ExtentOf(primaryExpression, ExtentFromFirstOf(rBracket, indexExpr)), primaryExpression, indexExpr, lBracket.Kind == TokenKind.QuestionLBracket);
         }
 
         #endregion Expressions

@@ -762,6 +762,14 @@ private void CheckAssignmentTarget(ExpressionAst ast, bool simpleAssignment, Act
                 {
                     errorAst = ast;
                 }
+                else if (ast is MemberExpressionAst memberExprAst && memberExprAst.NullConditional)
+                {
+                    errorAst = ast;
+                }
+                else if (ast is IndexExpressionAst indexExprAst && indexExprAst.NullConditional)
+                {
+                    errorAst = ast;
+                }
                 else if (ast is AttributedExpressionAst)
                 {
                     // Check for multiple types combined with [ref].

@@ -7851,6 +7851,26 @@ public MemberExpressionAst(IScriptExtent extent, ExpressionAst expression, Comma
             this.Static = @static;
         }
 
+        /// <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)
+        {
+            this.NullConditional = nullConditional;
+        }
+
         /// <summary>
         /// The expression that produces the value to retrieve the member from.  This property is never null.
         /// </summary>
@@ -7866,14 +7886,19 @@ public MemberExpressionAst(IScriptExtent extent, ExpressionAst expression, Comma
         /// </summary>
         public bool Static { get; private set; }
 
+        /// <summary>
+        /// Gets a value indicating true if the operator used is ?. or ?[].
+        /// </summary>
+        public bool NullConditional { get; protected set; }
+
         /// <summary>
         /// Copy the MemberExpressionAst instance.
         /// </summary>
         public override Ast Copy()
         {
             var newExpression = CopyElement(this.Expression);
             var newMember = CopyElement(this.Member);
-            return new MemberExpressionAst(this.Extent, newExpression, newMember, this.Static);
+            return new MemberExpressionAst(this.Extent, newExpression, newMember, this.Static, this.NullConditional);
         }
 
         #region Visitors
@@ -7915,7 +7940,7 @@ public class InvokeMemberExpressionAst : MemberExpressionAst, ISupportsAssignmen
         /// 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="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">
@@ -7934,6 +7959,29 @@ public InvokeMemberExpressionAst(IScriptExtent extent, ExpressionAst expression,
             }
         }
 
+        /// <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)
+        {
+            this.NullConditional = nullConditional;
+        }
+
         /// <summary>
         /// The non-empty collection of arguments to pass when invoking the method, or null if no arguments were specified.
         /// </summary>
@@ -7947,7 +7995,7 @@ 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);
+            return new InvokeMemberExpressionAst(this.Extent, newExpression, newMethod, newArguments, this.Static, this.NullConditional);
         }
 
         #region Visitors
@@ -10220,6 +10268,22 @@ public IndexExpressionAst(IScriptExtent extent, ExpressionAst target, Expression
             SetParent(index);
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IndexExpressionAst"/> class.
+        /// </summary>
+        /// <param name="extent">The extent of the expression.</param>
+        /// <param name="target">The expression being indexed.</param>
+        /// <param name="index">The index expression.</param>
+        /// <param name="nullConditional">Access the index only if the target is not null.</param>
+        /// <exception cref="PSArgumentNullException">
+        /// If <paramref name="extent"/>, <paramref name="target"/>, or <paramref name="index"/> is null.
+        /// </exception>
+        public IndexExpressionAst(IScriptExtent extent, ExpressionAst target, ExpressionAst index, bool nullConditional)
+            : this(extent, target, index)
+        {
+            this.NullConditional = nullConditional;
+        }
+
         /// <summary>
         /// Return the ast for the expression being indexed.  This value is never null.
         /// </summary>
@@ -10230,14 +10294,19 @@ public IndexExpressionAst(IScriptExtent extent, ExpressionAst target, Expression
         /// </summary>
         public ExpressionAst Index { get; private set; }
 
+        /// <summary>
+        /// Gets a value indicating whether ?[] operator is being used.
+        /// </summary>
+        public bool NullConditional { get; private set; }
+
         /// <summary>
         /// Copy the IndexExpressionAst instance.
         /// </summary>
         public override Ast Copy()
         {
             var newTarget = CopyElement(this.Target);
             var newIndex = CopyElement(this.Index);
-            return new IndexExpressionAst(this.Extent, newTarget, newIndex);
+            return new IndexExpressionAst(this.Extent, newTarget, newIndex, this.NullConditional);
         }
 
         #region Visitors