PowerShell · rjmholt · Feb 15, 2017 · Feb 15, 2017 · Feb 15, 2017 · Feb 15, 2017
diff --git a/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs b/src/System.Management.Automation/engine/CommandCompletion/CompletionAnalysis.cs
@@ -648,6 +648,10 @@ internal List<CompletionResult> GetResultHelper(CompletionContext completionCont
                                 bool matched;
                                 result = GetResultForIdentifierInConfiguration(completionContext, configAst, keywordAst, out matched);
                             }
+                            else if (keywordAst != null)
+                            {
+                                result = GetInnerDynamicKeywordResult(completionContext, keywordAst);
+                            }
                         }
                     }
                     else if (completionContext.TokenAtCursor == null)
@@ -689,8 +693,13 @@ internal List<CompletionResult> GetResultHelper(CompletionContext completionCont
                                         result = GetResultForEnumPropertyValueOfDSCResource(completionContext, string.Empty,
                                             ref replacementIndex, ref replacementLength, out unused);
                                     }
-                                    break;
+                                    break;
                                 default:
+                                    DynamicKeywordStatementAst keywordAst = Ast.GetAncestorAst<DynamicKeywordStatementAst>(lastAst);
+                                    if (keywordAst != null)
+                                    {
+                                        result = GetDynamicKeywordParameterResult(completionContext, keywordAst);
+                                    }
                                     break;
                             }
                         }
@@ -989,6 +998,7 @@ private List<CompletionResult> GetResultForEnumPropertyValueOfDSCResource(
                             DynamicKeywordProperty property;
                             if (keywordAst.Keyword.Properties.TryGetValue(propertyNameAst.Value, out property))
                             {
+                                result = new List<CompletionResult>();
                                 List<String> existingValues = null;
                                 WildcardPattern wildcardPattern = null;
                                 bool isDependsOnProperty = String.Equals(property.Name, @"DependsOn", StringComparison.OrdinalIgnoreCase);
@@ -1037,7 +1047,6 @@ private List<CompletionResult> GetResultForEnumPropertyValueOfDSCResource(
                                     completionContext.ReplacementIndex = replacementIndex;
                                     string matchString = stringToComplete + "*";
                                     wildcardPattern = WildcardPattern.Get(matchString, WildcardOptions.IgnoreCase | WildcardOptions.CultureInvariant);
-                                    result = new List<CompletionResult>();
                                 }
 
                                 Diagnostics.Assert(isCursorInString || (!hasNewLine), "hasNoQuote and hasNewLine cannot be true at the same time");
@@ -1114,6 +1123,13 @@ private List<CompletionResult> GetResultForEnumPropertyValueOfDSCResource(
                                         }
                                     }
                                 }
+                                else
+                                {
+                                    foreach (var propertyValue in property.Values)
+                                    {
+                                        result.Add(new CompletionResult(propertyValue, propertyValue, CompletionResultType.Text, propertyValue));
+                                    }
+                                }
                             }
                         }
                     }
@@ -1341,6 +1357,69 @@ private List<CompletionResult> GetResultForIdentifierInConfiguration(
             return results;
         }
 
+        internal static List<CompletionResult> GetInnerDynamicKeywordResult(CompletionContext context, DynamicKeywordStatementAst parentKeywordAst)
+        {
+            var results = new List<CompletionResult>();
+
+            if (String.IsNullOrEmpty(context.WordToComplete))
+            {
+                foreach (var keyword in parentKeywordAst.Keyword.InnerKeywords.Values)
+                {
+                    results.Add(new CompletionResult(keyword.Keyword, keyword.Keyword, CompletionResultType.Keyword, keyword.Keyword));
+                }
+            }
+            else
+            {
+                foreach (var keyword in parentKeywordAst.Keyword.InnerKeywords.Values)
+                {
+                    if (keyword.Keyword.StartsWith(context.WordToComplete))
+                    {
+                        results.Add(new CompletionResult(keyword.Keyword, keyword.Keyword, CompletionResultType.Keyword, keyword.Keyword));
+                    }
+                }
+            }
+
+            return results;
+        }
+
+        internal static List<CompletionResult> GetDynamicKeywordParameterResult(CompletionContext context, DynamicKeywordStatementAst keywordAst)
+        {
+            var results = new List<CompletionResult>();
+
+            string toComplete;
+            if (context?.WordToComplete?.StartsWith("-") ?? false)
+            {
+                toComplete = context.WordToComplete.Substring(1);
+            }
+            else
+            {
+                toComplete = "";
+            }
+            foreach (var param in keywordAst.Keyword.Parameters.Values)
+            {
+                if (!param.Name.StartsWith(toComplete))
+                {
+                    continue;
+                }
+
+                string typeConstraint = param.TypeConstraint;
+                Type paramType = Type.GetType(param.TypeConstraint);
+                if (paramType != null)
+                {
+                    string acceleratedType = TypeAccelerators.FindBuiltinAccelerator(paramType);
+                    if (!String.IsNullOrEmpty(acceleratedType))
+                    {
+                        typeConstraint = acceleratedType;
+                    }
+                }
+
+                string tooltip = "[" + typeConstraint + "]" + param.Name;
+                results.Add(new CompletionResult("-" + param.Name, param.Name, CompletionResultType.ParameterName, tooltip));
+            }
+
+            return results;
+        }
+
         private List<CompletionResult> GetResultForIdentifier(CompletionContext completionContext, ref int replacementIndex, ref int replacementLength, bool isQuotedString)
         {
             var tokenAtCursor = completionContext.TokenAtCursor;
@@ -1510,6 +1589,12 @@ private List<CompletionResult> GetResultForIdentifier(CompletionContext completi
                     // Current token is within ConfigurationDefinitionAst or DynamicKeywordStatementAst
                     keywordResult = GetResultForIdentifierInConfiguration(completionContext, configureAst, keywordAst, out matched);
                 }
+                else if (keywordAst != null)
+                {
+                    // Lie so keywords appear when commands are also possible
+                    matched = true;
+                    keywordResult = GetInnerDynamicKeywordResult(completionContext, keywordAst);
+                }
 
                 // Handle the file completion before command name completion
                 result = CompleteFileNameAsCommand(completionContext);
@@ -1521,14 +1606,18 @@ private List<CompletionResult> GetResultForIdentifier(CompletionContext completi
                     result.AddRange(commandNameResult);
                 }
 
-                if (matched && keywordResult != null)
-                {
-                    result.InsertRange(0, keywordResult);
-                }
-                else if (!matched && keywordResult != null && commandNameResult.Count == 0)
-                {
-                    result.AddRange(keywordResult);
+                if (keywordResult != null)
+                {
+                    if (matched)
+                    {
+                        result.InsertRange(0, keywordResult);
+                    }
+                    else if (commandNameResult.Count == 0)
+                    {
+                        result.AddRange(keywordResult);
+                    }
                 }
+
                 return result;
             }
 

diff --git a/src/System.Management.Automation/engine/CommandCompletion/CompletionCompleters.cs b/src/System.Management.Automation/engine/CommandCompletion/CompletionCompleters.cs
@@ -518,28 +518,35 @@ internal static List<CompletionResult> CompleteCommandParameter(CompletionContex
                 keywordAst = parameterAst.Parent as DynamicKeywordStatementAst;
             }
 
-            // If parent is DynamicKeywordStatementAst - 'Import-DscResource',
-            // then customize the auto completion results
-            if (keywordAst != null && String.Equals(keywordAst.Keyword.Keyword, "Import-DscResource", StringComparison.OrdinalIgnoreCase)
-                && !String.IsNullOrWhiteSpace(context.WordToComplete) && context.WordToComplete.StartsWith("-", StringComparison.OrdinalIgnoreCase))
-            {
-                var lastAst = context.RelatedAsts.Last();
-                var wordToMatch = context.WordToComplete.Substring(1) + "*";
-                var pattern = WildcardPattern.Get(wordToMatch, WildcardOptions.IgnoreCase);
-                var parameterNames = keywordAst.CommandElements.Where(ast => ast is CommandParameterAst).Select(ast => (ast as CommandParameterAst).ParameterName);
-                foreach (var parameterName in s_parameterNamesOfImportDSCResource)
-                {
-                    if (pattern.IsMatch(parameterName) && !parameterNames.Contains(parameterName, StringComparer.OrdinalIgnoreCase))
-                    {
-                        string tooltip = "[String] " + parameterName;
-                        result.Add(new CompletionResult("-" + parameterName, parameterName, CompletionResultType.ParameterName, tooltip));
-                    }
-                }
-                if (result.Count > 0)
-                {
-                    context.ReplacementLength = context.WordToComplete.Length;
-                    context.ReplacementIndex = lastAst.Extent.StartOffset;
-                }
+            if (keywordAst != null && !String.IsNullOrWhiteSpace(context.WordToComplete) && context.WordToComplete.StartsWith("-", StringComparison.OrdinalIgnoreCase))
+            {
+                // If parent is DynamicKeywordStatementAst - 'Import-DscResource',
+                // then customize the auto completion results
+                if (String.Equals(keywordAst.Keyword.Keyword, "Import-DscResource", StringComparison.OrdinalIgnoreCase))
+                {
+                    var lastAst = context.RelatedAsts.Last();
+                    var wordToMatch = context.WordToComplete.Substring(1) + "*";
+                    var pattern = WildcardPattern.Get(wordToMatch, WildcardOptions.IgnoreCase);
+                    var parameterNames = keywordAst.CommandElements.Where(ast => ast is CommandParameterAst).Select(ast => (ast as CommandParameterAst).ParameterName);
+                    foreach (var parameterName in s_parameterNamesOfImportDSCResource)
+                    {
+                        if (pattern.IsMatch(parameterName) && !parameterNames.Contains(parameterName, StringComparer.OrdinalIgnoreCase))
+                        {
+                            string tooltip = "[String] " + parameterName;
+                            result.Add(new CompletionResult("-" + parameterName, parameterName, CompletionResultType.ParameterName, tooltip));
+                        }
+                    }
+                    if (result.Count > 0)
+                    {
+                        context.ReplacementLength = context.WordToComplete.Length;
+                        context.ReplacementIndex = lastAst.Extent.StartOffset;
+                    }
+                }
+                else
+                {
+                    result.AddRange(CompletionAnalysis.GetDynamicKeywordParameterResult(context, keywordAst));
+                }
+
                 return result;
             }
 
@@ -1002,6 +1009,15 @@ internal static List<CompletionResult> CompleteCommandArgument(CompletionContext
                 if (paramAst != null)
                 {
                     commandAst = paramAst.Parent as CommandAst;
+
+                    if (commandAst == null)
+                    {
+                        DynamicKeywordStatementAst keywordAst = paramAst.Parent as DynamicKeywordStatementAst;
+                        if (keywordAst != null)
+                        {
+                            result = GetKeywordParameterValueResult(context, paramAst, keywordAst);
+                        }
+                    }
                 }
                 else
                 {
@@ -1379,6 +1395,23 @@ internal static string ConcatenateStringPathArguments(CommandElementAst stringAs
             return null;
         }
 
+        private static List<CompletionResult> GetKeywordParameterValueResult(CompletionContext context, CommandParameterAst paramAst, DynamicKeywordStatementAst keywordAst)
+        {
+            var results = new List<CompletionResult>();
+            DynamicKeywordParameter param;
+            if (!keywordAst.Keyword.Parameters.TryGetValue(paramAst.ParameterName, out param))
+            {
+                return results;
+            }
+
+            foreach (var paramVal in param.Values)
+            {
+                results.Add(new CompletionResult(paramVal, paramVal, CompletionResultType.ParameterValue, paramVal));
+            }
+
+            return results;
+        }
+
         /// <summary>
         /// Get the argument completion results when the pseudo binding was not successful
         /// </summary>