Add VerboseAction, DebugAction, ProgressAction, VerboseVariable, DebugVariable, and ProgressVariable common parameters

src/Microsoft.PowerShell.Commands.Utility/commands/utility/ImplicitRemotingCommands.cs

@@ -2727,7 +2727,22 @@ private string GenerateCertificateThumbprintParameter()
 
     $clientSideParameters = @{}
 
-    $parametersToLeaveRemote = 'ErrorAction', 'WarningAction', 'InformationAction'
+    $parametersToLeaveRemote = if (!$EnabledExperimentalFeatures.Contains('PSNewCommonParameters')) {
+        @(
+            'ErrorAction'
+            'InformationAction'
+            'WarningAction'
+        )
+    } else {
+        @(
+            'DebugAction'
+            'ErrorAction'
+            'InformationAction'
+            'ProgressAction'
+            'VerboseAction'
+            'WarningAction'
+        )
+    }
 
     Modify-PSImplicitRemotingParameters $clientSideParameters $PSBoundParameters 'AsJob'
     if ($proxyForCmdlet)

src/Microsoft.PowerShell.Security/security/CertificateProvider.cs

@@ -4,28 +4,28 @@
 #if !UNIX
 
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.IO;
 using System.Management.Automation;
 using System.Management.Automation.Host;
 using System.Management.Automation.Internal;
-using Runspaces = System.Management.Automation.Runspaces;
-using Dbg = System.Management.Automation;
-using Security = System.Management.Automation.Security;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Collections;
-using System.Runtime.InteropServices;
 using System.Management.Automation.Provider;
+using System.Runtime.InteropServices;
+using System.Security;
 using System.Security.Cryptography;
 using System.Security.Cryptography.X509Certificates;
 using System.Text.RegularExpressions;
-using System.Globalization;
-using System.IO;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Xml;
 using System.Xml.XPath;
-using System.Security;
 using DWORD = System.UInt32;
+using Runspaces = System.Management.Automation.Runspaces;
+using Security = System.Management.Automation.Security;
+using Sma = System.Management.Automation;
 
 namespace Microsoft.PowerShell.Commands
 {
@@ -1188,7 +1188,7 @@ protected override void GetItem(string path)
                         // satisfies the filter, output it.  Otherwise, don't.
 
                         X509Certificate2 cert = item as X509Certificate2;
-                        Dbg.Diagnostics.Assert(cert != null, "item should be a certificate");
+                        Sma.Diagnostics.Assert(cert != null, "item should be a certificate");
 
                         // If it's Win8 or above, filter matching for certain properties is done by
                         // the certificate enumeration filter at the API level. In that case,
@@ -1299,17 +1299,14 @@ private void AttemptToImportPkiModule()
 
             try
             {
-                System.Management.Automation.PowerShell ps = null;
-                ps = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace)
-                            .AddCommand(importModuleCommand)
-                                .AddParameter("Name", moduleName)
-                                .AddParameter("Scope", StringLiterals.Global)
-                                .AddParameter("ErrorAction", ActionPreference.Ignore)
-                                .AddParameter("WarningAction", ActionPreference.Ignore)
-                                .AddParameter("InformationAction", ActionPreference.Ignore)
-                                .AddParameter("Verbose", false)
-                                .AddParameter("Debug", false);
-                ps.Invoke();
+                using (var ps = Sma.PowerShell.Create(RunspaceMode.CurrentRunspace))
+                {
+                    ps.AddCommand(importModuleCommand)
+                      .AddParameter("Name", moduleName)
+                      .AddParameter("Scope", StringLiterals.Global)
+                      .IgnoreMessageStreamParameters()
+                      .Invoke();
+                }
             }
             catch (Exception)
             {
@@ -2683,7 +2680,7 @@ private static object GetCachedItem(string path)
                 if (s_pathCache.ContainsKey(path))
                 {
                     item = s_pathCache[path];
-                    Dbg.Diagnostics.Assert(item != null, "GetCachedItem");
+                    Sma.Diagnostics.Assert(item != null, "GetCachedItem");
                 }
             }
 

src/System.Management.Automation/FormatAndOutput/DefaultFormatters/PowerShellCore_format_ps1xml.cs

@@ -157,6 +157,10 @@ internal static IEnumerable<ExtendedTypeDefinition> GetFormatData()
                 "System.Management.Automation.InformationRecord",
                 ViewsOf_System_Management_Automation_InformationRecord());
 
+            yield return new ExtendedTypeDefinition(
+                "System.Management.Automation.ProgressRecord",
+                ViewsOf_System_Management_Automation_ProgressRecord());
+
             yield return new ExtendedTypeDefinition(
                 "System.Exception",
                 ViewsOf_System_Exception());
@@ -1248,6 +1252,29 @@ private static IEnumerable<FormatViewDefinition> ViewsOf_System_Management_Autom
                 .EndControl());
         }
 
+        private static IEnumerable<FormatViewDefinition> ViewsOf_System_Management_Automation_ProgressRecord()
+        {
+            // This generates string output that uses the following format:
+            //   PROGRESS: [<PercentComplete>% - ]<Activity>[: <StatusDescription>][ (<CurrentOperation>)]
+            // Activity is always shown.
+            // Items in square brackets are conditional, so:
+            // - PercentComplete only shows up if it is set, and uses a format like this: " 83% -"
+            // - StatusDescription is only shown if it is not "Processing"
+            // - CurrentOperation is only shown if it is not null or empty
+            // The end result is a string that might look something like any of the following examples:
+            //   PROGRESS: Initializing...
+            //   PROGRESS:  57% - Creating user: 57 of 100 (Initializing home directory)
+            //   PROGRESS: 100% - Task finished
+            yield return new FormatViewDefinition(
+                "ProgressRecord",
+                CustomControl
+                    .Create(outOfBand: true)
+                        .StartEntry()
+                            .AddScriptBlockExpressionBinding($@"'{FormatStrings.ProgressFormatString}' -f ""$(if ($_.PercentComplete -ge 0) {{'{{0,3}}% - ' -f $_.PercentComplete}})$($_.Activity)$(if ($_.StatusDescription -ne '{FormatStrings.Processing}') {{"": $($_.StatusDescription)""}})$(if ($_.CurrentOperation) {{"" ($($_.CurrentOperation))""}})""")
+                        .EndEntry()
+                    .EndControl());
+        }
+
         private static IEnumerable<FormatViewDefinition> ViewsOf_System_Exception()
         {
             yield return new FormatViewDefinition("Exception",

src/System.Management.Automation/engine/CommandDiscovery.cs

@@ -919,20 +919,17 @@ internal static Collection<PSModuleInfo> AutoloadSpecifiedModule(string moduleNa
 
             discoveryTracer.WriteLine("Attempting to load module: {0}", moduleName);
 
-            PowerShell ps = null;
             try
             {
-                ps = PowerShell.Create(RunspaceMode.CurrentRunspace)
-                    .AddCommand(importModuleCommand)
-                    .AddParameter("Name", moduleName)
-                     .AddParameter("Scope", StringLiterals.Global)
-                     .AddParameter("PassThru")
-                     .AddParameter("ErrorAction", ActionPreference.Ignore)
-                     .AddParameter("WarningAction", ActionPreference.Ignore)
-                     .AddParameter("InformationAction", ActionPreference.Ignore)
-                     .AddParameter("Verbose", false)
-                     .AddParameter("Debug", false);
-                matchingModules = (Collection<PSModuleInfo>)ps.Invoke<PSModuleInfo>();
+                using (var ps = PowerShell.Create(RunspaceMode.CurrentRunspace))
+                {
+                    ps.AddCommand(importModuleCommand)
+                      .AddParameter("Name", moduleName)
+                      .AddParameter("Scope", StringLiterals.Global)
+                      .AddParameter("PassThru")
+                      .IgnoreMessageStreamParameters();
+                    matchingModules = ps.Invoke<PSModuleInfo>();
+                }
             }
             catch (Exception e)
             {

src/System.Management.Automation/engine/CommonCommandParameters.cs

@@ -102,6 +102,40 @@ public ActionPreference WarningAction
             set { _commandRuntime.WarningPreference = value; }
         }
 
+        /// <summary>
+        /// Gets or sets the value of the VerboseAction parameter for the cmdlet.
+        /// </summary>
+        /// <remarks>
+        /// This parameter tells the command what to do when a verbose record
+        /// occurs.
+        /// </remarks>
+        [Experimental("PSNewCommonParameters", ExperimentAction.Show)]
+        [Parameter]
+        [Alias("va")]
+        public ActionPreference VerboseAction
+        {
+            get { return _commandRuntime.VerbosePreference; }
+
+            set { _commandRuntime.VerbosePreference = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the value of the DebugAction parameter for the cmdlet.
+        /// </summary>
+        /// <remarks>
+        /// This parameter tells the command what to do when a debug record
+        /// occurs.
+        /// </remarks>
+        [Experimental("PSNewCommonParameters", ExperimentAction.Show)]
+        [Parameter]
+        [Alias("da")]
+        public ActionPreference DebugAction
+        {
+            get { return _commandRuntime.DebugPreference; }
+
+            set { _commandRuntime.DebugPreference = value; }
+        }
+
         /// <summary>
         /// Gets or sets the value of the InformationAction parameter for the cmdlet.
         /// </summary>
@@ -123,6 +157,22 @@ public ActionPreference InformationAction
             set { _commandRuntime.InformationPreference = value; }
         }
 
+        /// <summary>
+        /// Gets or sets the value of the ProgressAction parameter for the cmdlet.
+        /// </summary>
+        /// <remarks>
+        /// This parameter tells the command what to do when an progress record occurs.
+        /// </remarks>
+        [Experimental("PSNewCommonParameters", ExperimentAction.Show)]
+        [Parameter]
+        [Alias("pra")]
+        public ActionPreference ProgressAction
+        {
+            get { return _commandRuntime.ProgressPreference; }
+
+            set { _commandRuntime.ProgressPreference = value; }
+        }
+
         /// <summary>
         /// Gets or sets the value of the ErrorVariable parameter for the cmdlet.
         /// </summary>
@@ -161,6 +211,42 @@ public string WarningVariable
             set { _commandRuntime.WarningVariable = value; }
         }
 
+        /// <summary>
+        /// Gets or sets the value of the VerboseVariable parameter for the cmdlet.
+        /// </summary>
+        /// <remarks>
+        /// This parameter tells the command which variable to populate with verbose messages.
+        /// Use +varname to append to the variable rather than clearing it.
+        /// </remarks>
+        [Experimental("PSNewCommonParameters", ExperimentAction.Show)]
+        [Parameter]
+        [Alias("vv")]
+        [ValidateVariableName]
+        public string VerboseVariable
+        {
+            get { return _commandRuntime.VerboseVariable; }
+
+            set { _commandRuntime.VerboseVariable = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the value of the DebugVariable parameter for the cmdlet.
+        /// </summary>
+        /// <remarks>
+        /// This parameter tells the command which variable to populate with debug messages.
+        /// Use +varname to append to the variable rather than clearing it.
+        /// </remarks>
+        [Experimental("PSNewCommonParameters", ExperimentAction.Show)]
+        [Parameter]
+        [Alias("dv")]
+        [ValidateVariableName]
+        public string DebugVariable
+        {
+            get { return _commandRuntime.DebugVariable; }
+
+            set { _commandRuntime.DebugVariable = value; }
+        }
+
         /// <summary>
         /// Gets or sets the value of the InformationVariable parameter for the cmdlet.
         /// </summary>
@@ -178,6 +264,24 @@ public string InformationVariable
             set { _commandRuntime.InformationVariable = value; }
         }
 
+        /// <summary>
+        /// Gets or sets the value of the ProgressVariable parameter for the cmdlet.
+        /// </summary>
+        /// <remarks>
+        /// This parameter tells the command which variable to populate with progress messages.
+        /// Use +varname to append to the variable rather than clearing it.
+        /// </remarks>
+        [Experimental("PSNewCommonParameters", ExperimentAction.Show)]
+        [Parameter]
+        [Alias("prv")]
+        [ValidateVariableName]
+        public string ProgressVariable
+        {
+            get { return _commandRuntime.ProgressVariable; }
+
+            set { _commandRuntime.ProgressVariable = value; }
+        }
+
         /// <summary>
         /// Gets or sets the OutVariable parameter for the cmdlet.
         /// </summary>

src/System.Management.Automation/engine/ExecutionContext.cs

@@ -1154,6 +1154,20 @@ internal ActionPreference InformationActionPreferenceVariable
             }
         }
 
+        internal ActionPreference ProgressActionPreferenceVariable
+        {
+            get => GetEnumPreference(
+                SpecialVariables.ProgressPreferenceVarPath,
+                InitialSessionState.defaultProgressPreference,
+                out _);
+
+            set => EngineSessionState.SetVariable(
+                SpecialVariables.ProgressPreferenceVarPath,
+                LanguagePrimitives.ConvertTo(value, typeof(ActionPreference), CultureInfo.InvariantCulture),
+                true,
+                CommandOrigin.Internal);
+        }
+
         internal object WhatIfPreferenceVariable
         {
             get

src/System.Management.Automation/engine/ExperimentalFeature/ExperimentalFeature.cs

@@ -112,6 +112,9 @@ static ExperimentalFeature()
                 new ExperimentalFeature(
                     name: "PSForEachObjectParallel",
                     description: "New parameter set for ForEach-Object to run script blocks in parallel"),
+                new ExperimentalFeature(
+                    name: "PSNewCommonParameters",
+                    description: "New -DebugAction, -DebugVariable, -ProgressAction, -ProgressVariable, -VerboseAction, and -VerboseVariable common parameters"),
                 new ExperimentalFeature(
                     name: "PSTernaryOperator",
                     description: "Support the ternary operator in PowerShell language"),

src/System.Management.Automation/engine/Modules/AnalysisCache.cs

@@ -593,16 +593,14 @@ private static void CallGetModuleDashList(ExecutionContext context, string modul
 
             try
             {
-                PowerShell.Create(RunspaceMode.CurrentRunspace)
-                    .AddCommand(getModuleCommand)
-                        .AddParameter("List", true)
-                        .AddParameter("ErrorAction", ActionPreference.Ignore)
-                        .AddParameter("WarningAction", ActionPreference.Ignore)
-                        .AddParameter("InformationAction", ActionPreference.Ignore)
-                        .AddParameter("Verbose", false)
-                        .AddParameter("Debug", false)
-                        .AddParameter("Name", modulePath)
-                    .Invoke();
+                using (var ps = PowerShell.Create(RunspaceMode.CurrentRunspace))
+                {
+                    ps.AddCommand(getModuleCommand)
+                      .AddParameter("List", true)
+                      .AddParameter("Name", modulePath)
+                      .IgnoreMessageStreamParameters()
+                      .Invoke();
+                }
             }
             catch (Exception e)
             {

src/System.Management.Automation/engine/Modules/RemoteDiscoveryHelper.cs

@@ -476,6 +476,12 @@ private static void HandleErrorFromPipeline(Cmdlet cmdlet, ErrorRecord errorReco
             CopyParameterFromCmdletToPowerShell(cmdlet, powerShell, "InformationAction");
             CopyParameterFromCmdletToPowerShell(cmdlet, powerShell, "Verbose");
             CopyParameterFromCmdletToPowerShell(cmdlet, powerShell, "Debug");
+            if (ExperimentalFeature.EnabledExperimentalFeatureNames.Contains("PSNewCommonParameters"))
+            {
+                CopyParameterFromCmdletToPowerShell(cmdlet, powerShell, "VerboseAction");
+                CopyParameterFromCmdletToPowerShell(cmdlet, powerShell, "DebugAction");
+                CopyParameterFromCmdletToPowerShell(cmdlet, powerShell, "ProgressAction");
+            }
 
             var invocationSettings = new PSInvocationSettings { Host = cmdlet.Host };