Name

Symbol.cs (1)

17Name = ThrowIfEmptyOrWithWhitespaces(name, nameof(name), allowWhitespace);

Commands\AddCommand.cs (1)

76using var activity = Telemetry.StartDiagnosticActivity(this.Name);

Commands\ApiGetCommand.cs (1)

48using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\ApiListCommand.cs (1)

50using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\ApiSearchCommand.cs (1)

62using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\AppHostLauncher.cs (1)

344args.Add(s_isolatedOption.Name);

Commands\BaseCommand.cs (2)

281if (option.Name == "--format" && option is Option<OutputFormat> formatOption) 331result.AddError(string.Format(CultureInfo.CurrentCulture, SharedCommandStrings.NonInteractiveRequiresYesFormat, command.Name));

Commands\DescribeCommand.cs (1)

126using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\DocsGetCommand.cs (1)

53using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\DocsListCommand.cs (1)

43using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\DocsSearchCommand.cs (1)

55using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\ExportCommand.cs (1)

74using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\GroupedHelpWriter.cs (11)

78list.Sort((a, b) => string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase)); 132foreach (var cmd in ungroupedCommands.OrderBy(c => c.Name, StringComparer.OrdinalIgnoreCase)) 273return string.IsNullOrEmpty(args) ? cmd.Name : $"{cmd.Name} {args}"; 291var name = $"<{arg.Name}>"; 309if (!string.IsNullOrEmpty(option.Name)) 311allNames.Add(option.Name); 327var longName = option.Name.StartsWith("--", StringComparison.Ordinal) 328? option.Name 329: option.Aliases.FirstOrDefault(static alias => alias.StartsWith("--", StringComparison.Ordinal)) ?? option.Name;

Commands\InitCommand.cs (1)

120using var activity = Telemetry.StartDiagnosticActivity(this.Name);

Commands\IntegrationSearchCommand.cs (1)

52using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\LogsCommand.cs (1)

144using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\LsCommand.cs (1)

73using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\NewCommand.cs (3)

301var subcommandTemplate = availableTemplates.SingleOrDefault(t => t.Name.Equals(parseResult.CommandResult.Command.Name, StringComparison.OrdinalIgnoreCase)); 309InteractionService.DisplayError($"Template '{parseResult.CommandResult.Command.Name}' is not available. Ensure the required runtime is installed."); 495using var activity = Telemetry.StartDiagnosticActivity(this.Name);

Commands\OptionWithLegacy.cs (1)

40internal string Name => InnerOption.Name;

Commands\ParseResultHelper.cs (3)

219excludedOptionNames.Add(option.Name); 416knownOptions.TryAdd(option.Name, option.Name);

Commands\PipelineCommandBase.cs (3)

183extensionInteractionService.DisplayConsolePlainText($"Detected aspire {Name} inside the Aspire extension, starting a debug session in VS Code..."); 190Command = Name, 219using var activity = Telemetry.StartDiagnosticActivity(this.Name);

Commands\PsCommand.cs (1)

108using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\ResourceCommand.cs (5)

104result.AddError(string.Format(CultureInfo.CurrentCulture, ResourceCommandStrings.ArgumentRequired, s_resourceArgument.Name)); 111result.AddError(string.Format(CultureInfo.CurrentCulture, ResourceCommandStrings.ArgumentRequired, s_commandArgument.Name)); 791if (!option.Hidden && seenOptionNames.Add(option.Name)) 802if (option.Recursive && !option.Hidden && seenOptionNames.Add(option.Name)) 837AddLongOptionName(option.Name, names);

Commands\RestoreCommand.cs (1)

66using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\RunCommand.cs (1)

1498additionalArgs.Add($"{AppHostLauncher.s_launchProfileOption.Name}={launchProfile}");

Commands\StartCommand.cs (1)

112additionalArgs.Add($"{AppHostLauncher.s_launchProfileOption.Name}={launchProfile}");

Commands\StopCommand.cs (6)

105return CommandResult.Failure(CompleteStopActivity(activity, CliExitCodes.FailedToFindProject), string.Format(CultureInfo.InvariantCulture, StopCommandStrings.AllAndProjectMutuallyExclusive, s_allOption.Name, s_appHostOption.Name)); 110return CommandResult.Failure(CompleteStopActivity(activity, CliExitCodes.InvalidCommand), string.Format(CultureInfo.InvariantCulture, StopCommandStrings.AllAndProjectMutuallyExclusive, s_allOption.Name, s_forceOption.Name)); 115return CommandResult.Failure(CompleteStopActivity(activity, CliExitCodes.InvalidCommand), string.Format(CultureInfo.InvariantCulture, StopCommandStrings.VolumesRequiresForce, s_volumesOption.Name, s_forceOption.Name)); 263InteractionService.DisplayError(string.Format(CultureInfo.InvariantCulture, StopCommandStrings.MultipleAppHostsNonInteractive, s_appHostOption.Name, s_allOption.Name));

Commands\TelemetryLogsCommand.cs (1)

81using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\TelemetrySpansCommand.cs (1)

71using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\TelemetryTracesCommand.cs (1)

70using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\TerminalAttachCommand.cs (1)

79using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\TerminalPsCommand.cs (1)

74using var activity = Telemetry.StartDiagnosticActivity(Name);

Commands\UpdateCommand.cs (1)

750var channelOptionDisplayName = $"'{_channelOption.Name}'";

Commands\WaitCommand.cs (1)

63using var activity = Telemetry.StartDiagnosticActivity(Name);

Completions\CompletionInvocation.cs (1)

53.FirstOrDefault(o => o.Name == name || o.Aliases.Contains(name));

Interaction\PromptBinding.cs (1)

161private static string FormatOptionName<T>(Option<T> option) => $"'{option.Name}'";

Packaging\PackagingService.cs (1)

258throw new PackageMetadataPrefetchingValidationException($"Command '{command.Name}' consumes template package metadata but does not enable {nameof(BaseCommand.PrefetchesTemplatePackageMetadata)}.");

Profiling\ProfileCaptureOptions.cs (3)

39var captureProfileOption = new Option<bool>(AspireRootCommand.CaptureProfileOption.Name); 40var captureProfileOutputOption = new Option<string?>(AspireRootCommand.CaptureProfileOutputOption.Name); 41var captureProfileDelayOption = new Option<int>(AspireRootCommand.CaptureProfileDelayOption.Name)

Program.cs (2)

1319var parentNames = new List<string> { r.CommandResult.Command.Name }; 1323parentNames.Add(parentCommandResult.Command.Name);

Utils\CliUpdateNotifier.cs (1)

103throw new PackageMetadataPrefetchingValidationException($"Command '{command.Name}' consumes cached CLI package metadata but does not enable {nameof(BaseCommand.PrefetchesCliPackageMetadata)}.");

Commands\ConfigCommandTests.cs (1)

677var hasDeployCommand = rootCommand.Subcommands.Any(cmd => cmd.Name == "deploy");

Commands\DoctorCommandTests.cs (1)

866Assert.DoesNotContain(command.Subcommands, subcommand => subcommand.Name == "info");

Commands\InitCommandTests.cs (3)

453Assert.True(initCommand.Options.Single(o => o.Name == "--source").Hidden); 454Assert.True(initCommand.Options.Single(o => o.Name == "--version").Hidden); 455Assert.True(initCommand.Options.Single(o => o.Name == "--channel").Hidden);

Commands\McpCommandTests.cs (14)

64var mcpCommand = rootCommand.Subcommands.FirstOrDefault(c => c.Name == "mcp"); 67Assert.Equal("mcp", mcpCommand.Name); 78var mcpCommand = rootCommand.Subcommands.FirstOrDefault(c => c.Name == "mcp"); 81var startCommand = mcpCommand.Subcommands.FirstOrDefault(c => c.Name == "start"); 83Assert.Equal("start", startCommand.Name); 94var mcpCommand = rootCommand.Subcommands.FirstOrDefault(c => c.Name == "mcp"); 165var agentCommand = rootCommand.Subcommands.FirstOrDefault(c => c.Name == "agent"); 168Assert.Equal("agent", agentCommand.Name); 180var agentCommand = rootCommand.Subcommands.FirstOrDefault(c => c.Name == "agent"); 183var mcpCommand = agentCommand.Subcommands.FirstOrDefault(c => c.Name == "mcp"); 185Assert.Equal("mcp", mcpCommand.Name); 196var agentCommand = rootCommand.Subcommands.FirstOrDefault(c => c.Name == "agent"); 199var initCommand = agentCommand.Subcommands.FirstOrDefault(c => c.Name == "init"); 201Assert.Equal("init", initCommand.Name);

Commands\NewCommandTests.cs (11)

Commands\ParseResultHelperTests.cs (1)

306Assert.Equal(string.Empty, ParseResultHelper.GetLoggableArguments(_command.Parse([_command.Name])));

Commands\RootCommandTests.cs (6)

473Assert.Equal("--banner", RootCommand.BannerOption.Name); 727var hasSetupCommand = command.Subcommands.Any(cmd => cmd.Name == "setup"); 743var hasSetupCommand = command.Subcommands.Any(cmd => cmd.Name == "setup"); 764.Select(cmd => cmd.Name) 791Assert.Contains(sub.Name, helpOutput); 804Assert.DoesNotContain(command.Subcommands, subcommand => subcommand.Name == "exec");

Commands\UpdateCommandTests.cs (1)

58var channelOption = command.Options.Single(option => option.Name == "--channel");

NuGet\NuGetPackagePrefetcherTests.cs (4)

241await AssertPrefetchingAsync(provider, command, command.Name, expectedTemplatePrefetch, expectedCliPrefetch); 258command.Name, 274await AssertPrefetchingAsync(provider, templateCommand, templateCommand.Name, expectedTemplatePrefetch: true, expectedCliPrefetch: true); 291? $"new {command.Name} --source source-feed"

parent\parent\Common\CommandLineHelpers.cs (7)

240if (optionResult is null || option.Name == "--make-repro-path") 253if (inputOptionNames.Contains(option.Name)) 263rspFile.Add($"{option.Name}:{ConvertFromOriginalPathToReproPackagePath(input: true, inputFile)}"); 271rspFile.Add($"{option.Name}:{optInList}"); 279if (outputOptionNames.Contains(option.Name)) 284rspFile.Add($"{option.Name}:{stringVal}"); 288rspFile.Add($"{option.Name}:{val}");

parent\dotnet\CliSchema.cs (6)

113name: command.Name, 133dict[argument.Name] = CreateArgumentDetails(index, argument); 145foreach (var option in options.OrderBy(o => o.Name, StringComparer.OrdinalIgnoreCase)) 147dict[option.Name] = CreateOptionDetails(option); 159foreach (var subcommand in subcommands.OrderBy(c => c.Name, StringComparer.OrdinalIgnoreCase)) 161dict[subcommand.Name] = CreateCommandDetails(subcommand);

parent\dotnet\CommandInvocation.cs (1)

59if (commandResult.Command.Name == "new")

parent\dotnet\Commands\Run\AotRunCommand.cs (1)

337fallbackReason = $"option '{unsupportedOption.Name}' is not supported by the native path";

parent\dotnet\Commands\Test\AotTestCommand.cs (1)

47&& optionResult.Option.Name == DiagnosticsOptionName);

parent\dotnet\Commands\Test\MTP\MicrosoftTestingPlatformTestCommand.Help.cs (2)

69yield return parentCommand.Name; 134var commandOptionNames = commandOptions.Select(o => o.Name.TrimStart('-')).ToHashSet(StringComparer.OrdinalIgnoreCase);

parent\dotnet\Extensions\ParseResultExtensions.cs (6)

83CommandResult commandResult => commandResult.Command.Name, 126.SkipWhile(arg => Parser.RootCommand.DiagOption.Name.Equals(arg) 228return optionResult.IdentifierToken ?? new Token($"--{optionResult.Option.Name}", TokenType.Option, optionResult.Option); 246List<string> parentNames = [parseResult.CommandResult.Command.Name]; 250parentNames.Add(parentCommandResult.Command.Name); 259parentNames.Add(optionAction.Option.Name);

parent\dotnet\Parser.cs (5)

306RootCommand.Subcommands.FirstOrDefault(c => c.Name.Equals(commandName, StringComparison.OrdinalIgnoreCase)); 500if (command.Name.Equals(ListReferenceCommandDefinition.Name)) 507if (listCommand.Arguments[i].Name == CliStrings.SolutionOrProjectArgumentName) 515else if (command.Name.Equals(AddPackageCommandDefinition.Name) || command.Name.Equals(AddCommandDefinition.Name))

parent\dotnet\Telemetry\AllowListToSendFirstAppliedOptions.cs (1)

25.Children.OfType<System.CommandLine.Parsing.CommandResult>().FirstOrDefault()?.Command.Name ?? null;

parent\dotnet\Telemetry\AllowListToSendFirstArgument.cs (3)

19System.CommandLine.Parsing.CommandResult commandResult => commandResult.Command.Name, 20OptionResult optionResult => optionResult.Option.Name, 21ArgumentResult argumentResult => argumentResult.Argument.Name,

parent\dotnet\Telemetry\TelemetryFilter.cs (2)

57topLevelCommandName = topLevelOptionAction.Option.Name; 89parseResult.CommandResult.Command.Name == "update")

parent\Microsoft.TemplateEngine.Cli\SymbolExtensions.cs (1)

20cliOption.HelpName = cliOption.Name.RemovePrefix();

CommandLine\CommandLineOptions.cs (7)

82var buildOptions = command.Options.Where(o => o.ForwardingFunction is not null && o.Name != CommonOptions.FrameworkOptionName); 228if (!command.Options.Any(option => option.Name == optionResult.Option.Name)) 288if (!seenCommand && isExplicitCommand && token == command.Name) 348=> optionResult.IdentifierToken?.Value ?? optionResult.Option.Name; 357var knownCommandsByName = dotnetDefinition.Subcommands.ToDictionary(keySelector: c => c.Name, elementSelector: c => c); 409Command = Command.Name,

CommandLine\DotnetWatchCommandDefinition.cs (11)

106v.AddError(string.Format(Resources.Cannot_specify_both_0_and_1_options, QuietOption.Name, VerboseOption.Name)); 111v.AddError(string.Format(Resources.Cannot_specify_both_0_and_1_options, QuietOption.Name, TraceOption.Name)); 116v.AddError(string.Format(Resources.Cannot_specify_both_0_and_1_options, VerboseOption.Name, TraceOption.Name)); 124v.AddError(string.Format(Resources.Cannot_specify_both_0_and_1_options, LongProjectOption.Name, ShortProjectOption.Name)); 131FileOption.Name, 132hasLongProjectOption ? LongProjectOption.Name : ShortProjectOption.Name));

parent\parent\Common\CommandLineHelpers.cs (7)

240if (optionResult is null || option.Name == "--make-repro-path") 253if (inputOptionNames.Contains(option.Name)) 263rspFile.Add($"{option.Name}:{ConvertFromOriginalPathToReproPackagePath(input: true, inputFile)}"); 271rspFile.Add($"{option.Name}:{optInList}"); 279if (outputOptionNames.Contains(option.Name)) 284rspFile.Add($"{option.Name}:{stringVal}"); 288rspFile.Add($"{option.Name}:{val}");

ForwardedOptionExtensions.cs (2)

129public Option<TValue> Forward() => option.SetForwardingFunction((TValue? o) => [option.Name]); 228(o.Name.Equals(alias) || o.Aliases.Contains(alias))

SpanParsableExtensions.cs (6)

91OptionResult optionResult => optionResult.Option.Name, 92ArgumentResult argumentResult => argumentResult.Argument.Name, 93CommandResult or null => tokenizationResult.Argument.Name, 131OptionResult optionResult => optionResult.Option.Name, 132ArgumentResult argumentResult => argumentResult.Argument.Name, 133CommandResult or null => tokenizationResult.Argument.Name,

Commands\New\CommandDefinitionExtensions.cs (2)

67var newCommandArgument = parentResult.Children.OfType<ArgumentResult>().FirstOrDefault(result => result.Argument.Name == argumentName); 94OptionResult? optionResult = parentResult.Children.OfType<OptionResult>().FirstOrDefault(result => result.Option.Name == optionName);

Commands\New\InstantiateCommandDefinition.cs (1)

32Validators.Add(symbolResult => symbolResult.ValidateOptionUsage(option.Name));

Commands\New\NewInstallCommandDefinition.cs (2)

47this.AddNoLegacyUsageValidators(isLegacy ? [InteractiveOption.Name, AddSourceOption.Name] : []);

Commands\New\NewListCommandDefinition.cs (2)

62this.AddNoLegacyUsageValidators(isLegacy ? [.. FilterOptions.AllNames, ColumnsAllOption.Name, ColumnsOption.Name, NewCommandDefinition.ShortNameArgumentName] : []);

Commands\New\NewSearchCommandDefinition.cs (2)

55this.AddNoLegacyUsageValidators(isLegacy ? [.. FilterOptions.AllNames, ColumnsAllOption.Name, ColumnsOption.Name, NewCommandDefinition.ShortNameArgumentName] : []);

Commands\New\NewUpdateCommandDefinition.cs (2)

32this.AddNoLegacyUsageValidators(isLegacy ? [InteractiveOption.Name, AddSourceOption.Name] : []);

Commands\Tool\ToolLocationOptions.cs (4)

34options.Add(GlobalOption.Name); 37if (parseResult.HasOption(LocalOption.Name)) 39options.Add(LocalOption.Name); 44options.Add(ToolPathOption.Name);

Commands\Workload\WorkloadSearchVersionsCommandDefinition.cs (2)

57result.AddError(string.Format(CommandDefinitionStrings.CannotCombineSearchStringAndVersion, Parent.WorkloadIdStubArgument.Name, Name));

Help\HelpBuilder.cs (4)

356sb.Append($"[<{argument.Name}>{arityIndicator}"); 361sb.Append($"<{argument.Name}>{arityIndicator}"); 406yield return parentCommand.Name; 512: parameter.Name;

Help\HelpBuilder.Default.cs (3)

53Argument argument => GetUsageLabel(argument.HelpName, argument.ValueType, argument.CompletionSources, argument, argument.Arity) ?? $"<{argument.Name}>", 223? new[] { symbol.Name } 224: new[] { symbol.Name }.Concat(aliasSet)

Help\LocalizationResources.cs (1)

109private static string GetOptionName(OptionResult optionResult) => optionResult.IdentifierToken?.Value ?? optionResult.Option.Name;

Utilities\OptionExtensions.cs (1)

72option.SetForwardingFunction(propertyDict => ForwardedMSBuildPropertyValues(propertyDict, option.Name));

MSBuildArgs.cs (1)

139return options.Any(o => o.Name == name) ? parseResult.GetValue<T>(name) : default;

CliTemplateParameter.cs (1)

278if (alias != option.Name)

Commands\BaseCommand.cs (2)

24: Command(definition.Name, definition.Description) 89Add(SubcommandFactories[subcommandDef.Name](hostBuilder, subcommandDef));

Commands\BaseFilterableArgs.cs (1)

55filterValues[FilterOptionDefinition.AllDefinitions[option.Name]] = value;

Commands\CommandLineUtils.cs (4)

34sb.Append($"[<{argument.Name}>{arityIndicator}"); 39sb.Append($"<{argument.Name}>{arityIndicator}"); 94sb.Append($"[<{option.Name}>{arityIndicator}"); 99sb.Append($"<{option.Name}>{arityIndicator}");

Commands\create\InstantiateCommand.cs (1)

464.SelectMany(sc => new[] { sc.Name }.Concat(sc.Aliases));

Commands\create\InstantiateCommand.Help.cs (3)

384if (!string.IsNullOrWhiteSpace(command.Name)) 386usageParts.Add(command.Name); 501yield return parentCommand.Name;

Commands\create\InstantiateCommandArgs.cs (1)

42if (s_passByOptionNames.Contains(optionResult.Option.Name))

Commands\create\TemplateCommand.cs (4)

257reporter.WriteLine(LocalizableStrings.TemplateCommand_DisplayConstraintResults_Hint, ForceOption.Name); 281reservedAliases.Add(option.Name); 299reservedAliases.Add(option.Name); 307reservedAliases.Add(subCommand.Name);

Commands\details\DetailsCommandArgs.cs (1)

14?? throw new ArgumentException($"{nameof(parseResult)} should contain one argument for {detailsCommand.Definition.NameArgument.Name}", nameof(parseResult));

Commands\Example.cs (11)

27parentCommands.Add(commandResult.Command.Name); 40parentCommands2.Add(nextCommand.Name); 78var commandParts = parseResult.Tokens.Select(t => t.Value).Prepend(parseResult.RootCommandResult.Command.Name); 102return new(currentCommand, commandParts.Add(option.Name).AddRange(args.Select(a => a.Any(char.IsWhiteSpace) ? $"'{a}'" : a))); 107return new(currentCommand, commandParts.Add(option.Name)); 110return new(currentCommand, commandParts.AddRange(option.Name, CommandLineUtils.FormatArgumentUsage(option))); 129return new(subcommand, commandParts.Add(subcommand.Name)); 135?? throw new ArgumentException($"Command {currentCommand.Name} does not have subcommand {typeof(TSubcommand).Name}"); 137return new(subcommand, commandParts.Add(subcommand.Name)); 142var subcommand = currentCommand.Subcommands.FirstOrDefault(c => c.Name.Equals(token) || c.Aliases.Contains(token)) 143?? throw new ArgumentException($"Command {currentCommand.Name} does not have subcommand '{token}'.");

Commands\install\InstallCommandArgs.cs (4)

16throw new ArgumentException($"{nameof(parseResult)} should contain at least one argument for {installCommand.Definition.NameArgument.Name}", nameof(parseResult)); 22if (installCommand is LegacyInstallCommand && (TemplatePackages.Contains(installCommand.Name) || installCommand.Aliases.Any(alias => TemplatePackages.Contains(alias)))) 24TemplatePackages = TemplatePackages.Where(package => installCommand.Name != package && !installCommand.Aliases.Contains(package)).ToList(); 29throw new ArgumentException($"{nameof(parseResult)} should contain at least one argument for {installCommand.Definition.NameArgument.Name}", nameof(parseResult));

Commands\NewCommandArgs.cs (2)

34if (!LegacyOptions.AllNames.Contains(o.Option.Name) && !s_passByOptionNames.Contains(o.Option.Name))

Commands\uninstall\UninstallCommandArgs.cs (2)

18if (uninstallCommand is LegacyUninstallCommand && (TemplatePackages.Contains(uninstallCommand.Name) || uninstallCommand.Aliases.Any(alias => TemplatePackages.Contains(alias)))) 20TemplatePackages = TemplatePackages.Where(package => uninstallCommand.Name != package && !uninstallCommand.Aliases.Contains(package)).ToList();

SymbolExtensions.cs (1)

20cliOption.HelpName = cliOption.Name.RemovePrefix();

NuGetCommands.cs (1)

29var packageCommand = command.Subcommands.FirstOrDefault(c => c.Name == "package");

Argument.cs (3)

67/// If <c>null</c>, the <see cref="Symbol.Name"/> of the argument will be used. 70/// An argument with <see cref="Symbol.Name"/> of <c>argument</c> and a 167public override string ToString() => $"{nameof(Argument)}: {Name}";

Argument{T}.cs (1)

98throw new InvalidOperationException($"Argument \"{Name}\" does not have a default value");

Binding\ArgumentConversionResult.cs (2)

50string alias = commandResult.Command.Name; 65string alias = optionResult.Option.Name;

Command.cs (4)

94/// <remarks>The collection does not contain the <see cref="Symbol.Name"/> of the Command.</remarks> 341if (identifier.Name.ContainsCaseInsensitive(textToMatch)) 343completions.Add(new CompletionItem(identifier.Name, CompletionItem.KindKeyword, detail: identifier.Description)); 361=> Name.Equals(name, StringComparison.Ordinal) || (_aliases is not null && _aliases.Contains(name));

Help\HelpBuilder.cs (4)

138yield return (parentCommand is RootCommand root ? root.HelpName : null) ?? parentCommand.Name; 303sb.Append($"[<{argument.Name}>{arityIndicator}"); 308sb.Append($"<{argument.Name}>{arityIndicator}"); 519: parameter.Name;

Help\HelpBuilder.Default.cs (4)

73Argument argument => GetUsageLabel(argument.HelpName, argument.ValueType, argument.CompletionSources, argument, argument.Arity) ?? $"<{argument.Name}>", 101return $"<{symbol.Name.TrimStart('-', '/')}>"; 137? new[] { symbol.Name } 138: new[] { symbol.Name }.Concat(aliasSet)

Invocation\ParseErrorAction.cs (2)

137return symbol.Name; 140return new[] { symbol.Name }.Concat(aliasSet)

LocalizationResources.cs (2)

58argumentResult.Argument.HelpName ?? argumentResult.Argument.Name, 257private static string GetOptionName(OptionResult optionResult) => optionResult.IdentifierToken?.Value ?? optionResult.Option.Name;

Option.cs (3)

48/// If <c>null</c>, the <see cref="Symbol.Name"/> of the option will be used, 52/// An option with <see cref="Symbol.Name"/> of <c>--option</c> and a 124/// <remarks>The collection does not contain the <see cref="Symbol.Name"/> of the Option.</remarks>

ParseResult.cs (1)

268.SelectMany(c => new[] { c.Name }.Concat(c.Aliases))

Parsing\ArgumentResult.cs (1)

142public override string ToString() => $"{nameof(ArgumentResult)} {Argument.Name}: {string.Join(" ", Tokens.Select(t => $"<{t.Value}>"))}";

Parsing\CommandResult.cs (1)

103argumentResult.AddError(LocalizationResources.RequiredOptionWasNotProvided(option.Name));

Parsing\OptionResult.cs (1)

48public override string ToString() => $"{nameof(OptionResult)}: {IdentifierToken?.Value ?? Option.Name} {string.Join(" ", Tokens.Select(t => t.Value))}";

Parsing\ParseDiagramAction.cs (2)

77builder.Append(argumentResult.Argument.Name); 142builder.Append(optionResult.IdentifierToken?.Value ?? optionResult.Option.Name);

Parsing\StringExtensions.cs (7)

55? rootCommand.Name 405var tokenString = $"[{directive.Name}]"; 463tokens.Add(cmd.Name, new Token(cmd.Name, TokenType.Command, cmd, Token.ImplicitPosition)); 476if (!tokens.ContainsKey(option.Name)) 478tokens.Add(option.Name, new Token(option.Name, TokenType.Option, option, Token.ImplicitPosition));

Parsing\SymbolResult.cs (2)

133null => Argument<T>.CreateDefaultValue() ?? throw new InvalidOperationException($"{argument.Name} is required but was not provided."), 141null => throw new InvalidOperationException($"{option.Name} is required but was not provided."),

Parsing\SymbolResultTree.cs (5)

135if (_symbolsByName!.TryGetValue(symbol.Name, out var node)) 144throw new InvalidOperationException($"Command {parent.Name} has more than one child named \"{symbol.Name}\"."); 149_symbolsByName[symbol.Name] = new(symbol, parent) 156_symbolsByName[symbol.Name] = new(symbol, parent);

RootCommand.cs (1)

46/// (when available via assembly metadata), or <c>null</c> to fall back to <see cref="Symbol.Name"/>.

Symbol.cs (1)

79public override string ToString() => $"{GetType().Name}: {Name}";

VersionOption.cs (1)

58result.AddError(LocalizationResources.VersionOptionCannotBeCombinedWithOtherArguments(result.IdentifierToken?.Value ?? result.Option.Name));

HelpGenerationExtensions.cs (8)

20null => "_" + command.Name, 21[] => "_" + command.Name, 22var names => "_" + string.Join('_', names) + "_" + command.Name 47return (option.Name, null); 55return (option.Name, [.. option.Aliases]); 68return [command.Name]; 72return [command.Name, .. command.Aliases]; 87return myOptions.Concat(c.Parents.OfType<Command>().SelectMany(OptionsForParent)).DistinctBy(o => o.Name);

shells\BashShellProvider.cs (6)

29complete -F {initialFunctionName} {command.Name} 43var completionOptions = command.HierarchicalOptions().Where(o => !o.Hidden).Select(o => o.Name).ToArray(); 44var completionSubcommands = visibleSubcommands.Select(x => x.Name).ToArray(); 104writer.WriteLine($"({subcommand.Name})"); 106writer.WriteLine($"{functionName}_{subcommand.Name} {subcommandArgument}"); 125string[] parentCommandNamesForSubcommands = [.. parentCommandNames, command.Name];

shells\FishShellProvider.cs (4)

23var safeName = command.Name.MakeSafeFunctionName(); 28writer.WriteLine($"# fish completions for {command.Name}"); 51writer.WriteLine($"complete -c {command.Name} -f -a '(_{safeName})'"); 327WriteCandidate(writer, sub.Name, SanitizeDescription(sub.Description));

shells\NuShellShellProvider.cs (1)

21var binary = command.Name;

shells\PowershellShellProvider.cs (6)

24var binaryName = command.Name; 98var verboseName = o.Name; 151null => [command.Name], 152[] => [command.Name], 153var names => [.. names, command.Name] 194var longName = subcommand.Name;

shells\ZshShellProvider.cs (11)

24var binaryName = command.Name; 27string[] pathToCurrentCommand = [command.Name]; 136writer.Write($"'{cardinality}:{arg.Name}{helpText}"); 144writer.WriteLine($"\"*::: :->{command.Name}\" \\"); 192writer.WriteLine($"({command.Name})"); 197var parentArguments = command.Parents.OfType<Command>().SelectMany(parent => parent.Arguments).Select(arg => arg.Name).ToHashSet(); 198var pos = command.Arguments.Where(a => !parentArguments.Contains(a.Name) && !a.Hidden).Count() + 1; 209writer.WriteLine($"({subcommand.Name})"); 258writer.WriteLine($"'{subcommand.Name}:{SanitizeHelp(subcommand.Description)}' \\"); 376path.Length == 0 ? [command.Name] : [.. path, command.Name];