/// <summary> /// Condition on the cmdlet that must be satisfied for the error to be raised /// </summary> /// <param name="CmdAst"></param> /// <returns></returns> public override bool CommandCondition(CommandAst CmdAst) { if (CTSTCmdlet == null) { CTSTCmdlet = Helper.Instance.CmdletNameAndAliases("convertto-securestring"); } return CmdAst != null && CmdAst.GetCommandName() != null && CTSTCmdlet.Contains(CmdAst.GetCommandName(), StringComparer.OrdinalIgnoreCase); }
internal bool IsInWorkflow() { Ast parent = this; bool flag = false; while ((parent != null) && !flag) { ScriptBlockAst ast2 = parent as ScriptBlockAst; if (ast2 != null) { FunctionDefinitionAst ast3 = ast2.Parent as FunctionDefinitionAst; if (ast3 != null) { flag = true; if (ast3.IsWorkflow) { return(true); } } } CommandAst ast4 = parent as CommandAst; if (((ast4 != null) && string.Equals(TokenKind.InlineScript.Text(), ast4.GetCommandName(), StringComparison.OrdinalIgnoreCase)) && (this != ast4)) { return(false); } parent = parent.Parent; } return(false); }
public override AstVisitAction VisitCommand(CommandAst commandAst) { string commandName; if (commandAst.InvocationOperator == TokenKind.Dot) { this.ReportError(commandAst, () => ParserStrings.DotSourcingNotSupportedInDataSection, new object[0]); return(AstVisitAction.Continue); } if (this._allowedCommands != null) { commandName = commandAst.GetCommandName(); if (commandName == null) { if (commandAst.InvocationOperator == TokenKind.Ampersand) { this.ReportError(commandAst, () => ParserStrings.OperatorNotSupportedInDataSection, new object[] { TokenKind.Ampersand.Text() }); } else { this.ReportError(commandAst, () => ParserStrings.CmdletNotInAllowedListForDataSection, new object[] { commandAst.Extent.Text }); } return(AstVisitAction.Continue); } if (!(from allowedCommand in this._allowedCommands where allowedCommand.Equals(commandName, StringComparison.OrdinalIgnoreCase) select allowedCommand).Any <string>()) { this.ReportError(commandAst, () => ParserStrings.CmdletNotInAllowedListForDataSection, new object[] { commandName }); } } return(AstVisitAction.Continue); }
/// <summary> /// Retrieves the error message /// </summary> /// <param name="FileName"></param> /// <param name="CmdAst"></param> /// <returns></returns> public override string GetError(string FileName, CommandAst CmdAst) { if (CmdAst == null) { return string.Empty; } return string.Format(CultureInfo.CurrentCulture, Strings.AvoidComputerNameHardcodedError, CmdAst.GetCommandName()); }
/// <summary> /// Checks that write-host command is not used /// </summary> /// <param name="cmdAst"></param> /// <returns></returns> public override AstVisitAction VisitCommand(CommandAst cmdAst) { if (cmdAst == null) { return AstVisitAction.SkipChildren; } if (cmdAst.GetCommandName() != null && String.Equals(cmdAst.GetCommandName(), "write-host", StringComparison.OrdinalIgnoreCase)) { if (String.IsNullOrWhiteSpace(fileName)) { records.Add(new DiagnosticRecord(String.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingWriteHostErrorScriptDefinition), cmdAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName)); } else { records.Add(new DiagnosticRecord(String.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingWriteHostError, System.IO.Path.GetFileName(fileName)), cmdAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName)); } } return AstVisitAction.Continue; }
private static FunctionDefinitionAst FindDefinition(CommandAst ast, Ast parentAst) { if (ast == null) throw new ArgumentNullException("ast"); if (parentAst == null) return null; var definitions = parentAst.FindAll( m => m is FunctionDefinitionAst && ((FunctionDefinitionAst) m).Name.Equals(ast.GetCommandName()), false).ToList(); if (definitions.Any()) { return definitions.Last() as FunctionDefinitionAst; } return FindDefinition(ast, parentAst.Parent); }
Command GetCommand(CommandAst commandAst) { if (commandAst.CommandElements.First() is ScriptBlockExpressionAst) { var scriptBlockAst = (commandAst.CommandElements.First() as ScriptBlockExpressionAst).ScriptBlock; return new Command(scriptBlockAst); } else { return new Command(commandAst.GetCommandName()); } }
/// <summary> /// Return true if mandatory parameters are used OR the cmdlet does not exist /// </summary> /// <param name="cmdAst"></param> /// <returns></returns> private bool IsMandatoryParameterExisted(CommandAst cmdAst) { CommandInfo cmdInfo = null; List<ParameterMetadata> mandParams = new List<ParameterMetadata>(); IEnumerable<CommandElementAst> ceAsts = null; bool returnValue = false; #region Predicates // Predicate to find ParameterAsts. Func<CommandElementAst, bool> foundParamASTs = delegate(CommandElementAst ceAst) { if (ceAst is CommandParameterAst) return true; return false; }; #endregion #region Compares parameter list and mandatory parameter list. cmdInfo = Helper.Instance.GetCommandInfo(Helper.Instance.GetCmdletNameFromAlias(cmdAst.GetCommandName())) ?? Helper.Instance.GetCommandInfo(cmdAst.GetCommandName()); if (cmdInfo == null || (cmdInfo.CommandType != System.Management.Automation.CommandTypes.Cmdlet)) { return true; } // ignores if splatted variable is used if (Helper.Instance.HasSplattedVariable(cmdAst)) { return true; } // Gets parameters from command elements. ceAsts = cmdAst.CommandElements.Where<CommandElementAst>(foundParamASTs); // Gets mandatory parameters from cmdlet. // If cannot find any mandatory parameter, it's not necessary to do a further check for current cmdlet. try { int noOfParamSets = cmdInfo.ParameterSets.Count; foreach (ParameterMetadata pm in cmdInfo.Parameters.Values) { int count = 0; if (pm.Attributes.Count < noOfParamSets) { continue; } foreach (Attribute attr in pm.Attributes) { if (!(attr is ParameterAttribute)) continue; if (((ParameterAttribute)attr).Mandatory) { count += 1; } } if (count >= noOfParamSets) { mandParams.Add(pm); } } } catch (Exception) { // For cases like cmd.exe. Also for runtime exception return true; } if (mandParams.Count() == 0 || Helper.Instance.PositionalParameterUsed(cmdAst)) { returnValue = true; } else { // Compares parameter list and mandatory parameter list. foreach (CommandElementAst ceAst in ceAsts) { CommandParameterAst cpAst = (CommandParameterAst)ceAst; if (mandParams.Count<ParameterMetadata>(item => item.Name.Equals(cpAst.ParameterName, StringComparison.OrdinalIgnoreCase)) > 0) { returnValue = true; break; } } } #endregion return returnValue; }
/// <summary> /// Visit command /// </summary> /// <param name="commandAst"></param> /// <returns></returns> public object VisitCommand(CommandAst commandAst) { if (commandAst == null) return null; //Add the check for Tee-Object -Variable var if (string.Equals(commandAst.GetCommandName(), "Tee-Object", StringComparison.OrdinalIgnoreCase)) { foreach (CommandElementAst ceAst in commandAst.CommandElements) { if (ceAst is CommandParameterAst) { string paramName = (ceAst as CommandParameterAst).ParameterName; if (string.Equals(paramName, "Variable", StringComparison.OrdinalIgnoreCase)) { int index = commandAst.CommandElements.IndexOf(ceAst); if (commandAst.CommandElements.Count > (index + 1)) { CommandElementAst paramConstant = commandAst.CommandElements[index + 1]; if (paramConstant is StringConstantExpressionAst) { //If common parameters are used, create a variable target and store the variable value _currentBlock.AddAst(new AssignmentTarget((paramConstant as StringConstantExpressionAst).Value, typeof(string))); } } } } } } else { foreach (CommandElementAst ceAst in commandAst.CommandElements) { if (ceAst is CommandParameterAst) { string paramName = (ceAst as CommandParameterAst).ParameterName; if (string.Equals(paramName, "ErrorVariable", StringComparison.OrdinalIgnoreCase) || string.Equals(paramName, "WarningVariable", StringComparison.OrdinalIgnoreCase) || string.Equals(paramName, "PipelineVariable ", StringComparison.OrdinalIgnoreCase) || string.Equals(paramName, "OutVariable", StringComparison.OrdinalIgnoreCase)) { int index = commandAst.CommandElements.IndexOf(ceAst); if (commandAst.CommandElements.Count > (index + 1)) { CommandElementAst paramConstant = commandAst.CommandElements[index + 1]; if (paramConstant is StringConstantExpressionAst) { //If common parameters are used, create a variable target and store the variable value _currentBlock.AddAst(new AssignmentTarget((paramConstant as StringConstantExpressionAst).Value, typeof(string))); } } } } ceAst.Visit(this.Decorator); } } return null; }
public override AstVisitAction VisitCommand(CommandAst commandAst) { string commandName; if (commandAst.InvocationOperator == TokenKind.Dot) { this.ReportError(commandAst, () => ParserStrings.DotSourcingNotSupportedInDataSection, new object[0]); return AstVisitAction.Continue; } if (this._allowedCommands != null) { commandName = commandAst.GetCommandName(); if (commandName == null) { if (commandAst.InvocationOperator == TokenKind.Ampersand) { this.ReportError(commandAst, () => ParserStrings.OperatorNotSupportedInDataSection, new object[] { TokenKind.Ampersand.Text() }); } else { this.ReportError(commandAst, () => ParserStrings.CmdletNotInAllowedListForDataSection, new object[] { commandAst.Extent.Text }); } return AstVisitAction.Continue; } if (!(from allowedCommand in this._allowedCommands where allowedCommand.Equals(commandName, StringComparison.OrdinalIgnoreCase) select allowedCommand).Any<string>()) { this.ReportError(commandAst, () => ParserStrings.CmdletNotInAllowedListForDataSection, new object[] { commandName }); } } return AstVisitAction.Continue; }
/// <summary> /// Visit CommandAst. Skip if name of command is in /// namestobeskipped /// </summary> /// <param name="commandAst"></param> /// <returns></returns> public override AstVisitAction VisitCommand(CommandAst commandAst) { if (commandAst == null || commandAst.GetCommandName() == null) { return AstVisitAction.SkipChildren; } if (commandAst.CommandElements != null && commandAst.CommandElements.Count > 0) { var firstCommand = commandAst.CommandElements[0]; if (NamesToBeSkipped.Contains(firstCommand.Extent.Text, StringComparer.OrdinalIgnoreCase)) { return AstVisitAction.SkipChildren; } } return AstVisitAction.Continue; }
Command GetCommand(CommandAst commandAst) { return new Command(commandAst.GetCommandName()); }
public override AstVisitAction VisitCommand(CommandAst commandAst) { // Commands are allowed if arguments are allowed, no redirection, no dotting // If _allowedCommands is null, any command is allowed, otherwise // we must check the command name. if (commandAst.InvocationOperator == TokenKind.Dot) { ReportError(commandAst, () => ParserStrings.DotSourcingNotSupportedInDataSection); return AstVisitAction.Continue; } if (_allowedCommands == null) return AstVisitAction.Continue; string commandName = commandAst.GetCommandName(); if (commandName == null) { if (commandAst.InvocationOperator == TokenKind.Ampersand) { ReportError(commandAst, () => ParserStrings.OperatorNotSupportedInDataSection, TokenKind.Ampersand.Text()); } else { ReportError(commandAst, () => ParserStrings.CmdletNotInAllowedListForDataSection, commandAst.Extent.Text); } return AstVisitAction.Continue; } if (_allowedCommands.Any(allowedCommand => allowedCommand.Equals(commandName, StringComparison.OrdinalIgnoreCase))) { return AstVisitAction.Continue; } ReportError(commandAst, () => ParserStrings.CmdletNotInAllowedListForDataSection, commandName); return AstVisitAction.Continue; }
// Visit one the other variations: // - Dotting scripts // - Setting aliases // - Importing modules // - Exporting module members public override AstVisitAction VisitCommand(CommandAst commandAst) { string commandName = commandAst.GetCommandName() ?? GetSafeValueVisitor.GetSafeValue(commandAst.CommandElements[0], null, GetSafeValueVisitor.SafeValueContext.ModuleAnalysis) as string; if (commandName == null) return AstVisitAction.SkipChildren; // They are trying to dot a script if (commandAst.InvocationOperator == TokenKind.Dot) { // . Foo-Bar4.ps1 // . $psScriptRoot\Foo-Bar.ps1 -Bing Baz // . ""$psScriptRoot\Support Files\Foo-Bar2.ps1"" -Bing Baz // . '$psScriptRoot\Support Files\Foo-Bar3.ps1' -Bing Baz DiscoveredModules.Add( new RequiredModuleInfo { Name = commandName, CommandsToPostFilter = new List<string>() }); ModuleIntrinsics.Tracer.WriteLine("Module dots {0}", commandName); } // They are setting an alias. if (String.Equals(commandName, "New-Alias", StringComparison.OrdinalIgnoreCase) || String.Equals(commandName, "Microsoft.PowerShell.Utility\\New-Alias", StringComparison.OrdinalIgnoreCase) || String.Equals(commandName, "Set-Alias", StringComparison.OrdinalIgnoreCase) || String.Equals(commandName, "Microsoft.PowerShell.Utility\\Set-Alias", StringComparison.OrdinalIgnoreCase) || String.Equals(commandName, "nal", StringComparison.OrdinalIgnoreCase) || String.Equals(commandName, "sal", StringComparison.OrdinalIgnoreCase)) { // Set-Alias Foo-Bar5 Foo-Bar // Set-Alias -Name Foo-Bar6 -Value Foo-Bar // sal Foo-Bar7 Foo-Bar // sal -Value Foo-Bar -Name Foo-Bar8 var boundParameters = DoPsuedoParameterBinding(commandAst, commandName); var name = boundParameters["Name"] as string; if (!string.IsNullOrEmpty(name)) { var value = boundParameters["Value"] as string; if (!string.IsNullOrEmpty(value)) { // These aren't stored in DiscoveredExports, as they are only // exported after the user calls Export-ModuleMember. DiscoveredAliases[name] = value; ModuleIntrinsics.Tracer.WriteLine("Module defines alias: {0} = {1}", name, value); } } return AstVisitAction.SkipChildren; } // They are importing a module if (String.Equals(commandName, "Import-Module", StringComparison.OrdinalIgnoreCase) || String.Equals(commandName, "ipmo", StringComparison.OrdinalIgnoreCase)) { // Import-Module Module1 // Import-Module Module2 -Function Foo-Module2*, Foo-Module2Second* -Cmdlet Foo-Module2Cmdlet,Foo-Module2Cmdlet* // Import-Module Module3 -Function Foo-Module3Command1, Foo-Module3Command2 // Import-Module Module4, // Module5 // Import-Module -Name Module6, // Module7 -Global var boundParameters = DoPsuedoParameterBinding(commandAst, commandName); List<string> commandsToPostFilter = new List<string>(); Action<string> onEachCommand = importedCommandName => { commandsToPostFilter.Add(importedCommandName); }; // Process any exports from the module that we determine from // the -Function, -Cmdlet, or -Alias parameters ProcessCmdletArguments(boundParameters["Function"], onEachCommand); ProcessCmdletArguments(boundParameters["Cmdlet"], onEachCommand); ProcessCmdletArguments(boundParameters["Alias"], onEachCommand); // Now, go through all of the discovered modules on Import-Module // and register them for deeper investigation. Action<string> onEachModule = moduleName => { ModuleIntrinsics.Tracer.WriteLine("Discovered module import: {0}", moduleName); DiscoveredModules.Add( new RequiredModuleInfo { Name = moduleName, CommandsToPostFilter = commandsToPostFilter }); }; ProcessCmdletArguments(boundParameters["Name"], onEachModule); return AstVisitAction.SkipChildren; } // They are exporting a module member if (String.Equals(commandName, "Export-ModuleMember", StringComparison.OrdinalIgnoreCase) || String.Equals(commandName, "Microsoft.PowerShell.Core\\Export-ModuleMember", StringComparison.OrdinalIgnoreCase) || String.Equals(commandName, "$script:ExportModuleMember", StringComparison.OrdinalIgnoreCase)) { // Export-ModuleMember * // Export-ModuleMember Exported-UnNamedModuleMember // Export-ModuleMember -Function Exported-FunctionModuleMember1, Exported-FunctionModuleMember2 -Cmdlet Exported-CmdletModuleMember ` // -Alias Exported-AliasModuleMember // & $script:ExportModuleMember -Function (...) var boundParameters = DoPsuedoParameterBinding(commandAst, commandName); Action<string> onEachFunction = exportedCommandName => { DiscoveredCommandFilters.Add(exportedCommandName); ModuleIntrinsics.Tracer.WriteLine("Discovered explicit export: {0}", exportedCommandName); // If the export doesn't contain wildcards, then add it to the // discovered commands as well. It is likely that they created // the command dynamically if ((!WildcardPattern.ContainsWildcardCharacters(exportedCommandName)) && (!DiscoveredExports.Contains(exportedCommandName))) { DiscoveredExports.Add(exportedCommandName); } }; ProcessCmdletArguments(boundParameters["Function"], onEachFunction); ProcessCmdletArguments(boundParameters["Cmdlet"], onEachFunction); Action<string> onEachAlias = exportedAlias => { DiscoveredCommandFilters.Add(exportedAlias); // If the export doesn't contain wildcards, then add it to the // discovered commands as well. It is likely that they created // the command dynamically if (!WildcardPattern.ContainsWildcardCharacters(exportedAlias)) { DiscoveredAliases[exportedAlias] = null; } }; ProcessCmdletArguments(boundParameters["Alias"], onEachAlias); return AstVisitAction.SkipChildren; } // They are exporting a module member using our advanced 'public' function // that we've presented in many demos if ((String.Equals(commandName, "public", StringComparison.OrdinalIgnoreCase)) && (commandAst.CommandElements.Count > 2)) { // public function Publicly-ExportedFunction // public alias Publicly-ExportedAlias string publicCommandName = commandAst.CommandElements[2].ToString().Trim(); DiscoveredExports.Add(publicCommandName); DiscoveredCommandFilters.Add(publicCommandName); } return AstVisitAction.SkipChildren; }
public override AstVisitAction VisitCommand(CommandAst commandAst) { var commandName = commandAst.GetCommandName(); if (commandName != null) { if (_singleton._engineIntrinsics != null) { var commandInfo = _singleton._engineIntrinsics.InvokeCommand.GetCommand(commandName, CommandTypes.All); if (commandInfo == null && !_singleton.UnresolvedCommandCouldSucceed(commandName, _rootAst)) { _singleton._current = commandAst.CommandElements[0].Extent.EndOffset; detectedError = string.Format(CultureInfo.CurrentCulture, PSReadLineResources.CommandNotFoundError, commandName); return AstVisitAction.StopVisit; } } if (commandAst.CommandElements.Any(e => e is ScriptBlockExpressionAst)) { if (_singleton._options.CommandsToValidateScriptBlockArguments == null || !_singleton._options.CommandsToValidateScriptBlockArguments.Contains(commandName)) { return AstVisitAction.SkipChildren; } } } if (_singleton._options.CommandValidationHandler != null) { try { _singleton._options.CommandValidationHandler(commandAst); } catch (Exception e) { detectedError = e.Message; } } return !string.IsNullOrWhiteSpace(detectedError) ? AstVisitAction.StopVisit : AstVisitAction.Continue; }
/// <summary> /// Creates a list containing suggested correction /// </summary> /// <param name="cmdAst">Command AST of an alias</param> /// <param name="cmdletName">Full name of the alias</param> /// <returns>Retruns a list of suggested corrections</returns> private List<CorrectionExtent> GetCorrectionExtent(CommandAst cmdAst, string cmdletName) { var ext = cmdAst.Extent; if (ext.File == null) { return null; } var corrections = new List<CorrectionExtent>(); var alias = cmdAst.GetCommandName(); string description = string.Format( CultureInfo.CurrentCulture, Strings.AvoidUsingCmdletAliasesCorrectionDescription, alias, cmdletName); corrections.Add(new CorrectionExtent( ext.StartLineNumber, ext.EndLineNumber, cmdAst.CommandElements[0].Extent.StartColumnNumber, cmdAst.CommandElements[0].Extent.EndColumnNumber, cmdletName, ext.File, description)); return corrections; }
public override AstVisitAction VisitCommand(CommandAst commandAst) { string commandName = commandAst.GetCommandName(); if (string.IsNullOrEmpty(commandName)) { commandName = commandAst.CommandElements[0].ToString().Trim(new char[] { '"', '\'' }); } if (commandAst.InvocationOperator == TokenKind.Dot) { commandName = Regex.Replace(commandName, @"\$[^\\]*\\", "", RegexOptions.IgnoreCase); RequiredModuleInfo item = new RequiredModuleInfo { Name = commandName, CommandsToPostFilter = new List<string>() }; this.DiscoveredModules.Add(item); ModuleIntrinsics.Tracer.WriteLine("Module dots " + commandName, new object[0]); } if (((string.Equals(commandName, "New-Alias", StringComparison.OrdinalIgnoreCase) || string.Equals(commandName, @"Microsoft.PowerShell.Utility\New-Alias", StringComparison.OrdinalIgnoreCase)) || (string.Equals(commandName, "Set-Alias", StringComparison.OrdinalIgnoreCase) || string.Equals(commandName, @"Microsoft.PowerShell.Utility\Set-Alias", StringComparison.OrdinalIgnoreCase))) || (string.Equals(commandName, "nal", StringComparison.OrdinalIgnoreCase) || string.Equals(commandName, "sal", StringComparison.OrdinalIgnoreCase))) { string str2 = this.GetParameterByNameOrPosition("Name", 0, commandAst); string str3 = this.GetParameterByNameOrPosition("Value", 1, commandAst); if (!string.IsNullOrEmpty(str2)) { this.DiscoveredAliases[str2] = str3; ModuleIntrinsics.Tracer.WriteLine("Module defines alias: " + str2 + "=" + str3, new object[0]); } } if (string.Equals(commandName, "Import-Module", StringComparison.OrdinalIgnoreCase) || string.Equals(commandName, "ipmo", StringComparison.OrdinalIgnoreCase)) { List<string> list = new List<string>(); string str4 = this.GetParameterByNameOrPosition("Function", -1, commandAst); if (!string.IsNullOrEmpty(str4)) { list.AddRange(this.ProcessExportedCommandList(str4)); } string str5 = this.GetParameterByNameOrPosition("Cmdlet", -1, commandAst); if (!string.IsNullOrEmpty(str5)) { list.AddRange(this.ProcessExportedCommandList(str5)); } string str6 = this.GetParameterByNameOrPosition("Alias", -1, commandAst); if (!string.IsNullOrEmpty(str6)) { list.AddRange(this.ProcessExportedCommandList(str6)); } string str7 = this.GetParameterByNameOrPosition("Name", 0, commandAst); if (!string.IsNullOrEmpty(str7)) { foreach (string str8 in str7.Split(new char[] { ',' })) { ModuleIntrinsics.Tracer.WriteLine("Discovered module import: " + str8, new object[0]); RequiredModuleInfo info2 = new RequiredModuleInfo { Name = str8.Trim(), CommandsToPostFilter = list }; this.DiscoveredModules.Add(info2); } } } if ((string.Equals(commandName, "Export-ModuleMember", StringComparison.OrdinalIgnoreCase) || string.Equals(commandName, @"Microsoft.PowerShell.Core\Export-ModuleMember", StringComparison.OrdinalIgnoreCase)) || string.Equals(commandName, "$script:ExportModuleMember", StringComparison.OrdinalIgnoreCase)) { List<string> list2 = new List<string>(); string arguments = this.GetParameterByNameOrPosition("Function", 0, commandAst); list2.AddRange(this.ExtractArgumentList(arguments)); string str10 = this.GetParameterByNameOrPosition("Cmdlet", -1, commandAst); list2.AddRange(this.ExtractArgumentList(str10)); foreach (string str11 in list2) { this.DiscoveredCommandFilters.Add(str11); ModuleIntrinsics.Tracer.WriteLine("Discovered explicit export: " + str11, new object[0]); if (!WildcardPattern.ContainsWildcardCharacters(str11) && !this.DiscoveredExports.Contains(str11)) { this.DiscoveredExports.Add(str11); } } list2 = new List<string>(); string str12 = this.GetParameterByNameOrPosition("Alias", -1, commandAst); list2.AddRange(this.ExtractArgumentList(str12)); foreach (string str13 in list2) { this.DiscoveredCommandFilters.Add(str13); if (!WildcardPattern.ContainsWildcardCharacters(str13) && !this.DiscoveredAliases.ContainsKey(str13)) { this.DiscoveredAliases.Add(str13, null); } } } if (string.Equals(commandName, "public", StringComparison.OrdinalIgnoreCase) && (commandAst.CommandElements.Count > 2)) { string str14 = commandAst.CommandElements[2].ToString().Trim(); this.DiscoveredExports.Add(str14); this.DiscoveredCommandFilters.Add(str14); } return AstVisitAction.Continue; }