Fix &! operator: parser terminator, scriptblock body extraction, and ThreadJob cmdlet resolution

src/System.Management.Automation/engine/lang/interface/PSToken.cs

@@ -303,6 +303,8 @@ public static PSTokenType GetPSTokenType(Token token)
             /*               Hidden */ PSTokenType.Keyword,
             /*                 Base */ PSTokenType.Keyword,
             /*              Default */ PSTokenType.Keyword,
+            /*                Clean */ PSTokenType.Keyword,
+            /*     AmpersandExclaim */ PSTokenType.Operator,
 
             #endregion Flags for keywords
 

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

@@ -5346,6 +5346,7 @@ private StatementAst FunctionDeclarationRule(Token functionToken)
                 case TokenKind.AndAnd:
                 case TokenKind.OrOr:
                 case TokenKind.Ampersand:
+                case TokenKind.AmpersandExclaim:
                 case TokenKind.Variable:
                 case TokenKind.SplattedVariable:
                 case TokenKind.HereStringExpandable:
@@ -5849,6 +5850,7 @@ private PipelineBaseAst PipelineChainRule()
             Token currentChainOperatorToken = null;
             Token nextToken = null;
             bool background = false;
+            bool backgroundThreadJob = false;
             while (true)
             {
                 // Look for the next pipeline in the chain,
@@ -5938,6 +5940,24 @@ private PipelineBaseAst PipelineChainRule()
                         background = true;
                         goto default;
 
+                    // ThreadJob background operator
+                    case TokenKind.AmpersandExclaim:
+                        SkipToken();
+                        nextToken = PeekToken();
+
+                        switch (nextToken.Kind)
+                        {
+                            case TokenKind.AndAnd:
+                            case TokenKind.OrOr:
+                                SkipToken();
+                                ReportError(nextToken.Extent, nameof(ParserStrings.BackgroundOperatorInPipelineChain), ParserStrings.BackgroundOperatorInPipelineChain);
+                                return new ErrorStatementAst(ExtentOf(currentPipelineChain ?? nextPipeline, nextToken.Extent));
+                        }
+
+                        background = true;
+                        backgroundThreadJob = true;
+                        goto default;
+
                     // No more chain operators -- return
                     default:
                         // If we haven't seen a chain yet, pass through the pipeline
@@ -5951,15 +5971,18 @@ private PipelineBaseAst PipelineChainRule()
 
                             // Set background on the pipeline AST
                             nextPipeline.Background = true;
+                            nextPipeline.BackgroundThreadJob = backgroundThreadJob;
                             return nextPipeline;
                         }
 
-                        return new PipelineChainAst(
+                        var chainAst = new PipelineChainAst(
                             ExtentOf(currentPipelineChain.Extent, nextPipeline.Extent),
                             currentPipelineChain,
                             nextPipeline,
                             currentChainOperatorToken.Kind,
                             background);
+                        chainAst.BackgroundThreadJob = backgroundThreadJob;
+                        return chainAst;
                 }
 
                 // Assemble the new chain statement AST
@@ -6008,6 +6031,7 @@ private PipelineBaseAst PipelineRule(
             Token nextToken = null;
             bool scanning = true;
             bool background = false;
+            bool backgroundThreadJob = false;
             ExpressionAst expr = startExpression;
             while (scanning)
             {
@@ -6125,6 +6149,20 @@ private PipelineBaseAst PipelineRule(
                         background = true;
                         break;
 
+                    case TokenKind.AmpersandExclaim:
+                        if (!allowBackground)
+                        {
+                            // Handled by invoking rule
+                            scanning = false;
+                            continue;
+                        }
+
+                        SkipToken();
+                        scanning = false;
+                        background = true;
+                        backgroundThreadJob = true;
+                        break;
+
                     case TokenKind.Pipe:
                         SkipToken();
                         SkipNewlines();
@@ -6156,7 +6194,12 @@ private PipelineBaseAst PipelineRule(
                 return null;
             }
 
-            return new PipelineAst(ExtentOf(startExtent, pipelineElements[pipelineElements.Count - 1]), pipelineElements, background);
+            var pipeline = new PipelineAst(ExtentOf(startExtent, pipelineElements[pipelineElements.Count - 1]), pipelineElements, background);
+            if (backgroundThreadJob)
+            {
+                pipeline.BackgroundThreadJob = true;
+            }
+            return pipeline;
         }
 
         private RedirectionAst RedirectionRule(RedirectionToken redirectionToken, RedirectionAst[] redirections, ref IScriptExtent extent)
@@ -6316,6 +6359,7 @@ private ExpressionAst GetCommandArgument(CommandArgumentContext context, Token t
                     case TokenKind.AndAnd:
                     case TokenKind.OrOr:
                     case TokenKind.Ampersand:
+                    case TokenKind.AmpersandExclaim:
                     case TokenKind.MinusMinus:
                     case TokenKind.Comma:
                         UngetToken(token);
@@ -6520,6 +6564,7 @@ internal Ast CommandRule(bool forDynamicKeyword)
                         case TokenKind.AndAnd:
                         case TokenKind.OrOr:
                         case TokenKind.Ampersand:
+                        case TokenKind.AmpersandExclaim:
                             UngetToken(token);
                             scanning = false;
                             continue;

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

@@ -5610,7 +5610,9 @@ public PipelineChainAst(
         /// </returns>
         public override Ast Copy()
         {
-            return new PipelineChainAst(Extent, CopyElement(LhsPipelineChain), CopyElement(RhsPipeline), Operator, Background);
+            var copy = new PipelineChainAst(Extent, CopyElement(LhsPipelineChain), CopyElement(RhsPipeline), Operator, Background);
+            copy.BackgroundThreadJob = this.BackgroundThreadJob;
+            return copy;
         }
 
         internal override object Accept(ICustomAstVisitor visitor)
@@ -5675,6 +5677,11 @@ public virtual ExpressionAst GetPureExpression()
         {
             return null;
         }
+
+        /// <summary>
+        /// Indicates that this pipeline should be run in the background as a ThreadJob.
+        /// </summary>
+        public bool BackgroundThreadJob { get; internal set; }
     }
 
     /// <summary>
@@ -5793,7 +5800,9 @@ public override ExpressionAst GetPureExpression()
         public override Ast Copy()
         {
             var newPipelineElements = CopyElements(this.PipelineElements);
-            return new PipelineAst(this.Extent, newPipelineElements, this.Background);
+            var copy = new PipelineAst(this.Extent, newPipelineElements, this.Background);
+            copy.BackgroundThreadJob = this.BackgroundThreadJob;
+            return copy;
         }
 
         #region Visitors

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

@@ -591,6 +591,9 @@ public enum TokenKind
         /// <summary>The 'clean' keyword.</summary>
         Clean = 170,
 
+        /// <summary>The ThreadJob background operator '&!'.</summary>
+        AmpersandExclaim = 171,
+
         #endregion Keywords
     }
 
@@ -952,6 +955,7 @@ public static class TokenTraits
             /*                 Base */ TokenFlags.Keyword,
             /*              Default */ TokenFlags.Keyword,
             /*                Clean */ TokenFlags.Keyword | TokenFlags.ScriptBlockBlockName,
+            /*     AmpersandExclaim */ TokenFlags.SpecialOperator | TokenFlags.ParseModeInvariant,
 
             #endregion Flags for keywords
         };
@@ -1152,6 +1156,7 @@ public static class TokenTraits
             /*                 Base */ "base",
             /*              Default */ "default",
             /*                Clean */ "clean",
+            /*     AmpersandExclaim */ "&!",
 
             #endregion Text for keywords
         };
@@ -1160,10 +1165,10 @@ public static class TokenTraits
         static TokenTraits()
         {
             Diagnostics.Assert(
-                s_staticTokenFlags.Length == ((int)TokenKind.Clean + 1),
+                s_staticTokenFlags.Length == ((int)TokenKind.AmpersandExclaim + 1),
                 "Table size out of sync with enum - _staticTokenFlags");
             Diagnostics.Assert(
-                s_tokenText.Length == ((int)TokenKind.Clean + 1),
+                s_tokenText.Length == ((int)TokenKind.AmpersandExclaim + 1),
                 "Table size out of sync with enum - _tokenText");
             // Some random assertions to make sure the enum and the traits are in sync
             Diagnostics.Assert(GetTraits(TokenKind.Begin) == (TokenFlags.Keyword | TokenFlags.ScriptBlockBlockName),

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

@@ -4975,12 +4975,19 @@ internal Token NextToken()
                     return ScanNumber(c);
 
                 case '&':
-                    if (PeekChar() == '&')
+                    c1 = PeekChar();
+                    if (c1 == '&')
                     {
                         SkipChar();
                         return NewToken(TokenKind.AndAnd);
                     }
 
+                    if (c1 == '!')
+                    {
+                        SkipChar();
+                        return NewToken(TokenKind.AmpersandExclaim);
+                    }
+
                     return NewToken(TokenKind.Ampersand);
 
                 case '|':