Implement null condtional assigment operator

Author: adityapatwardhan

src/System.Management.Automation/engine/parser/Compiler.cs

@@ -794,6 +794,7 @@ internal Expression ReduceAssignment(ISupportsAssignment left, TokenKind tokenKi
                 case TokenKind.MultiplyEquals: et = ExpressionType.Multiply; break;
                 case TokenKind.DivideEquals: et = ExpressionType.Divide; break;
                 case TokenKind.RemainderEquals: et = ExpressionType.Modulo; break;
+                case TokenKind.QuestionEquals: return GetCoalesceExpression(right, av, tokenKind);
             }
 
             var exprs = new List<Expression>();
@@ -803,6 +804,21 @@ internal Expression ReduceAssignment(ISupportsAssignment left, TokenKind tokenKi
             return Expression.Block(temps, exprs);
         }
 
+        private Expression GetCoalesceExpression(Expression rhs, IAssignableValue leftAssignableValue, TokenKind tokenKind)
+        {
+            var exprs = new List<Expression>();
+            var temps = new List<ParameterExpression>();
+            var leftExpr = leftAssignableValue.GetValue(this, exprs, temps);
+
+            if (tokenKind == TokenKind.QuestionEquals)
+            {
+                exprs.Add(leftAssignableValue.SetValue(this, Expression.MakeBinary(ExpressionType.Coalesce,leftExpr,rhs)));
+                return Expression.Block(temps, exprs);
+            }
+
+            return null;
+        }
+
         internal Expression GetLocal(int tupleIndex)
         {
             Expression result = LocalVariablesParameter;

src/System.Management.Automation/engine/parser/token.cs

@@ -416,6 +416,9 @@ public enum TokenKind
         /// <summary>The ternary operator '?'.</summary>
         QuestionMark = 100,
 
+        /// <summary>The null conditional assignment operator '?='.</summary>
+        QuestionEquals = 101,
+
         #endregion Operators
 
         #region Keywords
@@ -669,7 +672,7 @@ public enum TokenFlags
         SpecialOperator = 0x00001000,
 
         /// <summary>
-        /// The token is one of the assignment operators: '=', '+=', '-=', '*=', '/=', or '%='
+        /// The token is one of the assignment operators: '=', '+=', '-=', '*=', '/=', '%=' or '?='
         /// </summary>
         AssignmentOperator = 0x00002000,
 
@@ -854,7 +857,7 @@ public static class TokenTraits
             /*                  Shr */ TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison | TokenFlags.CanConstantFold,
             /*                Colon */ TokenFlags.SpecialOperator | TokenFlags.DisallowedInRestrictedMode,
             /*         QuestionMark */ TokenFlags.TernaryOperator | TokenFlags.DisallowedInRestrictedMode,
-            /*     Reserved slot 3  */ TokenFlags.None,
+            /*      QuestionEquals  */ TokenFlags.AssignmentOperator,
             /*     Reserved slot 4  */ TokenFlags.None,
             /*     Reserved slot 5  */ TokenFlags.None,
             /*     Reserved slot 6  */ TokenFlags.None,
@@ -1051,7 +1054,7 @@ public static class TokenTraits
             /*                  Shl */ "-shl",
             /*                  Shr */ "-shr",
             /*                Colon */ ":",
-            /*    Reserved slot 2   */ string.Empty,
+            /*       QuestionEquals */ "?=",
             /*    Reserved slot 3   */ string.Empty,
             /*    Reserved slot 4   */ string.Empty,
             /*    Reserved slot 5   */ string.Empty,

src/System.Management.Automation/engine/parser/tokenizer.cs

@@ -4996,6 +4996,17 @@ internal Token NextToken()
                 case '?' when InExpressionMode():
                     return this.NewToken(TokenKind.QuestionMark);
 
+                case '?':
+                    c1 = PeekChar();
+
+                    if (c1 == '=')
+                    {
+                        SkipChar();
+                        return CheckOperatorInCommandMode(c, c1, TokenKind.QuestionEquals);
+                    }
+
+                    return ScanGenericToken(c);
+
                 case '\0':
                     if (AtEof())
                     {

test/powershell/Language/Operators/NullCondtional.Tests.ps1

@@ -0,0 +1,50 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+Describe 'NullConditionalAssginmentOperator' -tag 'CI' {
+
+    BeforeAll {
+        $someGuid = New-Guid
+
+        $typesTests = @(
+            @{ name = 'string'; valueToSet = 'hello'}
+            @{ name = 'dotnetType'; valueToSet = $someGuid}
+            @{ name = 'byte'; valueToSet = [byte]0x94}
+            @{ name = 'intArray'; valueToSet = 1..2}
+            @{ name = 'stringArray'; valueToSet = 'a'..'c'}
+            @{ name = 'emptyArray'; valueToSet = @(1,2,3)}
+        )
+
+    }
+
+    It 'Variable doesnot exist' {
+        Remove-Variable variableDoesNotExist -ErrorAction SilentlyContinue -Force
+
+        $variableDoesNotExist ?= 1
+        $variableDoesNotExist | Should -Be 1
+
+        $variableDoesNotExist ?= 2
+        $variableDoesNotExist | Should -Be 1
+    }
+
+    It 'Variable exists and is null' {
+        $variableDoesNotExist = $null
+
+        $variableDoesNotExist ?= 2
+        $variableDoesNotExist | Should -Be 2
+    }
+
+    It 'Validate types - <name> can be set' -TestCases $typesTests {
+        param ($name, $valueToSet)
+
+        $x = $null
+        $x ?= $valueToSet
+        $x | Should -Be $valueToSet
+    }
+
+    It 'Validate hashtable can be set' {
+        $x = $null
+        $x ?= @{ 1 = '1'}
+        $x.Keys | Should -Be @(1)
+    }
+}