CommandAst.AsSentence: Expanding array literals (Fixes #291)

Author: StartAutomating

PipeScript.types.ps1xml

@@ -291,6 +291,31 @@ $decamelCase = [Regex]::new('(?<=[a-z])(?=[A-Z])')
     For the purposes of natural language processing ValueFromPipeline will be ignored.
 
     The order the parameters is declared takes precedence over Position attributes.
+.NOTES
+    Each potential command can be thought of as a simple sentence with (mostly) natural syntax
+    
+    command <parametername> ...<parameterargument> (etc)     
+        
+    either more natural or PowerShell syntax should be allowed, for example:
+
+    all functions can Quack {
+        "quack"
+    }
+
+    would map to the command all and the parameters -Function and -Can (with the arguments Quack and {"quack"})
+
+    Assuming -Functions was a `[switch]` or an alias to a `[switch]`, it will match that `[switch]` and only that switch.
+
+    If -Functions was not a `[switch]`, it will match values from that point.
+
+    If the parameter type is not a list or PSObject, only the next parameter will be matched.
+
+    If the parameter type *is* a list or an PSObject, 
+    or ValueFromRemainingArguments is present and no named parameters were found,
+    then all remaining arguments will be matched until the next named parameter is found.
+    
+    _Aliasing is important_ when working with a given parameter.
+    The alias, _not_ the parameter name, will be what is mapped in .Parameters.
 #>
 param()
 
@@ -349,6 +374,20 @@ if ($IsRightToLeft) {
 }
 
 
+$commandElements = # Walk thru each command element 
+    @(foreach ($element in $commandElements) {
+        # If the element is an array literal, expand it
+        if ($element -is [Management.Automation.Language.ArrayLiteralAst]) {
+            $element.Elements
+        } else {
+            # otherwise, include it as is.
+            $element
+        }
+    })
+
+# Now we have all of the words in a sentence.
+# We can still determine if an item in a list was in a list by inspecting it's parent.
+
 $sentences = @()
 if ($SpecificCommands) {    
     $potentialCommands = $SpecificCommands
@@ -399,32 +438,6 @@ $potentialCommandIndex = -1
 foreach ($potentialCommand in $potentialCommands) {
     $potentialCommandIndex++
     $commandName = $potentialCommandName = $potentialCommandNames[$potentialCommandIndex]
-    <#
-    Each potential command can be thought of as a simple sentence with (mostly) natural syntax
-    
-    command <parametername> ...<parameterargument> (etc)     
-        
-    either more natural or PowerShell syntax should be allowed, for example:
-
-    all functions can Quack {
-        "quack"
-    }
-
-    would map to the command all and the parameters -Function and -Can (with the arguments Quack and {"quack"})
-
-    Assuming -Functions was a `[switch]` or an alias to a `[switch]`, it will match that `[switch]` and only that switch.
-
-    If -Functions was not a `[switch]`, it will match values from that point.
-
-    If the parameter type is not a list or PSObject, only the next parameter will be matched.
-
-    If the parameter type *is* a list or an PSObject, 
-    or ValueFromRemainingArguments is present and no named parameters were found,
-    then all remaining arguments will be matched until the next named parameter is found.
-    
-    _Aliasing is important_ when working with a given parameter.  The alias, _not_ the parameter name, will be what is mapped.
-
-    #>
 
     # Cache the potential parameters
     $potentialParameters = $potentialCommand.Parameters