CompletionCompleters.cs

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using System.Collections;
using System.Collections.Concurrent;
using System.Collections.ObjectModel;
using System.Data;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Management.Automation.Internal;
using System.Management.Automation.Language;
using System.Collections.Generic;
using System.Management.Automation.Runspaces;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using Microsoft.Management.Infrastructure;
using Microsoft.Management.Infrastructure.Options;
using Microsoft.PowerShell;
using Microsoft.PowerShell.Cim;
using Microsoft.PowerShell.Commands;

namespace System.Management.Automation
{
    /// <summary>
    /// </summary>
    public static class CompletionCompleters
    {
        static CompletionCompleters()
        {
            AppDomain.CurrentDomain.AssemblyLoad += UpdateTypeCacheOnAssemblyLoad;
        }

        private static void UpdateTypeCacheOnAssemblyLoad(object sender, AssemblyLoadEventArgs args)
        {
            // Just null out the cache - we'll rebuild it the next time someone tries to complete a type.
            // We could rebuild it now, but we could be loading multiple assemblies (e.g. dependent assemblies)
            // and there is no sense in rebuilding anything until we're done loading all of the assemblies.
            Interlocked.Exchange(ref s_typeCache, null);
        }

        #region Command Names

        /// <summary>
        /// </summary>
        /// <param name="commandName"></param>
        /// <returns></returns>
        public static IEnumerable<CompletionResult> CompleteCommand(string commandName)
        {
            return CompleteCommand(commandName, null);
        }

        /// <summary>
        /// </summary>
        /// <param name="commandName"></param>
        /// <param name="moduleName"></param>
        /// <param name="commandTypes"></param>
        /// <returns></returns>
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")]
        public static IEnumerable<CompletionResult> CompleteCommand(string commandName, string moduleName, CommandTypes commandTypes = CommandTypes.All)
        {
            var runspace = Runspace.DefaultRunspace;
            if (runspace == null)
            {
                // No runspace, just return no results.
                return CommandCompletion.EmptyCompletionResult;
            }

            var helper = new PowerShellExecutionHelper(PowerShell.Create(RunspaceMode.CurrentRunspace));
            var executionContext = helper.CurrentPowerShell.Runspace.ExecutionContext;
            return CompleteCommand(new CompletionContext { WordToComplete = commandName, Helper = helper, ExecutionContext = executionContext }, moduleName, commandTypes);
        }

        internal static List<CompletionResult> CompleteCommand(CompletionContext context)
        {
            return CompleteCommand(context, null);
        }

        private static List<CompletionResult> CompleteCommand(CompletionContext context, string moduleName, CommandTypes types = CommandTypes.All)
        {
            var addAmpersandIfNecessary = IsAmpersandNeeded(context, false);

            string commandName = context.WordToComplete;
            string quote = HandleDoubleAndSingleQuote(ref commandName);

            commandName += "*";
            List<CompletionResult> commandResults = null;

            if (commandName.IndexOfAny(Utils.Separators.DirectoryOrDrive) == -1)
            {
                // The name to complete is neither module qualified nor is it a relative/rooted file path.

                Ast lastAst = null;
                if (context.RelatedAsts != null && context.RelatedAsts.Count > 0)
                {
                    lastAst = context.RelatedAsts.Last();
                }

                var powershell = context.Helper
                    .AddCommandWithPreferenceSetting("Get-Command", typeof(GetCommandCommand))
                    .AddParameter("All")
                    .AddParameter("Name", commandName);

                if (moduleName != null)
                    powershell.AddParameter("Module", moduleName);
                if (!types.Equals(CommandTypes.All))
                    powershell.AddParameter("CommandType", types);

                Exception exceptionThrown;
                var commandInfos = context.Helper.ExecuteCurrentPowerShell(out exceptionThrown);

                if (commandInfos != null && commandInfos.Count > 1)
                {
                    // OrderBy is using stable sorting
                    var sortedCommandInfos = commandInfos.OrderBy(a => a, new CommandNameComparer());
                    commandResults = MakeCommandsUnique(sortedCommandInfos, /* includeModulePrefix: */ false, addAmpersandIfNecessary, quote);
                }
                else
                {
                    commandResults = MakeCommandsUnique(commandInfos, /* includeModulePrefix: */ false, addAmpersandIfNecessary, quote);
                }

                if (lastAst != null)
                {
                    // Search the asts for function definitions that we might be calling
                    var findFunctionsVisitor = new FindFunctionsVisitor();
                    while (lastAst.Parent != null)
                    {
                        lastAst = lastAst.Parent;
                    }
                    lastAst.Visit(findFunctionsVisitor);

                    WildcardPattern commandNamePattern = WildcardPattern.Get(commandName, WildcardOptions.IgnoreCase);
                    foreach (var defn in findFunctionsVisitor.FunctionDefinitions)
                    {
                        if (commandNamePattern.IsMatch(defn.Name)
                            && !commandResults.Where(cr => cr.CompletionText.Equals(defn.Name, StringComparison.OrdinalIgnoreCase)).Any())
                        {
                            // Results found in the current script are prepended to show up at the top of the list.
                            commandResults.Insert(0, GetCommandNameCompletionResult(defn.Name, defn, addAmpersandIfNecessary, quote));
                        }
                    }
                }
            }
            else
            {
                // If there is a single \, we might be looking for a module/snapin qualified command
                var indexOfFirstColon = commandName.IndexOf(':');
                var indexOfFirstBackslash = commandName.IndexOf('\\');
                if (indexOfFirstBackslash > 0 && (indexOfFirstBackslash < indexOfFirstColon || indexOfFirstColon == -1))
                {
                    // First try the name before the backslash as a module name.
                    // Use the exact module name provided by the user
                    moduleName = commandName.Substring(0, indexOfFirstBackslash);
                    commandName = commandName.Substring(indexOfFirstBackslash + 1);

                    var powershell = context.Helper
                        .AddCommandWithPreferenceSetting("Get-Command", typeof(GetCommandCommand))
                        .AddParameter("All")
                        .AddParameter("Name", commandName)
                        .AddParameter("Module", moduleName);

                    if (!types.Equals(CommandTypes.All))
                        powershell.AddParameter("CommandType", types);

                    Exception exceptionThrown;
                    var commandInfos = context.Helper.ExecuteCurrentPowerShell(out exceptionThrown);

                    if (commandInfos != null && commandInfos.Count > 1)
                    {
                        var sortedCommandInfos = commandInfos.OrderBy(a => a, new CommandNameComparer());
                        commandResults = MakeCommandsUnique(sortedCommandInfos, /* includeModulePrefix: */ true, addAmpersandIfNecessary, quote);
                    }
                    else
                    {
                        commandResults = MakeCommandsUnique(commandInfos, /* includeModulePrefix: */ true, addAmpersandIfNecessary, quote);
                    }
                }
            }

            return commandResults;
        }

        private static readonly HashSet<string> s_keywordsToExcludeFromAddingAmpersand
            = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { TokenKind.InlineScript.ToString(), TokenKind.Configuration.ToString() };
        internal static CompletionResult GetCommandNameCompletionResult(string name, object command, bool addAmpersandIfNecessary, string quote)
        {
            string syntax = name, listItem = name;

            var commandInfo = command as CommandInfo;
            if (commandInfo != null)
            {
                try
                {
                    listItem = commandInfo.Name;
                    // This may require parsing a script, which could fail in a number of different ways
                    // (syntax errors, security exceptions, etc.)  If so, the name is fine for the tooltip.
                    syntax = commandInfo.Syntax;
                }
                catch (Exception)
                {
                }
            }

            syntax = string.IsNullOrEmpty(syntax) ? name : syntax;
            bool needAmpersand;

            if (CompletionRequiresQuotes(name, false))
            {
                needAmpersand = quote == string.Empty && addAmpersandIfNecessary;
                string quoteInUse = quote == string.Empty ? "'" : quote;
                if (quoteInUse == "'")
                {
                    name = name.Replace("'", "''");
                }
                else
                {
                    name = name.Replace("`", "``");
                    name = name.Replace("$", "`$");
                }
                name = quoteInUse + name + quoteInUse;
            }
            else
            {
                needAmpersand = quote == string.Empty && addAmpersandIfNecessary &&
                                Tokenizer.IsKeyword(name) && !s_keywordsToExcludeFromAddingAmpersand.Contains(name);
                name = quote + name + quote;
            }

            // It's useless to call ForEach-Object (foreach) as the first command of a pipeline. For example:
            //     PS C:\> fore<tab>  --->   PS C:\> foreach   (expected, use as the keyword)
            //     PS C:\> fore<tab>  --->   PS C:\> & foreach (unexpected, ForEach-Object is seldom used as the first command of a pipeline)
            if (needAmpersand && name != SpecialVariables.@foreach)
            {
                name = "& " + name;
            }
            return new CompletionResult(name, listItem, CompletionResultType.Command, syntax);
        }

        internal static List<CompletionResult> MakeCommandsUnique(IEnumerable<PSObject> commandInfoPsObjs, bool includeModulePrefix, bool addAmpersandIfNecessary, string quote)
        {
            List<CompletionResult> results = new List<CompletionResult>();
            if (commandInfoPsObjs == null || !commandInfoPsObjs.Any())
            {
                return results;
            }

            var commandTable = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            foreach (var psobj in commandInfoPsObjs)
            {
                object baseObj = PSObject.Base(psobj);
                string name = null;

                var commandInfo = baseObj as CommandInfo;
                if (commandInfo != null)
                {
                    // Skip the private commands
                    if (commandInfo.Visibility == SessionStateEntryVisibility.Private) { continue; }
                    name = commandInfo.Name;
                    if (includeModulePrefix && !string.IsNullOrEmpty(commandInfo.ModuleName))
                    {
                        // The command might be a prefixed commandInfo that we get by importing a module with the -Prefix parameter, for example:
                        //    FooModule.psm1: Get-Foo
                        //    import-module FooModule -Prefix PowerShell
                        //    --> command 'Get-PowerShellFoo' in the global session state (prefixed commandInfo)
                        //        command 'Get-Foo' in the module session state (un-prefixed commandInfo)
                        // in that case, we should not add the module name qualification because it doesn't work
                        if (String.IsNullOrEmpty(commandInfo.Prefix) || !ModuleCmdletBase.IsPrefixedCommand(commandInfo))
                        {
                            name = commandInfo.ModuleName + "\\" + commandInfo.Name;
                        }
                    }
                }
                else
                {
                    name = baseObj as string;
                    if (name == null) { continue; }
                }

                object value;
                if (!commandTable.TryGetValue(name, out value))
                {
                    commandTable.Add(name, baseObj);
                }
                else
                {
                    var list = value as List<object>;
                    if (list != null)
                    {
                        list.Add(baseObj);
                    }
                    else
                    {
                        list = new List<object> { value, baseObj };
                        commandTable[name] = list;
                    }
                }
            }

            List<CompletionResult> endResults = null;
            foreach (var keyValuePair in commandTable)
            {
                var commandList = keyValuePair.Value as List<object>;
                if (commandList != null)
                {
                    if (endResults == null)
                    {
                        endResults = new List<CompletionResult>();
                    }

                    // The first command might be an un-prefixed commandInfo that we get by importing a module with the -Prefix parameter,
                    // in that case, we should add the module name qualification because if the module is not in the module path, calling
                    // 'Get-Foo' directly doesn't work
                    string completionName = keyValuePair.Key;
                    if (!includeModulePrefix)
                    {
                        var commandInfo = commandList[0] as CommandInfo;
                        if (commandInfo != null && !String.IsNullOrEmpty(commandInfo.Prefix))
                        {
                            Diagnostics.Assert(!String.IsNullOrEmpty(commandInfo.ModuleName), "the module name should exist if commandInfo.Prefix is not an empty string");
                            if (!ModuleCmdletBase.IsPrefixedCommand(commandInfo))
                            {
                                completionName = commandInfo.ModuleName + "\\" + completionName;
                            }
                        }
                    }
                    results.Add(GetCommandNameCompletionResult(completionName, commandList[0], addAmpersandIfNecessary, quote));

                    // For the other commands that are hidden, we need to disambiguate,
                    // but put these at the end as it's less likely any of the hidden
                    // commands are desired.  If we can't add anything to disambiguate,
                    // then we'll skip adding a completion result.
                    for (int index = 1; index < commandList.Count; index++)
                    {
                        var commandInfo = commandList[index] as CommandInfo;
                        Diagnostics.Assert(commandInfo != null, "Elements should always be CommandInfo");

                        if (commandInfo.CommandType == CommandTypes.Application)
                        {
                            endResults.Add(GetCommandNameCompletionResult(commandInfo.Definition, commandInfo, addAmpersandIfNecessary, quote));
                        }
                        else if (!string.IsNullOrEmpty(commandInfo.ModuleName))
                        {
                            var name = commandInfo.ModuleName + "\\" + commandInfo.Name;
                            endResults.Add(GetCommandNameCompletionResult(name, commandInfo, addAmpersandIfNecessary, quote));
                        }
                    }
                }
                else
                {
                    // The first command might be an un-prefixed commandInfo that we get by importing a module with the -Prefix parameter,
                    // in that case, we should add the module name qualification because if the module is not in the module path, calling
                    // 'Get-Foo' directly doesn't work
                    string completionName = keyValuePair.Key;
                    if (!includeModulePrefix)
                    {
                        var commandInfo = keyValuePair.Value as CommandInfo;
                        if (commandInfo != null && !String.IsNullOrEmpty(commandInfo.Prefix))
                        {
                            Diagnostics.Assert(!String.IsNullOrEmpty(commandInfo.ModuleName), "the module name should exist if commandInfo.Prefix is not an empty string");
                            if (!ModuleCmdletBase.IsPrefixedCommand(commandInfo))
                            {
                                completionName = commandInfo.ModuleName + "\\" + completionName;
                            }
                        }
                    }
                    results.Add(GetCommandNameCompletionResult(completionName, keyValuePair.Value, addAmpersandIfNecessary, quote));
                }
            }

            if (endResults != null && endResults.Count > 0)
            {
                results.AddRange(endResults);
            }

            return results;
        }

        private class FindFunctionsVisitor : AstVisitor
        {
            internal readonly List<FunctionDefinitionAst> FunctionDefinitions = new List<FunctionDefinitionAst>();

            public override AstVisitAction VisitFunctionDefinition(FunctionDefinitionAst functionDefinitionAst)
            {
                FunctionDefinitions.Add(functionDefinitionAst);
                return AstVisitAction.Continue;
            }
        }

        #endregion Command Names

        #region Module Names

        internal static List<CompletionResult> CompleteModuleName(CompletionContext context, bool loadedModulesOnly, bool skipEditionCheck = false)
        {
            var moduleName = context.WordToComplete ?? string.Empty;
            var result = new List<CompletionResult>();
            var quote = HandleDoubleAndSingleQuote(ref moduleName);

            if (!moduleName.EndsWith("*", StringComparison.Ordinal))
            {
                moduleName += "*";
            }

            var powershell = context.Helper.AddCommandWithPreferenceSetting("Get-Module", typeof(GetModuleCommand)).AddParameter("Name", moduleName);
            if (!loadedModulesOnly)
            {
                powershell.AddParameter("ListAvailable", true);

                // -SkipEditionCheck should only be set or apply to -ListAvailable
                if (skipEditionCheck)
                {
                    powershell.AddParameter("SkipEditionCheck", true);
                }
            }

            Exception exceptionThrown;
            var psObjects = context.Helper.ExecuteCurrentPowerShell(out exceptionThrown);

            if (psObjects != null)
            {
                foreach (dynamic moduleInfo in psObjects)
                {
                    var completionText = moduleInfo.Name.ToString();
                    var listItemText = completionText;
                    var toolTip = "Description: " + moduleInfo.Description.ToString() + "\r\nModuleType: "
                                  + moduleInfo.ModuleType.ToString() + "\r\nPath: "
                                  + moduleInfo.Path.ToString();

                    if (CompletionRequiresQuotes(completionText, false))
                    {
                        var quoteInUse = quote == string.Empty ? "'" : quote;
                        if (quoteInUse == "'")
                            completionText = completionText.Replace("'", "''");
                        completionText = quoteInUse + completionText + quoteInUse;
                    }
                    else
                    {
                        completionText = quote + completionText + quote;
                    }

                    result.Add(new CompletionResult(completionText, listItemText, CompletionResultType.ParameterValue, toolTip));
                }
            }

            return result;
        }

        #endregion Module Names

        #region Command Parameters
        private static string[] s_parameterNamesOfImportDSCResource = { "Name", "ModuleName", "ModuleVersion" };

        internal static List<CompletionResult> CompleteCommandParameter(CompletionContext context)
        {
            string partialName = null;
            bool withColon = false;
            CommandAst commandAst = null;
            List<CompletionResult> result = new List<CompletionResult>();

            // Find the parameter ast, it will be near or at the end
            CommandParameterAst parameterAst = null;
            DynamicKeywordStatementAst keywordAst = null;
            for (int i = context.RelatedAsts.Count - 1; i >= 0; i--)
            {
                if (keywordAst == null)
                    keywordAst = context.RelatedAsts[i] as DynamicKeywordStatementAst;
                parameterAst = (context.RelatedAsts[i] as CommandParameterAst);
                if (parameterAst != null) break;
            }

            if (parameterAst != null)
            {
                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;
                }
                return result;
            }

            if (parameterAst != null)
            {
                // Parent must be a command
                commandAst = (CommandAst)parameterAst.Parent;
                partialName = parameterAst.ParameterName;
                withColon = context.WordToComplete.EndsWith(":", StringComparison.Ordinal);
            }
            else
            {
                // No CommandParameterAst is found. It could be a StringConstantExpressionAst "-"
                var dashAst = (context.RelatedAsts[context.RelatedAsts.Count - 1] as StringConstantExpressionAst);
                if (dashAst == null)
                    return result;
                if (!dashAst.Value.Trim().Equals("-", StringComparison.OrdinalIgnoreCase))
                    return result;

                // Parent must be a command
                commandAst = (CommandAst)dashAst.Parent;
                partialName = string.Empty;
            }

            PseudoBindingInfo pseudoBinding = new PseudoParameterBinder()
                                                .DoPseudoParameterBinding(commandAst, null, parameterAst, PseudoParameterBinder.BindingType.ParameterCompletion);
            // The command cannot be found or it's not a cmdlet, not a script cmdlet, not a function.
            // Try completing as if it the parameter is a command argument for native command completion.
            if (pseudoBinding == null)
            {
                return CompleteCommandArgument(context);
            }

            switch (pseudoBinding.InfoType)
            {
                case PseudoBindingInfoType.PseudoBindingFail:
                    // The command is a cmdlet or script cmdlet. Binding failed
                    result = GetParameterCompletionResults(partialName, uint.MaxValue, pseudoBinding.UnboundParameters, withColon);
                    break;
                case PseudoBindingInfoType.PseudoBindingSucceed:
                    // The command is a cmdlet or script cmdlet. Binding succeeded.
                    result = GetParameterCompletionResults(partialName, pseudoBinding, parameterAst, withColon);
                    break;
            }

            if (result.Count == 0)
            {
                result = pseudoBinding.CommandName.Equals("Set-Location", StringComparison.OrdinalIgnoreCase)
                             ? new List<CompletionResult>(CompleteFilename(context, containerOnly: true, extension: null))
                             : new List<CompletionResult>(CompleteFilename(context));
            }

            return result;
        }

        /// <summary>
        /// Get the parameter completion results when the pseudo binding was successful
        /// </summary>
        /// <param name="parameterName"></param>
        /// <param name="bindingInfo"></param>
        /// <param name="parameterAst"></param>
        /// <param name="withColon"></param>
        /// <returns></returns>
        private static List<CompletionResult> GetParameterCompletionResults(string parameterName, PseudoBindingInfo bindingInfo, CommandParameterAst parameterAst, bool withColon)
        {
            Diagnostics.Assert(bindingInfo.InfoType.Equals(PseudoBindingInfoType.PseudoBindingSucceed), "The pseudo binding should succeed");
            List<CompletionResult> result = new List<CompletionResult>();

            if (parameterName == string.Empty)
            {
                result = GetParameterCompletionResults(
                    parameterName,
                    bindingInfo.ValidParameterSetsFlags,
                    bindingInfo.UnboundParameters,
                    withColon);
                return result;
            }

            if (bindingInfo.ParametersNotFound.Count > 0)
            {
                // The parameter name cannot be matched to any parameter
                if (bindingInfo.ParametersNotFound.Any(pAst => parameterAst.GetHashCode() == pAst.GetHashCode()))
                {
                    return result;
                }
            }

            if (bindingInfo.AmbiguousParameters.Count > 0)
            {
                // The parameter name is ambiguous. It's ignored in the pseudo binding, and we should search in the UnboundParameters
                if (bindingInfo.AmbiguousParameters.Any(pAst => parameterAst.GetHashCode() == pAst.GetHashCode()))
                {
                    result = GetParameterCompletionResults(
                        parameterName,
                        bindingInfo.ValidParameterSetsFlags,
                        bindingInfo.UnboundParameters,
                        withColon);
                }
                return result;
            }

            if (bindingInfo.DuplicateParameters.Count > 0)
            {
                // The parameter name is resolved to a parameter that is already bound. We search it in the BoundParameters
                if (bindingInfo.DuplicateParameters.Any(pAst => parameterAst.GetHashCode() == pAst.Parameter.GetHashCode()))
                {
                    result = GetParameterCompletionResults(
                        parameterName,
                        bindingInfo.ValidParameterSetsFlags,
                        bindingInfo.BoundParameters.Values,
                        withColon);
                }
                return result;
            }

            // The parameter should be bound in the pseudo binding during the named binding
            string matchedParameterName = null;
            foreach (KeyValuePair<string, AstParameterArgumentPair> entry in bindingInfo.BoundArguments)
            {
                switch (entry.Value.ParameterArgumentType)
                {
                    case AstParameterArgumentType.AstPair:
                        {
                            AstPair pair = (AstPair)entry.Value;
                            if (pair.ParameterSpecified && pair.Parameter.GetHashCode() == parameterAst.GetHashCode())
                            {
                                matchedParameterName = entry.Key;
                            }
                            else if (pair.ArgumentIsCommandParameterAst && pair.Argument.GetHashCode() == parameterAst.GetHashCode())
                            {
                                // The parameter name cannot be resolved to a parameter
                                return result;
                            }
                        }
                        break;
                    case AstParameterArgumentType.Fake:
                        {
                            FakePair pair = (FakePair)entry.Value;
                            if (pair.ParameterSpecified && pair.Parameter.GetHashCode() == parameterAst.GetHashCode())
                            {
                                matchedParameterName = entry.Key;
                            }
                        }
                        break;
                    case AstParameterArgumentType.Switch:
                        {
                            SwitchPair pair = (SwitchPair)entry.Value;
                            if (pair.ParameterSpecified && pair.Parameter.GetHashCode() == parameterAst.GetHashCode())
                            {
                                matchedParameterName = entry.Key;
                            }
                        }
                        break;
                    case AstParameterArgumentType.AstArray:
                    case AstParameterArgumentType.PipeObject:
                        break;
                }

                if (matchedParameterName != null)
                    break;
            }

            Diagnostics.Assert(matchedParameterName != null, "we should find matchedParameterName from the BoundArguments");
            MergedCompiledCommandParameter param = bindingInfo.BoundParameters[matchedParameterName];

            WildcardPattern pattern = WildcardPattern.Get(parameterName + "*", WildcardOptions.IgnoreCase);
            string parameterType = "[" + ToStringCodeMethods.Type(param.Parameter.Type, dropNamespaces: true) + "] ";
            string colonSuffix = withColon ? ":" : string.Empty;
            if (pattern.IsMatch(matchedParameterName))
            {
                string completionText = "-" + matchedParameterName + colonSuffix;
                string tooltip = parameterType + matchedParameterName;
                result.Add(new CompletionResult(completionText, matchedParameterName, CompletionResultType.ParameterName, tooltip));
            }

            // Process alias when there is partial input
            result.AddRange(from alias in param.Parameter.Aliases
                            where pattern.IsMatch(alias)
                            select
                                new CompletionResult("-" + alias + colonSuffix, alias, CompletionResultType.ParameterName,
                                                     parameterType + alias));

            return result;
        }

        /// <summary>
        /// Get the parameter completion results by using the given valid parameter sets and available parameters
        /// </summary>
        /// <param name="parameterName"></param>
        /// <param name="validParameterSetFlags"></param>
        /// <param name="parameters"></param>
        /// <param name="withColon"></param>
        /// <returns></returns>
        private static List<CompletionResult> GetParameterCompletionResults(
            string parameterName,
            uint validParameterSetFlags,
            IEnumerable<MergedCompiledCommandParameter> parameters,
            bool withColon)
        {
            var result = new List<CompletionResult>();
            var commonParamResult = new List<CompletionResult>();
            var pattern = WildcardPattern.Get(parameterName + "*", WildcardOptions.IgnoreCase);
            var colonSuffix = withColon ? ":" : string.Empty;

            bool addCommonParameters = true;
            foreach (MergedCompiledCommandParameter param in parameters)
            {
                bool inParameterSet = (param.Parameter.ParameterSetFlags & validParameterSetFlags) != 0 || param.Parameter.IsInAllSets;
                if (!inParameterSet)
                    continue;

                string name = param.Parameter.Name;
                string type = "[" + ToStringCodeMethods.Type(param.Parameter.Type, dropNamespaces: true) + "] ";
                bool isCommonParameter = Cmdlet.CommonParameters.Contains(name, StringComparer.OrdinalIgnoreCase);
                List<CompletionResult> listInUse = isCommonParameter ? commonParamResult : result;

                if (pattern.IsMatch(name))
                {
                    // Then using functions to back dynamic keywords, we don't necessarily
                    // want all of the parameters to be shown to the user. Those that are marked
                    // DontShow will not be displayed. Also, if any of the parameters have
                    // don't show set, we won't show any of the common parameters either.
                    bool showToUser = true;
                    var compiledAttributes = param.Parameter.CompiledAttributes;
                    if (compiledAttributes != null && compiledAttributes.Count > 0)
                    {
                        foreach (var attr in compiledAttributes)
                        {
                            var pattr = attr as ParameterAttribute;
                            if (pattr != null && pattr.DontShow)
                            {
                                showToUser = false;
                                addCommonParameters = false;
                                break;
                            }
                        }
                    }
                    if (showToUser)
                    {
                        string completionText = "-" + name + colonSuffix;
                        string tooltip = type + name;
                        listInUse.Add(new CompletionResult(completionText, name, CompletionResultType.ParameterName,
                                                           tooltip));
                    }
                }

                if (parameterName != string.Empty)
                {
                    // Process alias when there is partial input
                    listInUse.AddRange(from alias in param.Parameter.Aliases
                                       where pattern.IsMatch(alias)
                                       select
                                         new CompletionResult("-" + alias + colonSuffix, alias, CompletionResultType.ParameterName,
                                                              type + alias));
                }
            }

            // Add the common parameters to the results if expected.
            if (addCommonParameters)
            {
                result.AddRange(commonParamResult);
            }
            return result;
        }

        /// <summary>
        /// Get completion results for operators that start with <paramref name="wordToComplete"/>
        /// </summary>
        /// <param name="wordToComplete">The starting text of the operator to complete</param>
        /// <returns>A list of completion results</returns>
        public static List<CompletionResult> CompleteOperator(string wordToComplete)
        {
            if (wordToComplete.StartsWith("-", StringComparison.Ordinal))
            {
                wordToComplete = wordToComplete.Substring(1);
            }

            return (from op in Tokenizer._operatorText
                    where op.StartsWith(wordToComplete, StringComparison.OrdinalIgnoreCase)
                    orderby op
                    select new CompletionResult("-" + op, op, CompletionResultType.ParameterName, GetOperatorDescription(op))).ToList();
        }

        private static string GetOperatorDescription(string op)
        {
            return ResourceManagerCache.GetResourceString(typeof(CompletionCompleters).Assembly,
                                                          "System.Management.Automation.resources.TabCompletionStrings",
                                                          op + "OperatorDescription");
        }

        #endregion Command Parameters

        #region Command Arguments

        internal static List<CompletionResult> CompleteCommandArgument(CompletionContext context)
        {
            CommandAst commandAst = null;
            List<CompletionResult> result = new List<CompletionResult>();

            // Find the expression ast. It should be at the end if there is one
            ExpressionAst expressionAst = null;
            MemberExpressionAst secondToLastMemberAst = null;
            Ast lastAst = context.RelatedAsts.Last();

            expressionAst = lastAst as ExpressionAst;
            if (expressionAst != null)
            {
                if (expressionAst.Parent is CommandAst)
                {
                    commandAst = (CommandAst)expressionAst.Parent;

                    if (expressionAst is ErrorExpressionAst && expressionAst.Extent.Text.EndsWith(",", StringComparison.Ordinal))
                    {
                        context.WordToComplete = string.Empty;
                        //BUGBUG context.CursorPosition = expressionAst.Extent.StartScriptPosition;
                    }
                    else if (commandAst.CommandElements.Count == 1 || context.WordToComplete == string.Empty)
                    {
                        expressionAst = null;
                    }
                    else if (commandAst.CommandElements.Count > 2)
                    {
                        var length = commandAst.CommandElements.Count;
                        var index = 1;

                        for (; index < length; index++)
                        {
                            if (commandAst.CommandElements[index] == expressionAst)
                                break;
                        }

                        CommandElementAst secondToLastAst = null;
                        if (index > 1)
                        {
                            secondToLastAst = commandAst.CommandElements[index - 1];
                            secondToLastMemberAst = secondToLastAst as MemberExpressionAst;
                        }

                        var partialPathAst = expressionAst as StringConstantExpressionAst;
                        if (partialPathAst != null && secondToLastAst != null &&
                            partialPathAst.StringConstantType == StringConstantType.BareWord &&
                            secondToLastAst.Extent.EndLineNumber == partialPathAst.Extent.StartLineNumber &&
                            secondToLastAst.Extent.EndColumnNumber == partialPathAst.Extent.StartColumnNumber &&
                            partialPathAst.Value.IndexOfAny(Utils.Separators.Directory) == 0)
                        {
                            var secondToLastStringConstantAst = secondToLastAst as StringConstantExpressionAst;
                            var secondToLastExpandableStringAst = secondToLastAst as ExpandableStringExpressionAst;
                            var secondToLastArrayAst = secondToLastAst as ArrayLiteralAst;
                            var secondToLastParamAst = secondToLastAst as CommandParameterAst;

                            if (secondToLastStringConstantAst != null || secondToLastExpandableStringAst != null)
                            {
                                var fullPath = ConcatenateStringPathArguments(secondToLastAst, partialPathAst.Value, context);
                                expressionAst = secondToLastStringConstantAst != null
                                                    ? (ExpressionAst)secondToLastStringConstantAst
                                                    : (ExpressionAst)secondToLastExpandableStringAst;

                                context.ReplacementIndex = ((InternalScriptPosition)secondToLastAst.Extent.StartScriptPosition).Offset;
                                context.ReplacementLength += ((InternalScriptPosition)secondToLastAst.Extent.EndScriptPosition).Offset - context.ReplacementIndex;
                                context.WordToComplete = fullPath;
                                //context.CursorPosition = secondToLastAst.Extent.StartScriptPosition;
                            }
                            else if (secondToLastArrayAst != null)
                            {
                                // Handle cases like: dir -Path .\cd, 'a b'\new<tab>
                                var lastArrayElement = secondToLastArrayAst.Elements.LastOrDefault();
                                var fullPath = ConcatenateStringPathArguments(lastArrayElement, partialPathAst.Value, context);
                                if (fullPath != null)
                                {
                                    expressionAst = secondToLastArrayAst;

                                    context.ReplacementIndex = ((InternalScriptPosition)lastArrayElement.Extent.StartScriptPosition).Offset;
                                    context.ReplacementLength += ((InternalScriptPosition)lastArrayElement.Extent.EndScriptPosition).Offset - context.ReplacementIndex;
                                    context.WordToComplete = fullPath;
                                }
                            }
                            else if (secondToLastParamAst != null)
                            {
                                // Handle cases like: dir -Path: .\cd, 'a b'\new<tab> || dir -Path: 'a b'\new<tab>
                                var fullPath = ConcatenateStringPathArguments(secondToLastParamAst.Argument, partialPathAst.Value, context);
                                if (fullPath != null)
                                {
                                    expressionAst = secondToLastParamAst.Argument;

                                    context.ReplacementIndex = ((InternalScriptPosition)secondToLastParamAst.Argument.Extent.StartScriptPosition).Offset;
                                    context.ReplacementLength += ((InternalScriptPosition)secondToLastParamAst.Argument.Extent.EndScriptPosition).Offset - context.ReplacementIndex;
                                    context.WordToComplete = fullPath;
                                }
                                else
                                {
                                    var arrayArgAst = secondToLastParamAst.Argument as ArrayLiteralAst;
                                    if (arrayArgAst != null)
                                    {
                                        var lastArrayElement = arrayArgAst.Elements.LastOrDefault();
                                        fullPath = ConcatenateStringPathArguments(lastArrayElement, partialPathAst.Value, context);
                                        if (fullPath != null)
                                        {
                                            expressionAst = arrayArgAst;

                                            context.ReplacementIndex = ((InternalScriptPosition)lastArrayElement.Extent.StartScriptPosition).Offset;
                                            context.ReplacementLength += ((InternalScriptPosition)lastArrayElement.Extent.EndScriptPosition).Offset - context.ReplacementIndex;
                                            context.WordToComplete = fullPath;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                else if (expressionAst.Parent is ArrayLiteralAst && expressionAst.Parent.Parent is CommandAst)
                {
                    commandAst = (CommandAst)expressionAst.Parent.Parent;

                    if (commandAst.CommandElements.Count == 1 || context.WordToComplete == string.Empty)
                    {
                        // dir -Path a.txt, b.txt <tab>
                        expressionAst = null;
                    }
                    else
                    {
                        // dir -Path a.txt, b.txt c<tab>
                        expressionAst = (ExpressionAst)expressionAst.Parent;
                    }
                }
                else if (expressionAst.Parent is ArrayLiteralAst && expressionAst.Parent.Parent is CommandParameterAst)
                {
                    // Handle scenarios such as
                    //      dir -Path: a.txt, <tab> || dir -Path: a.txt, b.txt <tab>
                    commandAst = (CommandAst)expressionAst.Parent.Parent.Parent;
                    if (context.WordToComplete == string.Empty)
                    {
                        // dir -Path: a.txt, b.txt <tab>
                        expressionAst = null;
                    }
                    else
                    {
                        // dir -Path: a.txt, b<tab>
                        expressionAst = (ExpressionAst)expressionAst.Parent;
                    }
                }
                else if (expressionAst.Parent is CommandParameterAst && expressionAst.Parent.Parent is CommandAst)
                {
                    commandAst = (CommandAst)expressionAst.Parent.Parent;
                    if (expressionAst is ErrorExpressionAst && expressionAst.Extent.Text.EndsWith(",", StringComparison.Ordinal))
                    {
                        // dir -Path: a.txt,<tab>
                        context.WordToComplete = string.Empty;
                        //context.CursorPosition = expressionAst.Extent.StartScriptPosition;
                    }
                    else if (context.WordToComplete == string.Empty)
                    {
                        // Handle scenario like this: Set-ExecutionPolicy -Scope:CurrentUser <tab>
                        expressionAst = null;
                    }
                }
            }
            else
            {
                var paramAst = lastAst as CommandParameterAst;
                if (paramAst != null)
                {
                    commandAst = paramAst.Parent as CommandAst;
                }
                else
                {
                    commandAst = lastAst as CommandAst;
                }
            }

            if (commandAst == null)
            {
                // We don't know if this could be expanded into anything interesting
                return result;
            }

            PseudoBindingInfo pseudoBinding = new PseudoParameterBinder()
                                                .DoPseudoParameterBinding(commandAst, null, null, PseudoParameterBinder.BindingType.ArgumentCompletion);

            do
            {
                // The command cannot be found, or it's NOT a cmdlet, NOT a script cmdlet and NOT a function
                if (pseudoBinding == null)
                    break;

                bool parsedArgumentsProvidesMatch = false;

                if (pseudoBinding.AllParsedArguments != null && pseudoBinding.AllParsedArguments.Count > 0)
                {
                    ArgumentLocation argLocation;
                    bool treatAsExpression = false;

                    if (expressionAst != null)
                    {
                        treatAsExpression = true;
                        var dashExp = expressionAst as StringConstantExpressionAst;
                        if (dashExp != null && dashExp.Value.Trim().Equals("-", StringComparison.OrdinalIgnoreCase))
                        {
                            // "-" is represented as StringConstantExpressionAst. Most likely the user is typing a <tab>