From bcbdeb7a1a74088548bff61ad1f40d5f28e47c22 Mon Sep 17 00:00:00 2001
From: Vlada Shubina <vshubina@microsoft.com>
Date: Tue, 26 Oct 2021 11:44:37 +0200
Subject: [PATCH] removed FilterDefinition.Name

---
 .../Commands/BaseFilterableArgs.cs            | 68 +++++++++++++++++++
 .../Commands/FilterOptionDefinition.cs        | 30 ++------
 .../Commands/GlobalArgs.cs                    | 14 ----
 .../Commands/IFilterableCommand.cs            |  5 --
 .../Commands/SearchCommand.cs                 | 13 ++--
 .../TemplateSearch/CliSearchFiltersFactory.cs |  8 +--
 .../CliTemplateSearchCoordinator.cs           |  9 ++-
 .../PublicAPI.Shipped.txt                     |  4 --
 .../PublicAPI.Unshipped.txt                   |  4 ++
 .../WellKnownSearchFilters.cs                 | 12 ++--
 .../ParserTests/InstallTests.cs               |  2 +-
 .../ParserTests/SearchTests.cs                | 13 ++--
 test/dotnet-new3.UnitTests/DotnetNewSearch.cs | 36 ++++++++--
 13 files changed, 138 insertions(+), 80 deletions(-)
 create mode 100644 src/Microsoft.TemplateEngine.Cli/Commands/BaseFilterableArgs.cs

diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/BaseFilterableArgs.cs b/src/Microsoft.TemplateEngine.Cli/Commands/BaseFilterableArgs.cs
new file mode 100644
index 00000000000..cac2fd0608e
--- /dev/null
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/BaseFilterableArgs.cs
@@ -0,0 +1,68 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using System.CommandLine.Parsing;
+
+namespace Microsoft.TemplateEngine.Cli.Commands
+{
+    internal class BaseFilterableArgs : GlobalArgs
+    {
+        private IReadOnlyDictionary<FilterOptionDefinition, OptionResult> _filters;
+
+        internal BaseFilterableArgs(BaseCommand command, ParseResult parseResult) : base(command, parseResult)
+        {
+            if (command is not IFilterableCommand filterableCommand)
+            {
+                throw new ArgumentException($"{nameof(command)} should be {nameof(IFilterableCommand)}", nameof(command));
+            }
+            _filters = ParseFilters(filterableCommand, parseResult);
+        }
+
+        /// <summary>
+        /// Gets list of <see cref="FilterOptionDefinition"/> parsed from command.
+        /// </summary>
+        internal IEnumerable<FilterOptionDefinition> AppliedFilters => _filters.Keys;
+
+        /// <summary>
+        /// Gets value for filter <paramref name="filter"/>.
+        /// </summary>
+        /// <param name="filter"></param>
+        /// <returns>value of the filter.</returns>
+        /// <exception cref="ArgumentException">when <paramref name="filter"/> is not among <see cref="AppliedFilters"/>.</exception>
+        internal string GetFilterValue(FilterOptionDefinition filter)
+        {
+            if (!_filters.ContainsKey(filter))
+            {
+                throw new ArgumentException($"{nameof(filter)} is not available in parse result.", nameof(filter));
+            }
+
+            return _filters[filter].GetValueOrDefault<string>() ?? string.Empty;
+        }
+
+        /// <summary>
+        /// Gets token name used for filter <paramref name="filter"/>.
+        /// </summary>
+        /// <param name="filter"></param>
+        /// <returns>Token or null when token cannot be evaluated.</returns>
+        internal string? GetFilterToken(FilterOptionDefinition filter)
+        {
+            return _filters[filter].Token?.Value;
+        }
+
+        private static IReadOnlyDictionary<FilterOptionDefinition, OptionResult> ParseFilters(IFilterableCommand filterableCommand, ParseResult parseResult)
+        {
+            Dictionary<FilterOptionDefinition, OptionResult> filterValues = new();
+            foreach (var filter in filterableCommand.Filters)
+            {
+                OptionResult? value = parseResult.FindResultFor(filter.Value);
+                if (value != null)
+                {
+                    filterValues[filter.Key] = value;
+                }
+            }
+            return filterValues;
+        }
+    }
+}
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/FilterOptionDefinition.cs b/src/Microsoft.TemplateEngine.Cli/Commands/FilterOptionDefinition.cs
index 959f8d205c5..26608871514 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/FilterOptionDefinition.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/FilterOptionDefinition.cs
@@ -18,66 +18,52 @@ namespace Microsoft.TemplateEngine.Cli.Commands
     /// </summary>
     internal class FilterOptionDefinition
     {
-        internal FilterOptionDefinition(string name, Func<Option> optionFactory)
+        internal FilterOptionDefinition(Func<Option> optionFactory)
         {
-            Name = string.IsNullOrWhiteSpace(name) ? throw new ArgumentException($"{nameof(name)} should not be null or whitespace", nameof(name)) : name;
             OptionFactory = optionFactory ?? throw new ArgumentNullException(nameof(optionFactory));
         }
 
         internal static FilterOptionDefinition AuthorFilter { get; } =
              new TemplateFilterOptionDefinition(
-                 "author",
                  optionFactory: () => SharedOptionsFactory.CreateAuthorOption(),
                  matchFilter: authorArg => WellKnownSearchFilters.AuthorFilter(authorArg),
                  mismatchCriteria: resolutionResult => resolutionResult.HasAuthorMismatch);
 
         internal static FilterOptionDefinition BaselineFilter { get; } =
             new TemplateFilterOptionDefinition(
-                "baseline",
                 optionFactory: () => SharedOptionsFactory.CreateBaselineOption(),
                 matchFilter: baselineArg => WellKnownSearchFilters.BaselineFilter(baselineArg),
                 mismatchCriteria: resolutionResult => resolutionResult.HasBaselineMismatch);
 
         internal static FilterOptionDefinition LanguageFilter { get; } =
             new TemplateFilterOptionDefinition(
-                "language",
                 optionFactory: () => SharedOptionsFactory.CreateLanguageOption(),
                 matchFilter: languageArg => WellKnownSearchFilters.LanguageFilter(languageArg),
                 mismatchCriteria: resolutionResult => resolutionResult.HasLanguageMismatch);
 
         internal static FilterOptionDefinition TagFilter { get; } =
             new TemplateFilterOptionDefinition(
-                "tag",
                 optionFactory: () => SharedOptionsFactory.CreateTagOption(),
                 matchFilter: tagArg => WellKnownSearchFilters.ClassificationFilter(tagArg),
                 mismatchCriteria: resolutionResult => resolutionResult.HasClassificationMismatch);
 
         internal static FilterOptionDefinition TypeFilter { get; } =
             new TemplateFilterOptionDefinition(
-                "type",
                 optionFactory: () => SharedOptionsFactory.CreateTypeOption(),
                 matchFilter: typeArg => WellKnownSearchFilters.TypeFilter(typeArg),
                 mismatchCriteria: resolutionResult => resolutionResult.HasTypeMismatch);
 
         internal static FilterOptionDefinition PackageFilter { get; } =
             new PackageFilterOptionDefinition(
-                "package",
                 optionFactory: () => SharedOptionsFactory.CreatePackageOption(),
                 matchFilter: PackageMatchFilter);
 
-        //TODO: check if it's needed
-
-        /// <summary>
-        /// Name of the option, should match option long name.
-        /// </summary>
-        internal string Name { get; }
-
         /// <summary>
         /// A predicate that creates instance of option.
         /// </summary>
         internal Func<Option> OptionFactory { get; }
 
-        private static Func<ITemplatePackageInfo, bool> PackageMatchFilter(string packageArg)
+        private static Func<ITemplatePackageInfo, bool> PackageMatchFilter(string? packageArg)
         {
             return (pack) =>
             {
@@ -96,10 +82,9 @@ private static Func<ITemplatePackageInfo, bool> PackageMatchFilter(string packag
     internal class TemplateFilterOptionDefinition : FilterOptionDefinition
     {
         internal TemplateFilterOptionDefinition(
-            string name,
             Func<Option> optionFactory,
-            Func<string, Func<ITemplateInfo, MatchInfo?>> matchFilter,
-            Func<TemplateResolutionResult, bool> mismatchCriteria) : base(name, optionFactory)
+            Func<string?, Func<ITemplateInfo, MatchInfo?>> matchFilter,
+            Func<TemplateResolutionResult, bool> mismatchCriteria) : base(optionFactory)
         {
             TemplateMatchFilter = matchFilter ?? throw new ArgumentNullException(nameof(matchFilter));
             MismatchCriteria = mismatchCriteria ?? throw new ArgumentNullException(nameof(mismatchCriteria));
@@ -112,7 +97,7 @@ internal TemplateFilterOptionDefinition(
         /// <remarks>
         /// Common template match filters are defined in Microsoft.TemplateEngine.Utils.WellKnonwnSearchFilter class.
         /// </remarks>
-        internal Func<string, Func<ITemplateInfo, MatchInfo?>> TemplateMatchFilter { get; set; }
+        internal Func<string?, Func<ITemplateInfo, MatchInfo?>> TemplateMatchFilter { get; set; }
 
         /// <summary>
         /// A predicate that returns if the filter option caused a mismatch in <see cref="TemplateResolutionResult"/> in case of partial match.
@@ -126,9 +111,8 @@ internal TemplateFilterOptionDefinition(
     internal class PackageFilterOptionDefinition : FilterOptionDefinition
     {
         internal PackageFilterOptionDefinition(
-            string name,
             Func<Option> optionFactory,
-            Func<string, Func<ITemplatePackageInfo, bool>> matchFilter) : base(name, optionFactory)
+            Func<string?, Func<ITemplatePackageInfo, bool>> matchFilter) : base(optionFactory)
         {
             PackageMatchFilter = matchFilter ?? throw new ArgumentNullException(nameof(matchFilter));
         }
@@ -137,6 +121,6 @@ internal PackageFilterOptionDefinition(
         /// A predicate that returns the package match filter for the filter option
         /// Package match filter should if package is a match based on filter value.
         /// </summary>
-        internal Func<string, Func<ITemplatePackageInfo, bool>> PackageMatchFilter { get; set; }
+        internal Func<string?, Func<ITemplatePackageInfo, bool>> PackageMatchFilter { get; set; }
     }
 }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs b/src/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs
index 21b832506b3..a84a4fdae94 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs
@@ -37,20 +37,6 @@ public GlobalArgs(BaseCommand command, ParseResult parseResult)
 
         internal string? DebugCustomSettingsLocation { get; private set; }
 
-        protected static IReadOnlyDictionary<FilterOptionDefinition, string> ParseFilters(IFilterableCommand filterableCommand, ParseResult parseResult)
-        {
-            Dictionary<FilterOptionDefinition, string> filterValues = new Dictionary<FilterOptionDefinition, string>();
-            foreach (var filter in filterableCommand.Filters)
-            {
-                string? value = parseResult.GetValueForOption(filter.Value)?.ToString();
-                if (!string.IsNullOrWhiteSpace(value))
-                {
-                    filterValues[filter.Key] = value;
-                }
-            }
-            return filterValues;
-        }
-
         protected static (bool, IReadOnlyList<string>?) ParseTabularOutputSettings(ITabularOutputCommand command, ParseResult parseResult)
         {
             return (parseResult.GetValueForOption(command.ColumnsAllOption), parseResult.GetValueForOption(command.ColumnsOption));
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/IFilterableCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/IFilterableCommand.cs
index 9cc3acc7e76..7908d745ba3 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/IFilterableCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/IFilterableCommand.cs
@@ -11,9 +11,4 @@ internal interface IFilterableCommand
     {
         IReadOnlyDictionary<FilterOptionDefinition, Option> Filters { get; }
     }
-
-    internal interface IFilterableArgs
-    {
-        IReadOnlyDictionary<FilterOptionDefinition, string> Filters { get; }
-    }
 }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/SearchCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/SearchCommand.cs
index f57d00bc963..2d111ac3b15 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/SearchCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/SearchCommand.cs
@@ -123,7 +123,7 @@ protected override SearchCommandArgs ParseContext(ParseResult parseResult)
         }
     }
 
-    internal class SearchCommandArgs : GlobalArgs, IFilterableArgs, ITabularOutputArgs
+    internal class SearchCommandArgs : BaseFilterableArgs, ITabularOutputArgs
     {
         internal SearchCommandArgs(BaseSearchCommand command, ParseResult parseResult) : base(command, parseResult)
         {
@@ -141,14 +141,13 @@ internal SearchCommandArgs(BaseSearchCommand command, ParseResult parseResult) :
                     SearchNameCriteria = newCommandArgument;
                 }
             }
-
-            Filters = ParseFilters(command, parseResult);
             (DisplayAllColumns, ColumnsToDisplay) = ParseTabularOutputSettings(command, parseResult);
-            Filters.TryGetValue(FilterOptionDefinition.LanguageFilter, out string? language);
-            Language = language;
-        }
 
-        public IReadOnlyDictionary<FilterOptionDefinition, string> Filters { get; }
+            if (AppliedFilters.Contains(FilterOptionDefinition.LanguageFilter))
+            {
+                Language = GetFilterValue(FilterOptionDefinition.LanguageFilter);
+            }
+        }
 
         public bool DisplayAllColumns { get; }
 
diff --git a/src/Microsoft.TemplateEngine.Cli/TemplateSearch/CliSearchFiltersFactory.cs b/src/Microsoft.TemplateEngine.Cli/TemplateSearch/CliSearchFiltersFactory.cs
index 50927255ab9..05ec37e91e5 100644
--- a/src/Microsoft.TemplateEngine.Cli/TemplateSearch/CliSearchFiltersFactory.cs
+++ b/src/Microsoft.TemplateEngine.Cli/TemplateSearch/CliSearchFiltersFactory.cs
@@ -61,9 +61,9 @@ internal static Func<TemplatePackageSearchData, IReadOnlyList<ITemplateInfo>> Ge
                 };
 
                 IEnumerable<Func<ITemplateInfo, MatchInfo?>> templateFilters =
-                    commandArgs.Filters.Keys
+                    commandArgs.AppliedFilters
                         .OfType<TemplateFilterOptionDefinition>()
-                        .Select(filter => filter.TemplateMatchFilter(commandArgs.Filters[filter]));
+                        .Select(filter => filter.TemplateMatchFilter(commandArgs.GetFilterValue(filter)));
 
                 IEnumerable<TemplateGroupMatchInfo> matchInformation =
                     templateGroups.Select(
@@ -87,9 +87,9 @@ internal Func<TemplatePackageSearchData, bool> GetPackFilter(SearchCommandArgs c
             return templatePackageSearchData =>
             {
                 return AlreadyInstalledFilter(templatePackageSearchData)
-                && commandArgs.Filters.Keys
+                && commandArgs.AppliedFilters
                         .OfType<PackageFilterOptionDefinition>()
-                        .All(packFilter => packFilter.PackageMatchFilter(commandArgs.Filters[packFilter])(templatePackageSearchData));
+                        .All(filter => filter.PackageMatchFilter(commandArgs.GetFilterValue(filter))(templatePackageSearchData));
             };
         }
 
diff --git a/src/Microsoft.TemplateEngine.Cli/TemplateSearch/CliTemplateSearchCoordinator.cs b/src/Microsoft.TemplateEngine.Cli/TemplateSearch/CliTemplateSearchCoordinator.cs
index d19a79e7ac5..261edc4e047 100644
--- a/src/Microsoft.TemplateEngine.Cli/TemplateSearch/CliTemplateSearchCoordinator.cs
+++ b/src/Microsoft.TemplateEngine.Cli/TemplateSearch/CliTemplateSearchCoordinator.cs
@@ -172,12 +172,12 @@ private static IReadOnlyCollection<SearchResultTableRow> GetSearchResultsForDisp
 
         private static bool ValidateCommandInput(SearchCommandArgs commandArgs)
         {
-            if (string.IsNullOrWhiteSpace(commandArgs.SearchNameCriteria) && !commandArgs.Filters.Any())
+            if (string.IsNullOrWhiteSpace(commandArgs.SearchNameCriteria) && !commandArgs.AppliedFilters.Any())
             //TODO: implement it for template options matching
             // && !commandInput.RemainingParameters.Any())
             {
                 Reporter.Error.WriteLine(LocalizableStrings.CliTemplateSearchCoordinator_Error_NoTemplateName.Red().Bold());
-                Reporter.Error.WriteLine(string.Format(LocalizableStrings.CliTemplateSearchCoordinator_Info_SearchHelp, string.Join(", ", SearchCommand.SupportedFilters.Select(f => $"'{f.Name}'"))));
+                Reporter.Error.WriteLine(string.Format(LocalizableStrings.CliTemplateSearchCoordinator_Info_SearchHelp, string.Join(", ", SearchCommand.SupportedFilters.Select(f => $"'{f.OptionFactory().Aliases.First()}'"))));
                 Reporter.Error.WriteLine(LocalizableStrings.Generic_ExamplesHeader);
                 Reporter.Error.WriteCommand(CommandExamples.SearchCommandExample(commandArgs.CommandName, usePlaceholder: true));
                 Reporter.Error.WriteCommand(CommandExamples.SearchCommandExample(commandArgs.CommandName, additionalArgs: new[] { "--author", "Microsoft" }));
@@ -197,9 +197,8 @@ private static bool ValidateCommandInput(SearchCommandArgs commandArgs)
         private static string GetInputParametersString(SearchCommandArgs commandArgs/*, IReadOnlyDictionary<string, string?>? templateParameters = null*/)
         {
             string separator = ", ";
-            IEnumerable<string> appliedFilters = commandArgs
-                .Filters
-                .Select(filter => $"{filter.Key.Name}='{filter.Value}'");
+            IEnumerable<string> appliedFilters = commandArgs.AppliedFilters
+                .Select(filter => $"{commandArgs.GetFilterToken(filter)}='{commandArgs.GetFilterValue(filter)}'");
 
             //TODO: implement it for template options matching
             //IEnumerable<string> appliedTemplateParameters = templateParameters?
diff --git a/src/Microsoft.TemplateEngine.Utils/PublicAPI.Shipped.txt b/src/Microsoft.TemplateEngine.Utils/PublicAPI.Shipped.txt
index 0abae3ae384..214f0f4ef57 100644
--- a/src/Microsoft.TemplateEngine.Utils/PublicAPI.Shipped.txt
+++ b/src/Microsoft.TemplateEngine.Utils/PublicAPI.Shipped.txt
@@ -158,10 +158,6 @@ static Microsoft.TemplateEngine.Utils.TemplateMatchInfoExtensions.HasShortNamePa
 static Microsoft.TemplateEngine.Utils.TemplateMatchInfoExtensions.HasTypeMatch(this Microsoft.TemplateEngine.Abstractions.TemplateFiltering.ITemplateMatchInfo! templateMatchInfo) -> bool
 static Microsoft.TemplateEngine.Utils.TemplateMatchInfoExtensions.HasTypeMismatch(this Microsoft.TemplateEngine.Abstractions.TemplateFiltering.ITemplateMatchInfo! templateMatchInfo) -> bool
 static Microsoft.TemplateEngine.Utils.TemplateParameterExtensions.IsChoice(this Microsoft.TemplateEngine.Abstractions.ITemplateParameter! parameter) -> bool
-static Microsoft.TemplateEngine.Utils.WellKnownSearchFilters.AuthorFilter(string! author) -> System.Func<Microsoft.TemplateEngine.Abstractions.ITemplateInfo!, Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo?>!
-static Microsoft.TemplateEngine.Utils.WellKnownSearchFilters.BaselineFilter(string! baselineName) -> System.Func<Microsoft.TemplateEngine.Abstractions.ITemplateInfo!, Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo?>!
-static Microsoft.TemplateEngine.Utils.WellKnownSearchFilters.ClassificationFilter(string! classification) -> System.Func<Microsoft.TemplateEngine.Abstractions.ITemplateInfo!, Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo?>!
-static Microsoft.TemplateEngine.Utils.WellKnownSearchFilters.LanguageFilter(string! language) -> System.Func<Microsoft.TemplateEngine.Abstractions.ITemplateInfo!, Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo?>!
 static Microsoft.TemplateEngine.Utils.WellKnownSearchFilters.MatchesAllCriteria.get -> System.Func<Microsoft.TemplateEngine.Abstractions.TemplateFiltering.ITemplateMatchInfo!, bool>!
 static Microsoft.TemplateEngine.Utils.WellKnownSearchFilters.MatchesAtLeastOneCriteria.get -> System.Func<Microsoft.TemplateEngine.Abstractions.TemplateFiltering.ITemplateMatchInfo!, bool>!
 static Microsoft.TemplateEngine.Utils.WellKnownSearchFilters.NameFilter(string! name) -> System.Func<Microsoft.TemplateEngine.Abstractions.ITemplateInfo!, Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo?>!
diff --git a/src/Microsoft.TemplateEngine.Utils/PublicAPI.Unshipped.txt b/src/Microsoft.TemplateEngine.Utils/PublicAPI.Unshipped.txt
index dfb6fa54bfb..dcaa2f4a022 100644
--- a/src/Microsoft.TemplateEngine.Utils/PublicAPI.Unshipped.txt
+++ b/src/Microsoft.TemplateEngine.Utils/PublicAPI.Unshipped.txt
@@ -4,3 +4,7 @@ Microsoft.TemplateEngine.Utils.AsyncMutex.IsLocked.get -> bool
 Microsoft.TemplateEngine.Utils.IFileSystemInfoExtensions
 static Microsoft.TemplateEngine.Utils.AsyncMutex.WaitAsync(string! mutexName, System.Threading.CancellationToken token) -> System.Threading.Tasks.Task<Microsoft.TemplateEngine.Utils.AsyncMutex!>!
 static Microsoft.TemplateEngine.Utils.IFileSystemInfoExtensions.GetDisplayPath(this Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo! fileSystemInfo) -> string!
+static Microsoft.TemplateEngine.Utils.WellKnownSearchFilters.AuthorFilter(string? author) -> System.Func<Microsoft.TemplateEngine.Abstractions.ITemplateInfo!, Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo?>!
+static Microsoft.TemplateEngine.Utils.WellKnownSearchFilters.BaselineFilter(string? baselineName) -> System.Func<Microsoft.TemplateEngine.Abstractions.ITemplateInfo!, Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo?>!
+static Microsoft.TemplateEngine.Utils.WellKnownSearchFilters.ClassificationFilter(string? classification) -> System.Func<Microsoft.TemplateEngine.Abstractions.ITemplateInfo!, Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo?>!
+static Microsoft.TemplateEngine.Utils.WellKnownSearchFilters.LanguageFilter(string? language) -> System.Func<Microsoft.TemplateEngine.Abstractions.ITemplateInfo!, Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo?>!
diff --git a/src/Microsoft.TemplateEngine.Utils/WellKnownSearchFilters.cs b/src/Microsoft.TemplateEngine.Utils/WellKnownSearchFilters.cs
index b3ac74297be..16516136db2 100644
--- a/src/Microsoft.TemplateEngine.Utils/WellKnownSearchFilters.cs
+++ b/src/Microsoft.TemplateEngine.Utils/WellKnownSearchFilters.cs
@@ -116,7 +116,7 @@ public static class WellKnownSearchFilters
         /// - adds match disposition <see cref="MatchInfo.BuiltIn.Classification"/> with <see cref="MatchKind.Mismatch"/> otherwise.<br/>
         /// </summary>
         /// <returns> the predicate to be used when filtering the templates..</returns>
-        public static Func<ITemplateInfo, MatchInfo?> ClassificationFilter(string classification)
+        public static Func<ITemplateInfo, MatchInfo?> ClassificationFilter(string? classification)
         {
             return (template) =>
             {
@@ -139,7 +139,7 @@ public static class WellKnownSearchFilters
         /// - adds match disposition <see cref="MatchInfo.BuiltIn.Language"/> with <see cref="MatchKind.Mismatch"/> otherwise.<br/>
         /// </summary>
         /// <returns> the predicate to be used when filtering the templates.</returns>
-        public static Func<ITemplateInfo, MatchInfo?> LanguageFilter(string language)
+        public static Func<ITemplateInfo, MatchInfo?> LanguageFilter(string? language)
         {
             return (template) =>
             {
@@ -166,7 +166,7 @@ public static class WellKnownSearchFilters
         /// - adds match disposition <see cref="MatchInfo.BuiltIn.Baseline"/> with <see cref="MatchKind.Mismatch"/> otherwise.<br/>
         /// </summary>
         /// <returns> the predicate to be used when filtering the templates.</returns>
-        public static Func<ITemplateInfo, MatchInfo?> BaselineFilter(string baselineName)
+        public static Func<ITemplateInfo, MatchInfo?> BaselineFilter(string? baselineName)
         {
             return (template) =>
             {
@@ -175,7 +175,7 @@ public static class WellKnownSearchFilters
                     return null;
                 }
 
-                if (template.BaselineInfo != null && template.BaselineInfo.ContainsKey(baselineName))
+                if (template.BaselineInfo != null && template.BaselineInfo.ContainsKey(baselineName!))
                 {
                     return new MatchInfo(MatchInfo.BuiltIn.Baseline, baselineName, MatchKind.Exact);
                 }
@@ -195,7 +195,7 @@ public static class WellKnownSearchFilters
         /// - <see cref="MatchInfo.BuiltIn.Author"/> with <see cref="MatchKind.Mismatch"/> otherwise.<br/>
         /// </summary>
         /// <returns> the predicate to be used when filtering the templates.</returns>
-        public static Func<ITemplateInfo, MatchInfo?> AuthorFilter(string author)
+        public static Func<ITemplateInfo, MatchInfo?> AuthorFilter(string? author)
         {
             return (template) =>
             {
@@ -211,7 +211,7 @@ public static class WellKnownSearchFilters
 
                 int authorIndex = template.Author!.IndexOf(author, StringComparison.OrdinalIgnoreCase);
 
-                if (authorIndex == 0 && template.Author.Length == author.Length)
+                if (authorIndex == 0 && template.Author.Length == author!.Length)
                 {
                     return new MatchInfo(MatchInfo.BuiltIn.Author, author, MatchKind.Exact);
                 }
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs
index 9c0ace04440..b76bbd4d0c8 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs
@@ -188,7 +188,7 @@ public void Install_CanReturnParseError_OnLegacyOptionMisplacement(string option
 
             Assert.NotEmpty(parseResult.Errors);
             Assert.Single(parseResult.Errors);
-            Assert.Contains($"Option '{expectedOptionName}' should be used after 'install'.", parseResult.Errors.Select(error => error.Message));
+            Assert.Contains($"Invalid command syntax: option '{expectedOptionName}' should be used after 'install'.", parseResult.Errors.Select(error => error.Message));
         }
 
     }
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs
index 0eb3c17954c..2b717b93e83 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs
@@ -4,6 +4,7 @@
 #nullable enable
 
 using System.CommandLine;
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 using Microsoft.TemplateEngine.Cli.Commands;
 using Microsoft.TemplateEngine.TestHelper;
@@ -69,9 +70,8 @@ public void Search_CanParseFilterOption(string command, string expectedFilter)
             var parseResult = myCommand.Parse(command);
             SearchCommandArgs args = new SearchCommandArgs((BaseSearchCommand)parseResult.CommandResult.Command, parseResult);
 
-            Assert.Single(args.Filters);
-            Assert.True(args.Filters.TryGetValue(expectedDef, out string? filterValue));
-            Assert.Contains("filter-value", filterValue);
+            Assert.Single(args.AppliedFilters);
+            Assert.Contains("filter-value", args.GetFilterValue(expectedDef));
             Assert.Equal("source", args.SearchNameCriteria);
         }
 
@@ -104,9 +104,8 @@ public void Search_CanParseFilterOptionWithoutMainCriteria(string command, strin
             var parseResult = myCommand.Parse(command);
             SearchCommandArgs args = new SearchCommandArgs((BaseSearchCommand)parseResult.CommandResult.Command, parseResult);
 
-            Assert.Single(args.Filters);
-            Assert.True(args.Filters.TryGetValue(expectedDef, out string? filterValue));
-            Assert.Contains("filter-value", filterValue);
+            Assert.Single(args.AppliedFilters);
+            Assert.Contains("filter-value", args.GetFilterValue(expectedDef));
             Assert.Null(args.SearchNameCriteria);
         }
 
@@ -151,7 +150,7 @@ public void Search_CannotParseOptionsAtNewLevel(string command, string expectedF
             var parseResult = myCommand.Parse(command);
 
             Assert.NotEmpty(parseResult.Errors);
-            Assert.Equal($"Option '{expectedFilter}' should be used after 'search'.", parseResult.Errors.First().Message);
+            Assert.Equal($"Invalid command syntax: option '{expectedFilter}' should be used after 'search'.", parseResult.Errors.First().Message);
         }
 
         [Fact]
diff --git a/test/dotnet-new3.UnitTests/DotnetNewSearch.cs b/test/dotnet-new3.UnitTests/DotnetNewSearch.cs
index cf92e4426a4..ba148dbba87 100644
--- a/test/dotnet-new3.UnitTests/DotnetNewSearch.cs
+++ b/test/dotnet-new3.UnitTests/DotnetNewSearch.cs
@@ -35,6 +35,7 @@ public void BasicTest(string testCase)
                 .And.NotHaveStdErr()
                 .And.HaveStdOutContaining("Searching for the templates...")
                 .And.HaveStdOutContaining("Matches from template source: NuGet.org")
+                .And.HaveStdOutContaining("These templates matched your input: 'console'")
                 .And.HaveStdOutMatching("Template Name\\s+Short Name\\s+Author\\s+Language\\s+Package\\s+Downloads")
                 .And.HaveStdOutContaining("To use the template, run the following command to install the package:")
                 .And.HaveStdOutContaining("   dotnet new3 --install <PACKAGE_ID>");
@@ -60,7 +61,7 @@ public void CannotExecuteEmptyCriteria(string testCase)
                 .And.NotHaveStdOut()
                 .And.HaveStdErrContaining(
 @"Search failed: not enough information specified for search.
-To search for templates, specify partial template name or use one of supported filters: 'author', 'baseline', 'language', 'type', 'tag', 'package'.
+To search for templates, specify partial template name or use one of supported filters: '--author', '--baseline', '--language', '--type', '--tag', '--package'.
 Examples:
    dotnet new3 <TEMPLATE_NAME> --search
    dotnet new3 --search --author Microsoft
@@ -80,6 +81,21 @@ public void CannotExecuteSearchWithShortCriteria(string testCase)
                 .And.HaveStdErrContaining("Search failed: template name is too short, minimum 2 characters are required.");
         }
 
+        [Theory]
+        [InlineData("--search fofofo", "'fofofo'")]
+        [InlineData("search fofofo", "'fofofo'")]
+        [InlineData("search fofofo --type item", "'fofofo', --type='item'")]
+        [InlineData("search fofofo --language Z#", "'fofofo', --language='Z#'")]
+        [InlineData("search -lang Z#", "-lang='Z#'")]
+        public void CanDisplayNoResults(string testCase, string criteria)
+        {
+            new DotnetNewCommand(_log, testCase.Split(" "))
+                .WithCustomHive(_sharedHome.HomeDirectory)
+                .Execute()
+                .Should().Fail()
+                .And.HaveStdErrContaining($"No templates found matching: {criteria}.");
+        }
+
         [Theory]
         [InlineData("azure --search")]
         [InlineData("--search azure")]
@@ -151,6 +167,7 @@ public void CanFilterTags(string testCase)
                 .And.NotHaveStdErr()
                 .And.HaveStdOutContaining("Searching for the templates...")
                 .And.HaveStdOutContaining("Matches from template source: NuGet.org")
+                .And.HaveStdOutContaining("These templates matched your input: 'console', --tag='Common'")
                 .And.HaveStdOutMatching("Template Name\\s+Short Name\\s+Tags\\s+Package\\s+Downloads")
                 .And.HaveStdOutContaining("To use the template, run the following command to install the package:")
                 .And.HaveStdOutContaining("   dotnet new3 --install <PACKAGE_ID>");
@@ -181,6 +198,7 @@ public void CanFilterTags_WithoutName(string testCase)
                 .And.NotHaveStdErr()
                 .And.HaveStdOutContaining("Searching for the templates...")
                 .And.HaveStdOutContaining("Matches from template source: NuGet.org")
+                .And.HaveStdOutContaining("These templates matched your input: --tag='Common'")
                 .And.HaveStdOutMatching("Template Name\\s+Short Name\\s+Tags\\s+Package\\s+Downloads")
                 .And.HaveStdOutContaining("To use the template, run the following command to install the package:")
                 .And.HaveStdOutContaining("   dotnet new3 --install <PACKAGE_ID>");
@@ -210,6 +228,7 @@ public void CanFilterAuthor(string testCase)
                 .And.NotHaveStdErr()
                 .And.HaveStdOutContaining("Searching for the templates...")
                 .And.HaveStdOutContaining("Matches from template source: NuGet.org")
+                .And.HaveStdOutContaining("These templates matched your input: 'func', --author='micro'")
                 .And.HaveStdOutMatching("Template Name\\s+Short Name\\s+Author\\s+Package\\s+Downloads")
                 .And.HaveStdOutContaining("To use the template, run the following command to install the package:")
                 .And.HaveStdOutContaining("   dotnet new3 --install <PACKAGE_ID>");
@@ -239,6 +258,7 @@ public void CanFilterAuthor_WithoutName(string testCase)
                 .ExitWith(0)
                 .And.NotHaveStdErr()
                 .And.HaveStdOutContaining("Searching for the templates...")
+                .And.HaveStdOutContaining("These templates matched your input: --author='micro'")
                 .And.HaveStdOutContaining("Matches from template source: NuGet.org")
                 .And.HaveStdOutMatching("Template Name\\s+Short Name\\s+Author\\s+Package\\s+Downloads")
                 .And.HaveStdOutContaining("To use the template, run the following command to install the package:")
@@ -268,6 +288,7 @@ public void CanFilterLanguage(string testCase)
                 .ExitWith(0)
                 .And.NotHaveStdErr()
                 .And.HaveStdOutContaining("Searching for the templates...")
+                .And.HaveStdOutContaining("These templates matched your input: 'console', --language='Q#'")
                 .And.HaveStdOutContaining("Matches from template source: NuGet.org")
                 .And.HaveStdOutMatching("Template Name\\s+Short Name\\s+Language\\s+Package\\s+Downloads")
                 .And.HaveStdOutContaining("To use the template, run the following command to install the package:")
@@ -286,9 +307,11 @@ public void CanFilterLanguage(string testCase)
         }
 
         [Theory]
-        [InlineData("--search --columns language --language Q#")]
-        [InlineData("search --columns language --language Q#")]
-        public void CanFilterLanguage_WithoutName(string testCase)
+        [InlineData("--search --columns language --language Q#", "--language")]
+        [InlineData("search --columns language --language Q#", "--language")]
+        [InlineData("--search --columns language -lang Q#", "-lang")]
+        [InlineData("search --columns language -lang Q#", "-lang")]
+        public void CanFilterLanguage_WithoutName(string testCase, string optionName)
         {
             var commandResult = new DotnetNewCommand(_log, testCase.Split(" "))
                 .WithCustomHive(_sharedHome.HomeDirectory)
@@ -298,6 +321,7 @@ public void CanFilterLanguage_WithoutName(string testCase)
                 .ExitWith(0)
                 .And.NotHaveStdErr()
                 .And.HaveStdOutContaining("Searching for the templates...")
+                .And.HaveStdOutContaining($"These templates matched your input: {optionName}='Q#'")
                 .And.HaveStdOutContaining("Matches from template source: NuGet.org")
                 .And.HaveStdOutMatching("Template Name\\s+Short Name\\s+Language\\s+Package\\s+Downloads")
                 .And.HaveStdOutContaining("To use the template, run the following command to install the package:")
@@ -327,6 +351,7 @@ public void CanFilterType(string testCase)
                 .ExitWith(0)
                 .And.NotHaveStdErr()
                 .And.HaveStdOutContaining("Searching for the templates...")
+                .And.HaveStdOutContaining("These templates matched your input: 'console', --type='item'")
                 .And.HaveStdOutContaining("Matches from template source: NuGet.org")
                 .And.HaveStdOutMatching("Template Name\\s+Short Name\\s+Type\\s+Package\\s+Downloads")
                 .And.HaveStdOutContaining("To use the template, run the following command to install the package:")
@@ -357,6 +382,7 @@ public void CanFilterType_WithoutName(string testCase)
                 .ExitWith(0)
                 .And.NotHaveStdErr()
                 .And.HaveStdOutContaining("Searching for the templates...")
+                .And.HaveStdOutContaining("These templates matched your input: --type='item'")
                 .And.HaveStdOutContaining("Matches from template source: NuGet.org")
                 .And.HaveStdOutMatching("Template Name\\s+Short Name\\s+Type\\s+Package\\s+Downloads")
                 .And.HaveStdOutContaining("To use the template, run the following command to install the package:")
@@ -386,6 +412,7 @@ public void CanFilterPackage(string testCase)
                 .ExitWith(0)
                 .And.NotHaveStdErr()
                 .And.HaveStdOutContaining("Searching for the templates...")
+                .And.HaveStdOutContaining("These templates matched your input: 'console', --package='core'")
                 .And.HaveStdOutContaining("Matches from template source: NuGet.org")
                 .And.HaveStdOutMatching("Template Name\\s+Short Name\\s+Author\\s+Language\\s+Package\\s+Downloads")
                 .And.HaveStdOutContaining("To use the template, run the following command to install the package:")
@@ -415,6 +442,7 @@ public void CanFilterPackage_WithoutName(string testCase)
                 .ExitWith(0)
                 .And.NotHaveStdErr()
                 .And.HaveStdOutContaining("Searching for the templates...")
+                .And.HaveStdOutContaining("These templates matched your input: --package='core'")
                 .And.HaveStdOutContaining("Matches from template source: NuGet.org")
                 .And.HaveStdOutMatching("Template Name\\s+Short Name\\s+Author\\s+Language\\s+Package\\s+Downloads")
                 .And.HaveStdOutContaining("To use the template, run the following command to install the package:")