PowerShell · bergmeister · Jul 6, 2019 · Jul 7, 2019 · Jul 7, 2019 · Jul 7, 2019
diff --git a/src/System.Management.Automation/engine/ExperimentalFeature/ExperimentalFeature.cs b/src/System.Management.Automation/engine/ExperimentalFeature/ExperimentalFeature.cs
@@ -123,6 +123,9 @@ static ExperimentalFeature()
                 new ExperimentalFeature(
                     name: "PSNativePSPathResolution",
                     description: "Convert PSPath to filesystem path, if possible, for native commands"),
+                new ExperimentalFeature(
+                    name: "PSGeneralizedSplatting",
+                    description: "Preliminary support for generalized splatting, currently only inline splatting"),
             };
             EngineExperimentalFeatures = new ReadOnlyCollection<ExperimentalFeature>(engineFeatures);
 

@@ -4145,10 +4145,17 @@ public object VisitCommand(CommandAst commandAst)
                         splatTest = usingExpression.SubExpression;
                     }
 
-                    VariableExpressionAst variableExpression = splatTest as VariableExpressionAst;
-                    if (variableExpression != null)
+                    switch (splatTest)
                     {
-                        splatted = variableExpression.Splatted;
+                        case VariableExpressionAst variableExpressionAst:
+                            splatted = variableExpressionAst.Splatted;
+                            break;
+                        case HashtableAst hashTableAst:
+                            if (ExperimentalFeature.IsEnabled("PSGeneralizedSplatting"))
+                            {
+                                splatted = hashTableAst.Splatted;
+                            }
+                            break;
                     }
 
                     elementExprs[i] = Expression.Call(

@@ -6291,6 +6291,7 @@ private ExpressionAst GetCommandArgument(CommandArgumentContext context, Token t
                     case TokenKind.AtParen:
                     case TokenKind.AtCurly:
                     case TokenKind.LCurly:
+                    case TokenKind.At:
                         UngetToken(token);
                         exprAst = PrimaryExpressionRule(withMemberAccess: true);
                         Diagnostics.Assert(exprAst != null, "PrimaryExpressionRule should never return null");
@@ -7231,7 +7232,8 @@ private ExpressionAst PrimaryExpressionRule(bool withMemberAccess)
                     break;
 
                 case TokenKind.AtCurly:
-                    expr = HashExpressionRule(token, false /* parsingSchemaElement */ );
+                case TokenKind.At:
+                    expr = HashExpressionRule(token, parsingSchemaElement: false);
                     break;
 
                 case TokenKind.LCurly:
@@ -7305,6 +7307,17 @@ private ExpressionAst HashExpressionRule(Token atCurlyToken, bool parsingSchemaE
             SkipNewlines();
 
             List<KeyValuePair> keyValuePairs = new List<KeyValuePair>();
+
+            bool splatted = false;
+            if (ExperimentalFeature.IsEnabled("PSGeneralizedSplatting"))
+            {
+                if (atCurlyToken.Kind == TokenKind.At)
+                {
+                    NextToken();
+                    splatted = true;
+                }
+            }
+
             while (true)
             {
                 KeyValuePair pair = GetKeyValuePair(parsingSchemaElement);
@@ -7350,9 +7363,11 @@ private ExpressionAst HashExpressionRule(Token atCurlyToken, bool parsingSchemaE
                 endExtent = rCurly.Extent;
             }
 
-            var hashAst = new HashtableAst(ExtentOf(atCurlyToken, endExtent), keyValuePairs);
-            hashAst.IsSchemaElement = parsingSchemaElement;
-            return hashAst;
+            var hashtableAst = new HashtableAst(ExtentOf(atCurlyToken, endExtent), keyValuePairs, splatted)
+            {
+                IsSchemaElement = parsingSchemaElement,
+            };
+            return hashtableAst;
         }
 
         private KeyValuePair GetKeyValuePair(bool parsingSchemaElement)

@@ -1096,6 +1096,18 @@ public override AstVisitAction VisitVariableExpression(VariableExpressionAst var
 
         public override AstVisitAction VisitHashtable(HashtableAst hashtableAst)
         {
+            if (ExperimentalFeature.IsEnabled("PSGeneralizedSplatting"))
+            {
+                // Check usage of generalized splatting, which supports only arguments to a command at the moment
+                if (hashtableAst.Splatted && hashtableAst.KeyValuePairs.Count > 0 && !(hashtableAst.Parent is CommandAst))
+                {
+                    _parser.ReportError(hashtableAst.Extent,
+                        nameof(ParserStrings.GeneralizedSplattingOnlyPermittedForCommands),
+                        ParserStrings.GeneralizedSplattingOnlyPermittedForCommands,
+                        hashtableAst);
+                }
+            }
+
             HashSet<string> keys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
             foreach (var entry in hashtableAst.KeyValuePairs)
             {

@@ -9833,11 +9833,12 @@ public class HashtableAst : ExpressionAst
         /// </summary>
         /// <param name="extent">The extent of the literal, from '@{' to the closing '}'.</param>
         /// <param name="keyValuePairs">The optionally null or empty list of key/value pairs.</param>
+        /// <param name="splatted">Whether it is splatted.</param>
         /// <exception cref="PSArgumentNullException">
         /// If <paramref name="extent"/> is null.
         /// </exception>
         [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures")]
-        public HashtableAst(IScriptExtent extent, IEnumerable<KeyValuePair> keyValuePairs)
+        public HashtableAst(IScriptExtent extent, IEnumerable<KeyValuePair> keyValuePairs, bool splatted)
             : base(extent)
         {
             if (keyValuePairs != null)
@@ -9849,6 +9850,7 @@ public HashtableAst(IScriptExtent extent, IEnumerable<KeyValuePair> keyValuePair
             {
                 this.KeyValuePairs = s_emptyKeyValuePairs;
             }
+            Splatted = splatted;
         }
 
         /// <summary>
@@ -9875,7 +9877,7 @@ public override Ast Copy()
                 }
             }
 
-            return new HashtableAst(this.Extent, newKeyValuePairs);
+            return new HashtableAst(this.Extent, newKeyValuePairs, this.Splatted);
         }
 
         /// <summary>
@@ -9886,6 +9888,11 @@ public override Ast Copy()
         // Indicates that this ast was constructed as part of a schematized object instead of just a plain hash literal.
         internal bool IsSchemaElement { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether inline splatting syntax (using @) was used, false otherwise.
+        /// </summary>
+        public bool Splatted { get; }
+
         #region Visitors
 
         internal override object Accept(ICustomAstVisitor visitor)

@@ -6,6 +6,7 @@
 using System.Collections.ObjectModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
+using System.Linq;
 using System.Management.Automation.Internal;
 using System.Text;
 
@@ -428,6 +429,12 @@ public enum TokenKind
         /// <summary>The null conditional index access operator '?[]'.</summary>
         QuestionLBracket = 104,
 
+        /// <summary>
+        /// The unary operator used for generalized splatting expressions.
+        /// This excludes the legacy token <see cref="TokenKind.SplattedVariable"/>.
+        /// </summary>
+        At = 105,
+
         #endregion Operators
 
         #region Keywords
@@ -878,7 +885,7 @@ public static class TokenTraits
             /*     QuestionQuestion */ TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceCoalesce,
             /*          QuestionDot */ TokenFlags.SpecialOperator | TokenFlags.DisallowedInRestrictedMode,
             /*     QuestionLBracket */ TokenFlags.None,
-            /*     Reserved slot 7  */ TokenFlags.None,
+            /*                   At */ TokenFlags.None,
             /*     Reserved slot 8  */ TokenFlags.None,
             /*     Reserved slot 9  */ TokenFlags.None,
             /*     Reserved slot 10 */ TokenFlags.None,
@@ -1077,7 +1084,7 @@ public static class TokenTraits
             /*     QuestionQuestion */ "??",
             /*          QuestionDot */ "?.",
             /*     QuestionLBracket */ "?[",
-            /*    Reserved slot 7   */ string.Empty,
+            /*                   At */ "@",
             /*    Reserved slot 8   */ string.Empty,
             /*    Reserved slot 9   */ string.Empty,
             /*    Reserved slot 10  */ string.Empty,
@@ -1154,10 +1161,11 @@ public static class TokenTraits
 #if DEBUG
         static TokenTraits()
         {
-            Diagnostics.Assert(s_staticTokenFlags.Length == ((int)TokenKind.Default + 1),
-                               "Table size out of sync with enum - _staticTokenFlags");
-            Diagnostics.Assert(s_tokenText.Length == ((int)TokenKind.Default + 1),
-                               "Table size out of sync with enum - _tokenText");
+            var maximumEnumValueOfTokenKind = Enum.GetValues(typeof(TokenKind)).Cast<int>().Max();
+            Diagnostics.Assert(s_staticTokenFlags.Length - 1 == maximumEnumValueOfTokenKind,
+                               $"Table size out of sync with enum - {nameof(s_staticTokenFlags)}");
+            Diagnostics.Assert(s_tokenText.Length - 1 == maximumEnumValueOfTokenKind,
+                               $"Table size out of sync with enum - {nameof(s_tokenText)}");
             // Some random assertions to make sure the enum and the traits are in sync
             Diagnostics.Assert(GetTraits(TokenKind.Begin) == (TokenFlags.Keyword | TokenFlags.ScriptBlockBlockName),
                                "Table out of sync with enum - flags Begin");

@@ -4674,6 +4674,11 @@ internal Token NextToken()
                         return ScanVariable(true, false);
                     }
 
+                    if (ExperimentalFeature.IsEnabled("PSGeneralizedSplatting"))
+                    {
+                        return NewToken(TokenKind.At);
+                    }
+
                     ReportError(_currentIndex - 1,
                         nameof(ParserStrings.UnrecognizedToken),
                         ParserStrings.UnrecognizedToken);

diff --git a/src/System.Management.Automation/resources/ParserStrings.resx b/src/System.Management.Automation/resources/ParserStrings.resx
@@ -212,6 +212,9 @@ Possible matches are</value>
   <data name="SplattingNotPermittedInArgumentList" xml:space="preserve">
     <value>Splatted variables like '@{0}' cannot be part of a comma-separated list of arguments.</value>
   </data>
+  <data name="GeneralizedSplattingOnlyPermittedForCommands" xml:space="preserve">
+    <value>'{0}' uses the generalized splatting operator, which can be used only as an inline argument to a command. Declare a hashtable variable instead if the intent is to splat it to a command at a later time.</value>
+  </data>
   <data name="MissingFileSpecification" xml:space="preserve">
     <value>Missing file specification after redirection operator.</value>
   </data>

diff --git a/test/powershell/Language/Parser/Parser.Tests.ps1 b/test/powershell/Language/Parser/Parser.Tests.ps1
@@ -1349,3 +1349,36 @@ foo``u{2195}abc
         }
     }
 }
+
+
+Describe 'Splatting' -Tags 'CI' {
+    BeforeAll {
+        $tempFile = New-TemporaryFile
+    }
+    AfterAll {
+        Remove-Item $tempFile
+    }
+
+    Context 'Happy Path' {
+        It "Splatting using hashtable variable '@var'" {
+            $splattedHashTable = @{ Path = $tempFile }
+            Get-Item @splattedHashTable | Should -Not -BeNullOrEmpty
+        }
+
+        It "Splatting using inlined hashtable '@@{key=value}'" {
+            Get-Item @@{ Path = $tempFile; Verbose = $true } | Should -Not -BeNullOrEmpty
+        }
+    }
+
+    Context 'Parameter mismatches' {
+        $skipTest = -not $EnabledExperimentalFeatures.Contains('PSGeneralizedSplatting')
+        It "Splatting using hashtable variable '@var'" -Skip:$skipTest {
+            $splattedHashTable = @{ ParameterThatDoesNotExist = $tempFile }
+            { Get-Item @splattedHashTable } | Should -Throw -ErrorId 'NamedParameterNotFound'
+        }
+
+        It "Splatting using inlined hashtable '@@{key=value}'" -Skip:$skipTest {
+            { Get-Item @@{ ParameterThatDoesNotExist = $tempFile } } | Should -Throw -ErrorId 'NamedParameterNotFound'
+        }
+    }
+}
diff --git a/test/powershell/Language/Parser/Parsing.Tests.ps1 b/test/powershell/Language/Parser/Parsing.Tests.ps1
@@ -641,3 +641,79 @@ Describe "Keywords 'default', 'hidden', 'in', 'static' Token parsing" -Tags CI {
         . $Keyword | Should -BeExactly $Keyword
     }
 }
+
+Describe "Generalized Splatting - Parsing" -Tags CI {
+    BeforeAll {
+        $skipTest = -not $EnabledExperimentalFeatures.Contains('PSGeneralizedSplatting')
+        if ($skipTest) {
+            Write-Verbose "Test Suite Skipped. The test suite requires the experimental feature 'PSGeneralizedSplatting' to be enabled." -Verbose
+            $originalDefaultParameterValues = $PSDefaultParameterValues.Clone()
+            $PSDefaultParameterValues["it:skip"] = $true
+        }
+        else {
+            $testCases_basic = @(
+                @{  Script        = 'Verb-Noun @@{ "ParameterName"="ParameterValue" }';
+                    TokenKind     = [System.Management.Automation.Language.TokenKind]::At;
+                    TokenPosition = 1
+                }
+                @{  Script        = 'Verb-Noun @@{ "ParameterName1"="ParameterValue1"; "ParameterName2"="ParameterValue2" }';
+                    TokenKind     = [System.Management.Automation.Language.TokenKind]::At;
+                    TokenPosition = 1
+                }
+            )
+
+            $testCases_incomplete = @(
+                @{  Script  = '@@{ "Key"="Value" }';
+                    ErrorId = "GeneralizedSplattingOnlyPermittedForCommands";
+                    AstType = [System.Management.Automation.Language.ErrorExpressionAst]
+                }
+                # The following test case is incomplete at the moment but could be implemented as per RFC0002
+                @{  Script  = '$str="1234"; $str.SubString(@@{ StartIndex = 2; Length = 2 })';
+                    ErrorId = "GeneralizedSplattingOnlyPermittedForCommands";
+                    AstType = [System.Management.Automation.Language.ErrorExpressionAst]
+                }
+            )
+        }
+    }
+
+    AfterAll {
+        if ($skipTest) {
+            $global:PSDefaultParameterValues = $originalDefaultParameterValues
+        }
+    }
+
+    It "Using generalized splatting operator '@@' in script <Script> for inline argument splatting of a command" -TestCases $testCases_basic {
+        param($Script, $TokenKind, [int]$TokenPosition)
+
+        $tokens = $null
+        $errors = $null
+        $result = [System.Management.Automation.Language.Parser]::ParseInput($Script, [ref]$tokens, [ref]$errors)
+
+        $tokens[$TokenPosition].Kind | Should -BeExactly $TokenKind
+        $tokens[$TokenPosition].Text | Should -BeExactly '@'
+
+        $result.EndBlock.Statements.PipelineElements[0].CommandElements[1] | Should -BeOfType 'System.Management.Automation.Language.HashtableAst'
+        $result.EndBlock.Statements.PipelineElements[0].CommandElements[1].Extent.Text.StartsWith('@@{') |
+            Should -BeTrue -Because "HashtableAst Extent should start with '@@{'"
+        $result.EndBlock.Statements.PipelineElements[0].CommandElements[1].Extent.Text.EndsWith('}') |
+            Should -BeTrue -Because "HashtableAst Extent should end with '}'"
+    }
+
+    It "Generalized splatting operator '@@' can be used in function name" {
+        function a@@ { 'a@@' }
+        function a@@b { 'a@@b' }
+
+        a@@ | Should -BeExactly 'a@@'
+        a@@b | Should -BeExactly 'a@@b'
+    }
+
+    It "Using generalized splatting expression <Script> not as argument to command should generate correct error" -TestCases $testCases_incomplete {
+        param($Script, $ErrorId, $AstType)
+
+        $errors = $null
+        [System.Management.Automation.Language.Parser]::ParseInput($Script, [ref]$null, [ref]$errors)
+
+        $errors.Count | Should -Be 1
+        $errors.ErrorId | Should -BeExactly $ErrorId
+    }
+}