public override AstVisitAction VisitCommandParameter(CommandParameterAst ast) { if (ast.ParameterName.ToLower() == "typedefinition") IsTypeDefinitionAst = true; return AstVisitAction.Continue; }
public void IsTypeDefinitionAst_should_be_false_when_visit_not_typedefinition_CommandParameterAst() { var commandParameterAst = new CommandParameterAst(extent, "Other", argument, extent); visitor.VisitCommandParameter(commandParameterAst); visitor.IsTypeDefinitionAst.Should().BeFalse(); }
public void IsTypeDefinitionAst_should_be_true_when_visit_typedefinition_ast() { var commandParameterAst = new CommandParameterAst(extent, "TypeDefinition", argument, extent); visitor.VisitCommandParameter(commandParameterAst); visitor.IsTypeDefinitionAst.Should().BeTrue(); }
public object VisitCommandParameter(CommandParameterAst commandParameterAst) { if (commandParameterAst.Argument != null) { commandParameterAst.Argument.Accept(this); } return(null); }
public void VarName_should_return_name_from_argument() { var commandParameterAst = new CommandParameterAst(extent, "TypeDefinition", argument, extent); visitor.VisitCommandParameter(commandParameterAst); visitor.VisitVariableExpression(argument); visitor.VarName.Should().Be(argument.VariablePath.UserPath); }
public System.Object VisitCommandParameter(System.Management.Automation.Language.CommandParameterAst commandParameterAst) { IScriptExtent mappedExtent = MapExtent(commandParameterAst.Extent); ExpressionAst mappedArgument = commandParameterAst.Argument != null?_VisitExpression(commandParameterAst.Argument) : null; IScriptExtent mappedErrorPosition = MapExtent(commandParameterAst.ErrorPosition); return(new CommandParameterAst(mappedExtent, commandParameterAst.ParameterName, mappedArgument, mappedErrorPosition)); }
/// <summary> /// Checks to see if this command parameter is the symbol we are looking for. /// </summary> /// <param name="commandParameterAst">A CommandParameterAst object in the script's AST</param> /// <returns>A descion to stop searching if the right symbol was found, /// or a decision to continue if it wasn't found</returns> public override AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst) { if (this.IsPositionInExtent(commandParameterAst.Extent)) { this.FoundSymbolReference = new SymbolReference( SymbolType.Parameter, commandParameterAst.Extent); return AstVisitAction.StopVisit; } return AstVisitAction.Continue; }
internal FakePair(CommandParameterAst parameterAst) { if (parameterAst == null) { throw PSTraceSource.NewArgumentNullException("parameterAst"); } base.Parameter = parameterAst; base.ParameterArgumentType = AstParameterArgumentType.Fake; base.ParameterSpecified = true; base.ArgumentSpecified = true; base.ParameterName = parameterAst.ParameterName; base.ParameterText = parameterAst.ParameterName; base.ArgumentType = typeof(object); }
internal AstPair(CommandParameterAst parameterAst) { if ((parameterAst == null) || (parameterAst.Argument == null)) { throw PSTraceSource.NewArgumentException("parameterAst"); } base.Parameter = parameterAst; base.ParameterArgumentType = AstParameterArgumentType.AstPair; base.ParameterSpecified = true; base.ArgumentSpecified = true; base.ParameterName = parameterAst.ParameterName; base.ParameterText = "-" + base.ParameterName + ":"; base.ArgumentType = parameterAst.Argument.StaticType; this._parameterContainsArgument = true; this._argument = parameterAst.Argument; }
private void AddParameter(CommandParameterAst commandParameterAst) { string str; object expressionValue; if (commandParameterAst.Argument != null) { ExpressionAst argument = commandParameterAst.Argument; IScriptExtent errorPosition = commandParameterAst.ErrorPosition; str = ((errorPosition.EndLineNumber != argument.Extent.StartLineNumber) || (errorPosition.EndColumnNumber != argument.Extent.StartColumnNumber)) ? ": " : ":"; expressionValue = this.GetExpressionValue(commandParameterAst.Argument); } else { str = ""; expressionValue = null; } this._powershell.AddParameter(string.Format(CultureInfo.InvariantCulture, "-{0}{1}", new object[] { commandParameterAst.ParameterName, str }), expressionValue); }
internal AstPair(CommandParameterAst parameterAst, ExpressionAst argumentAst) { if ((parameterAst != null) && (parameterAst.Argument != null)) { throw PSTraceSource.NewArgumentException("parameterAst"); } if ((parameterAst == null) && (argumentAst == null)) { throw PSTraceSource.NewArgumentNullException("argumentAst"); } base.Parameter = parameterAst; base.ParameterArgumentType = AstParameterArgumentType.AstPair; base.ParameterSpecified = parameterAst != null; base.ArgumentSpecified = argumentAst != null; base.ParameterName = (parameterAst != null) ? parameterAst.ParameterName : null; base.ParameterText = (parameterAst != null) ? parameterAst.ParameterName : null; base.ArgumentType = (argumentAst != null) ? argumentAst.StaticType : null; this._parameterContainsArgument = false; this._argument = argumentAst; }
internal AstPair(CommandParameterAst parameterAst, CommandParameterAst argumentAst) { if ((parameterAst != null) && (parameterAst.Argument != null)) { throw PSTraceSource.NewArgumentException("parameterAst"); } if ((parameterAst == null) || (argumentAst == null)) { throw PSTraceSource.NewArgumentNullException("argumentAst"); } base.Parameter = parameterAst; base.ParameterArgumentType = AstParameterArgumentType.AstPair; base.ParameterSpecified = true; base.ArgumentSpecified = true; base.ParameterName = parameterAst.ParameterName; base.ParameterText = parameterAst.ParameterName; base.ArgumentType = typeof(string); this._parameterContainsArgument = false; this._argument = argumentAst; this._argumentIsCommandParameterAst = true; }
public override AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst) { return(AstVisitAction.Continue); }
public object VisitCommandParameter(CommandParameterAst commandParameterAst) { return(AutomationNull.Value); }
/// <summary/> public virtual AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst) { return(AstVisitAction.Continue); }
public object VisitCommandParameter(CommandParameterAst commandParameterAst) { throw PSTraceSource.NewArgumentException("ast"); }
public override AstVisitAction VisitCommandParameter(CommandParameterAst ast) { return(Check(ast)); }
public override AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst) { return AstVisitAction.Continue; }
internal SwitchPair(CommandParameterAst parameterAst) { if (parameterAst == null) throw PSTraceSource.NewArgumentNullException("parameterAst"); Parameter = parameterAst; ParameterArgumentType = AstParameterArgumentType.Switch; ParameterSpecified = true; ArgumentSpecified = true; ParameterName = parameterAst.ParameterName; ParameterText = parameterAst.ParameterName; ArgumentType = typeof(bool); }
/// <summary/> public virtual object VisitCommandParameter(CommandParameterAst commandParameterAst) { return _decorated.VisitCommandParameter(commandParameterAst); }
/// <summary> /// Visit command parameter /// </summary> /// <param name="commandParameterAst"></param> /// <returns></returns> public object VisitCommandParameter(CommandParameterAst commandParameterAst) { if (commandParameterAst == null) return null; if (commandParameterAst.Argument != null) { commandParameterAst.Argument.Visit(this.Decorator); } return null; }
public object VisitCommandParameter(CommandParameterAst commandParameterAst) { if (commandParameterAst.Argument != null) { commandParameterAst.Argument.Accept(this); } return null; }
private static CommandParameterInternal GetCommandParameter(CommandParameterAst commandParameterAst, System.Management.Automation.ExecutionContext context) { ExpressionAst argument = commandParameterAst.Argument; IScriptExtent errorPosition = commandParameterAst.ErrorPosition; if (argument == null) { return CommandParameterInternal.CreateParameter(errorPosition, commandParameterAst.ParameterName, errorPosition.Text); } object obj2 = Compiler.GetExpressionValue(argument, context, (IList)null); bool spaceAfterParameter = (errorPosition.EndLineNumber != argument.Extent.StartLineNumber) || (errorPosition.EndColumnNumber != argument.Extent.StartColumnNumber); return CommandParameterInternal.CreateParameterWithArgument(errorPosition, commandParameterAst.ParameterName, errorPosition.Text, argument.Extent, obj2, spaceAfterParameter); }
/// <summary> /// Get the parameter binding metadata /// </summary> /// <param name="command"></param> /// <param name="pipeArgumentType">Indicate the type of the piped-in argument</param> /// <param name="paramAstAtCursor">The CommandParameterAst the cursor is pointing at</param> /// <param name="bindingType">Indicates whether pseudo binding is for argument binding, argument completion, or parameter completion.</param> /// <returns>PseudoBindingInfo</returns> internal PseudoBindingInfo DoPseudoParameterBinding(CommandAst command, Type pipeArgumentType, CommandParameterAst paramAstAtCursor, BindingType bindingType) { if (command == null) { throw PSTraceSource.NewArgumentNullException("command"); } // initialize/reset the private members InitializeMembers(); _commandAst = command; _commandElements = command.CommandElements; Collection<AstParameterArgumentPair> unboundArguments = new Collection<AstParameterArgumentPair>(); // analyze the command and reparse the arguments { ExecutionContext executionContext = LocalPipeline.GetExecutionContextFromTLS(); if (executionContext != null) { // WinBlue: 324316. This limits the interaction of pseudoparameterbinder with the actual host. SetTemporaryDefaultHost(executionContext); PSLanguageMode? previousLanguageMode = null; try { // Tab expansion is called from a trusted function - we should apply ConstrainedLanguage if necessary. if (ExecutionContext.HasEverUsedConstrainedLanguage) { previousLanguageMode = executionContext.LanguageMode; executionContext.LanguageMode = PSLanguageMode.ConstrainedLanguage; } _bindingEffective = PrepareCommandElements(executionContext); } finally { if (previousLanguageMode.HasValue) { executionContext.LanguageMode = previousLanguageMode.Value; } RestoreHost(executionContext); } } } if (_bindingEffective && (_isPipelineInputExpected || pipeArgumentType != null)) { _pipelineInputType = pipeArgumentType; } _bindingEffective = ParseParameterArguments(paramAstAtCursor); if (_bindingEffective) { // named binding unboundArguments = BindNamedParameters(); _bindingEffective = _currentParameterSetFlag != 0; // positional binding unboundArguments = BindPositionalParameter( unboundArguments, _currentParameterSetFlag, _defaultParameterSetFlag, bindingType); // VFRA/pipeline binding if the given command is a binary cmdlet or a script cmdlet if (!_function) { unboundArguments = BindRemainingParameters(unboundArguments); BindPipelineParameters(); } // Update available parameter sets based on bound arguments // (x & (x -1 ) == 0) is a bit hack to determine if something is // exactly a power of two. bool parameterSetSpecified = (_currentParameterSetFlag != 0) && (_currentParameterSetFlag != UInt32.MaxValue); bool onlyOneRemainingParameterSet = (_currentParameterSetFlag != 0) && (_currentParameterSetFlag & (_currentParameterSetFlag - 1)) == 0; if ((bindingType != BindingType.ParameterCompletion) && parameterSetSpecified && (!onlyOneRemainingParameterSet)) { CmdletParameterBinderController.ResolveParameterSetAmbiguityBasedOnMandatoryParameters( _boundParameters, _unboundParameters, null, ref _currentParameterSetFlag, null); } } // Binding failed if (!_bindingEffective) { // The command is not a cmdlet, not a script cmdlet, and not a function if (_bindableParameters == null) return null; // get all bindable parameters _unboundParameters.Clear(); _unboundParameters.AddRange(_bindableParameters.BindableParameters.Values); return new PseudoBindingInfo( _commandInfo, _defaultParameterSetFlag, _arguments, _unboundParameters); } return new PseudoBindingInfo( _commandInfo, _currentParameterSetFlag, _defaultParameterSetFlag, _boundParameters, _unboundParameters, _boundArguments, _boundPositionalParameter, _arguments, _parametersNotFound, _ambiguousParameters, _bindingExceptions, _duplicateParameters, unboundArguments ); }
private static void ResetCurrentParameter(ref CommandParameterAst currentParameter, ref ParameterBindingResult bindingResult) { currentParameter = null; bindingResult = new ParameterBindingResult(); }
private void AddBoundParameter(CommandParameterAst parameter, string parameterName, ParameterBindingResult bindingResult) { if (BoundParameters.ContainsKey(parameterName)) { AddDuplicateParameterBindingException(parameter); } else { BoundParameters.Add(parameterName, bindingResult); } }
private void AddParameter(CommandParameterAst commandParameterAst, bool isTrustedInput) { string nameSuffix; object argument; if (commandParameterAst.Argument != null) { var arg = commandParameterAst.Argument; var errorPos = commandParameterAst.ErrorPosition; bool spaceAfterParameter = (errorPos.EndLineNumber != arg.Extent.StartLineNumber || errorPos.EndColumnNumber != arg.Extent.StartColumnNumber); nameSuffix = spaceAfterParameter ? ": " : ":"; argument = GetExpressionValue(commandParameterAst.Argument, isTrustedInput); } else { nameSuffix = ""; argument = null; } // first character in parameter name must be a dash _powershell.AddParameter( string.Format(CultureInfo.InvariantCulture, "-{0}{1}", commandParameterAst.ParameterName, nameSuffix), argument); }
public virtual AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst) { return AstVisitAction.Continue; }
internal AstPair(CommandParameterAst parameterAst, CommandElementAst argumentAst) { if (parameterAst != null && parameterAst.Argument != null) throw PSTraceSource.NewArgumentException("parameterAst"); if (parameterAst == null || argumentAst == null) throw PSTraceSource.NewArgumentNullException("argumentAst"); Parameter = parameterAst; ParameterArgumentType = AstParameterArgumentType.AstPair; ParameterSpecified = true; ArgumentSpecified = true; ParameterName = parameterAst.ParameterName; ParameterText = parameterAst.ParameterName; ArgumentType = typeof(string); ParameterContainsArgument = false; Argument = argumentAst; ArgumentIsCommandParameterAst = true; }
/// <summary/> public virtual object VisitCommandParameter(CommandParameterAst commandParameterAst) { return(null); }
internal PseudoBindingInfo DoPseudoParameterBinding(CommandAst command, Type pipeArgumentType, CommandParameterAst paramAstAtCursor, bool isForArgumentCompletion) { if (command == null) { throw PSTraceSource.NewArgumentNullException("command"); } this.InitializeMembers(); this._commandAst = command; this._commandElements = command.CommandElements; this._bindingEffective = this.PrepareCommandElements(LocalPipeline.GetExecutionContextFromTLS()); if (this._bindingEffective && (this._isPipelineInputExpected || (pipeArgumentType != null))) { this._pipelineInputType = pipeArgumentType; } this._bindingEffective = this.ParseParameterArguments(paramAstAtCursor); if (this._bindingEffective) { Collection <AstParameterArgumentPair> unboundArguments = this.BindNamedParameters(); this._bindingEffective = this._currentParameterSetFlag != 0; unboundArguments = this.BindPositionalParameter(unboundArguments, this._currentParameterSetFlag, this._defaultParameterSetFlag, isForArgumentCompletion); if (!this._function) { this.BindRemainingParameters(unboundArguments); this.BindPipelineParameters(); } } if (this._bindingEffective) { return(new PseudoBindingInfo(this._commandInfo, this._currentParameterSetFlag, this._defaultParameterSetFlag, this._boundParameters, this._unboundParameters, this._boundArguments, this._boundPositionalParameter, this._arguments, this._parametersNotFound, this._ambiguousParameters, this._duplicateParameters)); } if (this._bindableParameters == null) { return(null); } this._unboundParameters.Clear(); this._unboundParameters.AddRange(this._bindableParameters.BindableParameters.Values); return(new PseudoBindingInfo(this._commandInfo, this._defaultParameterSetFlag, this._arguments, this._unboundParameters)); }
public object VisitCommandParameter(CommandParameterAst commandParameterAst) { return false; }
private bool ParseParameterArguments(CommandParameterAst paramAstAtCursor) { if (!this._bindingEffective) { return(this._bindingEffective); } Collection <AstParameterArgumentPair> collection = new Collection <AstParameterArgumentPair>(); for (int i = 0; i < this._arguments.Count; i++) { AstParameterArgumentPair item = this._arguments[i]; if (!item.ParameterSpecified || item.ArgumentSpecified) { collection.Add(item); } else { string parameterName = item.ParameterName; MergedCompiledCommandParameter parameter = null; try { bool tryExactMatching = item.Parameter != paramAstAtCursor; parameter = this._bindableParameters.GetMatchingParameter(parameterName, false, tryExactMatching, null); } catch (ParameterBindingException) { this._ambiguousParameters.Add(item.Parameter); goto Label_01F1; } if (parameter == null) { if (i < (this._arguments.Count - 1)) { AstParameterArgumentPair pair2 = this._arguments[i + 1]; if (!pair2.ParameterSpecified && pair2.ArgumentSpecified) { this._arguments = null; return(false); } } this._parametersNotFound.Add(item.Parameter); } else if (parameter.Parameter.Type == typeof(SwitchParameter)) { SwitchPair pair3 = new SwitchPair(item.Parameter); collection.Add(pair3); } else if (i < (this._arguments.Count - 1)) { AstParameterArgumentPair pair4 = this._arguments[i + 1]; if (pair4.ParameterSpecified) { try { if (this._bindableParameters.GetMatchingParameter(pair4.ParameterName, false, true, null) == null) { AstPair pair5 = new AstPair(item.Parameter, pair4.Parameter); collection.Add(pair5); i++; } else { FakePair pair6 = new FakePair(item.Parameter); collection.Add(pair6); } goto Label_01F1; } catch (ParameterBindingException) { FakePair pair7 = new FakePair(item.Parameter); collection.Add(pair7); goto Label_01F1; } } AstPair pair8 = pair4 as AstPair; AstPair pair9 = new AstPair(item.Parameter, (ExpressionAst)pair8.Argument); collection.Add(pair9); i++; } else { FakePair pair10 = new FakePair(item.Parameter); collection.Add(pair10); } Label_01F1 :; } } this._arguments = collection; return(true); }
/// <summary> /// Decides if the current function defintion is a reference of the symbol being searched for. /// A reference of the symbol will be a of type SymbolType.Parameter and have the same name as the symbol /// </summary> /// <param name="commandParameterAst">A commandParameterAst in the script's AST</param> /// <returns>A visit action that continues the search for references</returns> public override AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst) { if (symbolRef.SymbolType.Equals(SymbolType.Parameter) && commandParameterAst.Extent.Text.Equals(symbolRef.SymbolName, StringComparison.InvariantCultureIgnoreCase)) { this.FoundReferences.Add(new SymbolReference( SymbolType.Parameter, commandParameterAst.Extent)); } return AstVisitAction.Continue; }
private bool PrepareCommandElements(ExecutionContext context) { int num = 0; bool dotSource = this._commandAst.InvocationOperator == TokenKind.Dot; CommandProcessorBase base2 = null; string resolvedCommandName = null; bool flag2 = false; try { base2 = this.PrepareFromAst(context, out resolvedCommandName) ?? context.CreateCommand(resolvedCommandName, dotSource); } catch (RuntimeException exception) { CommandProcessorBase.CheckForSevereException(exception); if ((this._commandAst.IsInWorkflow() && (resolvedCommandName != null)) && CompletionCompleters.PseudoWorkflowCommands.Contains <string>(resolvedCommandName, StringComparer.OrdinalIgnoreCase)) { flag2 = true; } else { return(false); } } CommandProcessor commandProcessor = base2 as CommandProcessor; ScriptCommandProcessorBase base3 = base2 as ScriptCommandProcessorBase; bool flag3 = (commandProcessor != null) && commandProcessor.CommandInfo.ImplementsDynamicParameters; List <object> list = flag3 ? new List <object>(this._commandElements.Count) : null; if (((commandProcessor != null) || (base3 != null)) || flag2) { num++; while (num < this._commandElements.Count) { CommandParameterAst parameterAst = this._commandElements[num] as CommandParameterAst; if (parameterAst != null) { if (list != null) { list.Add(parameterAst.Extent.Text); } AstPair item = (parameterAst.Argument != null) ? new AstPair(parameterAst, parameterAst.Argument) : new AstPair(parameterAst); this._arguments.Add(item); } else { StringConstantExpressionAst ast2 = this._commandElements[num] as StringConstantExpressionAst; if ((ast2 == null) || !ast2.Value.Trim().Equals("-", StringComparison.OrdinalIgnoreCase)) { ExpressionAst argumentAst = this._commandElements[num] as ExpressionAst; if (argumentAst != null) { if (list != null) { list.Add(argumentAst.Extent.Text); } this._arguments.Add(new AstPair(null, argumentAst)); } } } num++; } } if (commandProcessor != null) { this._function = false; if (flag3) { ParameterBinderController.AddArgumentsToCommandProcessor(commandProcessor, list.ToArray()); bool flag4 = false; bool flag5 = false; do { CommandProcessorBase currentCommandProcessor = context.CurrentCommandProcessor; try { context.CurrentCommandProcessor = commandProcessor; commandProcessor.SetCurrentScopeToExecutionScope(); if (!flag4) { commandProcessor.CmdletParameterBinderController.BindCommandLineParametersNoValidation(commandProcessor.arguments); } else { flag5 = true; commandProcessor.CmdletParameterBinderController.ClearUnboundArguments(); commandProcessor.CmdletParameterBinderController.BindCommandLineParametersNoValidation(new Collection <CommandParameterInternal>()); } } catch (ParameterBindingException exception2) { if ((exception2.ErrorId == "MissingArgument") || (exception2.ErrorId == "AmbiguousParameter")) { flag4 = true; } } catch (Exception exception3) { CommandProcessorBase.CheckForSevereException(exception3); } finally { context.CurrentCommandProcessor = currentCommandProcessor; commandProcessor.RestorePreviousScope(); } }while (flag4 && !flag5); } this._commandInfo = commandProcessor.CommandInfo; this._commandName = commandProcessor.CommandInfo.Name; this._bindableParameters = commandProcessor.CmdletParameterBinderController.BindableParameters; this._defaultParameterSetFlag = commandProcessor.CommandInfo.CommandMetadata.DefaultParameterSetFlag; } else if (base3 != null) { this._function = true; this._commandInfo = base3.CommandInfo; this._commandName = base3.CommandInfo.Name; this._bindableParameters = base3.ScriptParameterBinderController.BindableParameters; this._defaultParameterSetFlag = 0; } else if (!flag2) { return(false); } if (this._commandAst.IsInWorkflow()) { Type type = Type.GetType("Microsoft.PowerShell.Workflow.AstToWorkflowConverter, Microsoft.PowerShell.Activities, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"); if (type != null) { Dictionary <string, Type> dictionary = (Dictionary <string, Type>)type.GetMethod("GetActivityParameters").Invoke(null, new object[] { this._commandAst }); if (dictionary != null) { bool flag6 = dictionary.ContainsKey("PSComputerName") && !dictionary.ContainsKey("ComputerName"); List <MergedCompiledCommandParameter> source = new List <MergedCompiledCommandParameter>(); Collection <Attribute> attributes = new Collection <Attribute> { new ParameterAttribute() }; foreach (KeyValuePair <string, Type> pair2 in dictionary) { if (flag2 || !this._bindableParameters.BindableParameters.ContainsKey(pair2.Key)) { Type actualActivityParameterType = GetActualActivityParameterType(pair2.Value); RuntimeDefinedParameter runtimeDefinedParameter = new RuntimeDefinedParameter(pair2.Key, actualActivityParameterType, attributes); CompiledCommandParameter parameter = new CompiledCommandParameter(runtimeDefinedParameter, false) { IsInAllSets = true }; MergedCompiledCommandParameter parameter3 = new MergedCompiledCommandParameter(parameter, ParameterBinderAssociation.DeclaredFormalParameters); source.Add(parameter3); } } if (source.Any <MergedCompiledCommandParameter>()) { MergedCommandParameterMetadata metadata = new MergedCommandParameterMetadata(); if (!flag2) { metadata.ReplaceMetadata(this._bindableParameters); } foreach (MergedCompiledCommandParameter parameter5 in source) { metadata.BindableParameters.Add(parameter5.Parameter.Name, parameter5); } this._bindableParameters = metadata; } foreach (string str2 in ignoredWorkflowParameters) { if (this._bindableParameters.BindableParameters.ContainsKey(str2)) { this._bindableParameters.BindableParameters.Remove(str2); } } if (this._bindableParameters.BindableParameters.ContainsKey("ComputerName") && flag6) { this._bindableParameters.BindableParameters.Remove("ComputerName"); string key = (from aliasPair in this._bindableParameters.AliasedParameters where string.Equals("ComputerName", aliasPair.Value.Parameter.Name) select aliasPair.Key).FirstOrDefault <string>(); this._bindableParameters.AliasedParameters.Remove(key); } } } } this._unboundParameters.AddRange(this._bindableParameters.BindableParameters.Values); CommandBaseAst ast4 = null; PipelineAst parent = this._commandAst.Parent as PipelineAst; if (parent.PipelineElements.Count > 1) { foreach (CommandBaseAst ast6 in parent.PipelineElements) { if (ast6.GetHashCode() == this._commandAst.GetHashCode()) { this._isPipelineInputExpected = ast4 != null; if (this._isPipelineInputExpected) { this._pipelineInputType = typeof(object); } break; } ast4 = ast6; } } return(true); }
public object VisitCommandParameter(CommandParameterAst commandParameterAst) { return(false); }
internal AstPair(CommandParameterAst parameterAst, ExpressionAst argumentAst) { if (parameterAst != null && parameterAst.Argument != null) throw PSTraceSource.NewArgumentException("parameterAst"); if (parameterAst == null && argumentAst == null) throw PSTraceSource.NewArgumentNullException("argumentAst"); Parameter = parameterAst; ParameterArgumentType = AstParameterArgumentType.AstPair; ParameterSpecified = parameterAst != null; ArgumentSpecified = argumentAst != null; ParameterName = parameterAst != null ? parameterAst.ParameterName : null; ParameterText = parameterAst != null ? parameterAst.ParameterName : null; ArgumentType = argumentAst != null ? argumentAst.StaticType : null; ParameterContainsArgument = false; Argument = argumentAst; }
private bool ParseParameterArguments(CommandParameterAst paramAstAtCursor) { if (!this._bindingEffective) { return this._bindingEffective; } Collection<AstParameterArgumentPair> collection = new Collection<AstParameterArgumentPair>(); for (int i = 0; i < this._arguments.Count; i++) { AstParameterArgumentPair item = this._arguments[i]; if (!item.ParameterSpecified || item.ArgumentSpecified) { collection.Add(item); } else { string parameterName = item.ParameterName; MergedCompiledCommandParameter parameter = null; try { bool tryExactMatching = item.Parameter != paramAstAtCursor; parameter = this._bindableParameters.GetMatchingParameter(parameterName, false, tryExactMatching, null); } catch (ParameterBindingException) { this._ambiguousParameters.Add(item.Parameter); goto Label_01F1; } if (parameter == null) { if (i < (this._arguments.Count - 1)) { AstParameterArgumentPair pair2 = this._arguments[i + 1]; if (!pair2.ParameterSpecified && pair2.ArgumentSpecified) { this._arguments = null; return false; } } this._parametersNotFound.Add(item.Parameter); } else if (parameter.Parameter.Type == typeof(SwitchParameter)) { SwitchPair pair3 = new SwitchPair(item.Parameter); collection.Add(pair3); } else if (i < (this._arguments.Count - 1)) { AstParameterArgumentPair pair4 = this._arguments[i + 1]; if (pair4.ParameterSpecified) { try { if (this._bindableParameters.GetMatchingParameter(pair4.ParameterName, false, true, null) == null) { AstPair pair5 = new AstPair(item.Parameter, pair4.Parameter); collection.Add(pair5); i++; } else { FakePair pair6 = new FakePair(item.Parameter); collection.Add(pair6); } goto Label_01F1; } catch (ParameterBindingException) { FakePair pair7 = new FakePair(item.Parameter); collection.Add(pair7); goto Label_01F1; } } AstPair pair8 = pair4 as AstPair; AstPair pair9 = new AstPair(item.Parameter, (ExpressionAst) pair8.Argument); collection.Add(pair9); i++; } else { FakePair pair10 = new FakePair(item.Parameter); collection.Add(pair10); } Label_01F1:; } } this._arguments = collection; return true; }
public override AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst) { throw new NotImplementedException(); //VisitCommandParameter(commandParameterAst); }
internal AstPair(CommandParameterAst parameterAst) { if (parameterAst == null || parameterAst.Argument == null) throw PSTraceSource.NewArgumentException("parameterAst"); Parameter = parameterAst; ParameterArgumentType = AstParameterArgumentType.AstPair; ParameterSpecified = true; ArgumentSpecified = true; ParameterName = parameterAst.ParameterName; ParameterText = "-" + ParameterName + ":"; ArgumentType = parameterAst.Argument.StaticType; ParameterContainsArgument = true; Argument = parameterAst.Argument; }
/// <summary> /// Parse the arguments to process switch parameters and parameters without a value /// specified. We always eat the error (such as parameter without value) and continue /// to do the binding. /// </summary> /// /// <param name="paramAstAtCursor"> /// For parameter completion, if the cursor is pointing at a CommandParameterAst, we /// should not try exact matching for that CommandParameterAst. This is to handle the /// following case: /// Add-Computer -domain(tab) /// Add-Computer has an alias "Domain" that can exactly match this partial input, but /// since the user is typing 'tab', the partial input 'domain' should not be considered /// as an exact match. In this case, we don't try exact matching when calling /// GetMatchingParameter(..) so as to preserve other possibilities. /// </param> private bool ParseParameterArguments(CommandParameterAst paramAstAtCursor) { if (!_bindingEffective) return _bindingEffective; var result = new Collection<AstParameterArgumentPair>(); for (int index = 0; index < _arguments.Count; index++) { AstParameterArgumentPair argument = _arguments[index]; if (!argument.ParameterSpecified || argument.ArgumentSpecified) { // Add the positional/named arguments back result.Add(argument); continue; } Diagnostics.Assert(argument.ParameterSpecified && !argument.ArgumentSpecified, "At this point, the parameters should have no arguments"); //Now check the parameter name with the bindable parameters string parameterName = argument.ParameterName; MergedCompiledCommandParameter matchingParameter = null; try { bool tryExactMatching = argument.Parameter != paramAstAtCursor; matchingParameter = _bindableParameters.GetMatchingParameter(parameterName, false, tryExactMatching, null); } catch (ParameterBindingException e) { // The parameterName is resolved to multiple parameters. The most possible scenario for this // would be the user typping tab to complete a parameter. In this case, we can ignore this // parameter safely. // If the next item is a pure argument, we skip it so that it doesn't get bound // positionally. if (index < _arguments.Count - 1) { AstParameterArgumentPair nextArg = _arguments[index + 1]; if (!nextArg.ParameterSpecified && nextArg.ArgumentSpecified) { index++; } } _ambiguousParameters.Add(argument.Parameter); _bindingExceptions[argument.Parameter] = e; continue; } if (matchingParameter == null) { // The parameter cannot be found. The reason could be: // 1. It's a bynamic parameter, and we cannot retrieve the ParameterMetadata for it // at this point, since it's pseudo binding. // 2. The spelling of this parameter is wrong. // We can simply ignore this parameter, but the issue is what to do with the argument // following this parameter (if there is an argument following it). There are two cases: // 1. This parameter is supposed to be a switch parameter. Then the argument following it // should NOT be ignored. // 2. This parameter is supposed to take an argument. Then the following argument should // also be ignored // We check the next item. If it's a pure argument, we give up the binding, because we don't // know how to deal with it (ignore it? keep it?), and it will affect the accuracy of our // parameter set resolution. if (index < _arguments.Count - 1) { AstParameterArgumentPair nextArg = _arguments[index + 1]; // If the next item is a pure argument, we give up the pseudo binding. if (!nextArg.ParameterSpecified && nextArg.ArgumentSpecified) { // Testing paramsAstAtCursor ensures we only give up during tab completion, // otherwise we know this is a missing parameter. if (paramAstAtCursor != null) { // Do not use the parsed arguments _arguments = null; return false; } else { // Otherwise, skip the next argument index++; _parametersNotFound.Add(argument.Parameter); continue; } } } // If the next item is not a pure argument, or the current parameter is the last item, // ignore this parameter and carry on with the binding _parametersNotFound.Add(argument.Parameter); continue; } // Check if it's SwitchParameter if (matchingParameter.Parameter.Type == typeof(SwitchParameter)) { SwitchPair newArg = new SwitchPair(argument.Parameter); result.Add(newArg); continue; } // It's not a switch parameter, we need to check the next argument if (index < _arguments.Count - 1) { AstParameterArgumentPair nextArg = _arguments[index + 1]; if (nextArg.ParameterSpecified) { try { MergedCompiledCommandParameter nextMatchingParameter = _bindableParameters.GetMatchingParameter(nextArg.ParameterName, false, true, null); // The next parameter doesn't exist. We use it as an argument if (nextMatchingParameter == null) { AstPair newArg = new AstPair(argument.Parameter, nextArg.Parameter); result.Add(newArg); index++; } else { // It's possible the user is typing tab for argument completion. // We set a fake argument for the current parameter in this case. FakePair newArg = new FakePair(argument.Parameter); result.Add(newArg); } } catch (ParameterBindingException) { // The next parameter name is ambiguous. We just set // a fake argument for the current paramter. FakePair newArg = new FakePair(argument.Parameter); result.Add(newArg); } } else { // The next item is a pure argument. AstPair nextArgument = nextArg as AstPair; Diagnostics.Assert(nextArgument != null, "the next item should be a pure argument here"); Diagnostics.Assert(nextArgument.ArgumentSpecified && !nextArgument.ArgumentIsCommandParameterAst, "the next item should be a pure argument here"); AstPair newArg = new AstPair(argument.Parameter, (ExpressionAst)nextArgument.Argument); result.Add(newArg); index++; } } else { // The current parameter is the last item. Set a fake argument for it FakePair newArg = new FakePair(argument.Parameter); result.Add(newArg); } } _arguments = result; return true; }
/// <summary/> public virtual AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst) => DefaultVisit(commandParameterAst);
private void AddDuplicateParameterBindingException(CommandParameterAst duplicateParameter) { if (duplicateParameter == null) { return; } ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, null, duplicateParameter.ErrorPosition, duplicateParameter.ParameterName, null, null, ParameterBinderStrings.ParameterAlreadyBound, "ParameterAlreadyBound"); // if the duplicated Parameter Name appears more than twice, we will ignore as we already have similar bindingException. if (!BindingExceptions.ContainsKey(duplicateParameter.ParameterName)) { BindingExceptions.Add(duplicateParameter.ParameterName, new StaticBindingError(duplicateParameter, bindingException)); } }