Change Null coalescing assigned operator to ??=

Author: adityapatwardhan

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

@@ -794,7 +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);
+                case TokenKind.QuestionQuestionEquals: return GetCoalesceExpression(right, av, tokenKind);
             }
 
             var exprs = new List<Expression>();
@@ -810,7 +810,7 @@ private Expression GetCoalesceExpression(Expression rhs, IAssignableValue leftAs
             var temps = new List<ParameterExpression>();
             var leftExpr = leftAssignableValue.GetValue(this, exprs, temps);
 
-            if (tokenKind == TokenKind.QuestionEquals)
+            if (tokenKind == TokenKind.QuestionQuestionEquals)
             {
                 exprs.Add(leftAssignableValue.SetValue(this, Expression.MakeBinary(ExpressionType.Coalesce,leftExpr,rhs)));
                 return Expression.Block(temps, exprs);

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

@@ -417,7 +417,7 @@ public enum TokenKind
         QuestionMark = 100,
 
         /// <summary>The null conditional assignment operator '?='.</summary>
-        QuestionEquals = 101,
+        QuestionQuestionEquals = 101,
 
         /// <summary>The null coalesce operator '??'.</summary>
         QuestionQuestion = 102,
@@ -860,7 +860,7 @@ public static class TokenTraits
             /*                  Shr */ TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison | TokenFlags.CanConstantFold,
             /*                Colon */ TokenFlags.SpecialOperator | TokenFlags.DisallowedInRestrictedMode,
             /*         QuestionMark */ TokenFlags.TernaryOperator | TokenFlags.DisallowedInRestrictedMode,
-            /*      QuestionEquals  */ TokenFlags.AssignmentOperator,
+         /* QuestionQuestionEquals  */ TokenFlags.AssignmentOperator,
             /*    QuestionQuestion  */ TokenFlags.BinaryOperator,
             /*     Reserved slot 5  */ TokenFlags.None,
             /*     Reserved slot 6  */ TokenFlags.None,
@@ -1057,7 +1057,7 @@ public static class TokenTraits
             /*                  Shl */ "-shl",
             /*                  Shr */ "-shr",
             /*                Colon */ ":",
-            /*       QuestionEquals */ "?=",
+          /* QuestionQuestionEquals */ "??=",
             /*     QuestionQuestion */ "??",
             /*    Reserved slot 4   */ string.Empty,
             /*    Reserved slot 5   */ string.Empty,

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

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

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

@@ -3,7 +3,7 @@
 
 Describe 'NullConditionalOperations' -tag 'CI' {
 
-    Context "Null conditional assignment operator ?=" {
+    Context "Null conditional assignment operator ??=" {
         BeforeAll {
             $someGuid = New-Guid
 
@@ -21,43 +21,43 @@ Describe 'NullConditionalOperations' -tag 'CI' {
         It 'Variable doesnot exist' {
             Remove-Variable variableDoesNotExist -ErrorAction SilentlyContinue -Force
 
-            $variableDoesNotExist ?= 1
+            $variableDoesNotExist ??= 1
             $variableDoesNotExist | Should -Be 1
 
-            $variableDoesNotExist ?= 2
+            $variableDoesNotExist ??= 2
             $variableDoesNotExist | Should -Be 1
         }
 
         It 'Variable exists and is null' {
             $variableDoesNotExist = $null
 
-            $variableDoesNotExist ?= 2
+            $variableDoesNotExist ??= 2
             $variableDoesNotExist | Should -Be 2
         }
 
         It 'Validate types - <name> can be set' -TestCases $typesTests {
             param ($name, $valueToSet)
 
             $x = $null
-            $x ?= $valueToSet
+            $x ??= $valueToSet
             $x | Should -Be $valueToSet
         }
 
         It 'Validate hashtable can be set' {
             $x = $null
-            $x ?= @{ 1 = '1' }
+            $x ??= @{ 1 = '1' }
             $x.Keys | Should -Be @(1)
         }
 
         It 'Validate lhs is returned' {
             $x = 100
-            $x ?= 200
+            $x ??= 200
             $x | Should -Be 100
         }
 
         It 'Error case' {
             $e = $null
-            $null = [System.Management.Automation.Language.Parser]::ParseInput('1 ?= 100', [ref] $null, [ref] $e)
+            $null = [System.Management.Automation.Language.Parser]::ParseInput('1 ??= 100', [ref] $null, [ref] $e)
             $e[0].ErrorId | Should -BeExactly 'InvalidLeftHandSide'
         }
     }
@@ -102,11 +102,11 @@ Describe 'NullConditionalOperations' -tag 'CI' {
 
     Context 'Combined usage of null conditional operators' {
 
-        It '?? and ?= used together' {
-            $x ?= 100 ?? 200
+        It '?? and ??= used together' {
+            $x ??= 100 ?? 200
             $x | Should -Be 100
 
-            $y ?= 100 ?? 200
+            $y ??= 100 ?? 200
             $y | Should -Be 100
         }
     }