support for specifying the type of the search directly in the textbox (t: for type, m: for member and c: for constant)

for instance, t:MyType will search for types matching "MyType"  (match behavior did not change)

ILSpy/SearchPane.cs

@@ -20,7 +20,6 @@ using System;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.ComponentModel;
-using System.IO;
 using System.Threading;
 using System.Windows;
 using System.Windows.Controls;
@@ -53,9 +52,9 @@ namespace ICSharpCode.ILSpy
 			}
 		}
 		
-		const int SearchMode_Type = 0;
+		public const int SearchMode_Type = 0;
-		const int SearchMode_Member = 1;
+		public const int SearchMode_Member = 1;
-		const int SearchMode_Literal = 2;
+		public const int SearchMode_Literal = 2;
 		
 		private SearchPane()
 		{
@@ -184,6 +183,11 @@ namespace ICSharpCode.ILSpy
 			}
 		}
 
+		internal interface ISearch
+		{
+			void Search(TypeDefinition type, Language language, Action<SearchResult> addResult);
+		}
+
 		sealed class RunningSearch
 		{
 			readonly Dispatcher dispatcher;
@@ -195,9 +199,6 @@ namespace ICSharpCode.ILSpy
 			public readonly ObservableCollection<SearchResult> Results = new ObservableCollection<SearchResult>();
 			int resultCount;
 			
-			TypeCode searchTermLiteralType = TypeCode.Empty;
-			object searchTermLiteralValue;
-			
 			public RunningSearch(LoadedAssembly[] assemblies, string searchTerm, int searchMode, Language language)
 			{
 				this.dispatcher = Dispatcher.CurrentDispatcher;
@@ -217,44 +218,17 @@ namespace ICSharpCode.ILSpy
 			public void Run()
 			{
 				try {
-					if (searchMode == SearchMode_Literal) {
+					var searcher = ResolveSearcher(searchMode, searchTerm);
-			      if (1 == searchTerm.Length)
+					foreach (var loadedAssembly in assemblies)
 					{
-  						CSharpParser parser = new CSharpParser();
-  						PrimitiveExpression pe = parser.ParseExpression(searchTerm[0]) as PrimitiveExpression;
-  						if (pe != null && pe.Value != null) {
-  							TypeCode peValueType = Type.GetTypeCode(pe.Value.GetType());
-  							switch (peValueType) {
-  								case TypeCode.Byte:
-  								case TypeCode.SByte:
-  								case TypeCode.Int16:
-  								case TypeCode.UInt16:
-  								case TypeCode.Int32:
-  								case TypeCode.UInt32:
-  								case TypeCode.Int64:
-  								case TypeCode.UInt64:
-  									searchTermLiteralType = TypeCode.Int64;
-  									searchTermLiteralValue = CSharpPrimitiveCast.Cast(TypeCode.Int64, pe.Value, false);
-  									break;
-  								case TypeCode.Single:
-  								case TypeCode.Double:
-  								case TypeCode.String:
-  									searchTermLiteralType = peValueType;
-  									searchTermLiteralValue = pe.Value;
-  									break;
-  							}
-						  }
-						}
-					}
-					
-					foreach (var loadedAssembly in assemblies) {
 						ModuleDefinition module = loadedAssembly.ModuleDefinition;
 						if (module == null)
 							continue;
 						CancellationToken cancellationToken = cts.Token;
+
 						foreach (TypeDefinition type in module.Types) {
 							cancellationToken.ThrowIfCancellationRequested();
-							PerformSearch(type);
+							searcher.Search(type, language, AddResult);
 						}
 					}
 				} catch (OperationCanceledException) {
@@ -278,126 +252,117 @@ namespace ICSharpCode.ILSpy
 				cts.Token.ThrowIfCancellationRequested();
 			}
 		
-			bool IsMatch(string text)
+			private ISearch ResolveSearcher(int mode, string[] terms)
 			{
-			  for (int i = 0; i < searchTerm.Length; ++i) {
+				if (terms.Length == 1)
-			    // How to handle overlapping matches?
+				{
-			    if (text.IndexOf(searchTerm[i], StringComparison.OrdinalIgnoreCase) < 0)
+					if (terms[0].StartsWith("t:"))
-			      return false;
+						return new TypeSearcher(terms);
-			  }
+
-  			return true;
+					if (terms[0].StartsWith("m:"))
+						return new MemberSearcher(terms);
+					
+					if (terms[0].StartsWith("c:"))
+						return new LiteralSearcher(terms);
 				}
 
-			void PerformSearch(TypeDefinition type)
+				switch (mode)
 				{
-				if (searchMode == SearchMode_Type && IsMatch(type.Name)) {
+					case SearchMode_Type:		return new TypeSearcher(terms);
-					AddResult(new SearchResult {
+					case SearchMode_Member:		return new MemberSearcher(terms);
-					          	Member = type,
+					case SearchMode_Literal:	return new LiteralSearcher(terms);
-					          	Image = TypeTreeNode.GetIcon(type),
-					          	Name = language.TypeToString(type, includeNamespace: false),
-					          	LocationImage = type.DeclaringType != null ? TypeTreeNode.GetIcon(type.DeclaringType) : Images.Namespace,
-					          	Location = type.DeclaringType != null ? language.TypeToString(type.DeclaringType, includeNamespace: true) : type.Namespace
-					          });
 				}
 
-				foreach (TypeDefinition nestedType in type.NestedTypes) {
+				return null;
-					PerformSearch(nestedType);
 			}			
-				
-				if (searchMode == SearchMode_Type)
-					return;
-				
-				foreach (FieldDefinition field in type.Fields) {
-					if (IsMatch(field)) {
-						AddResult(new SearchResult {
-						          	Member = field,
-						          	Image = FieldTreeNode.GetIcon(field),
-						          	Name = field.Name,
-						          	LocationImage = TypeTreeNode.GetIcon(type),
-						          	Location = language.TypeToString(type, includeNamespace: true)
-						          });
 		}
+
+		internal sealed class SearchResult : INotifyPropertyChanged, IMemberTreeNode
+		{
+			event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged {
+				add { }
+				remove { }
 			}
-				foreach (PropertyDefinition property in type.Properties) {
+			
-					if (IsMatch(property)) {
+			public MemberReference Member { get; set; }
-						AddResult(new SearchResult {
+			
-						          	Member = property,
+			public string Location { get; set; }
-						          	Image = PropertyTreeNode.GetIcon(property),
+			public string Name { get; set; }
-						          	Name = property.Name,
+			public ImageSource Image { get; set; }
-						          	LocationImage = TypeTreeNode.GetIcon(type),
+			public ImageSource LocationImage { get; set; }
-						          	Location = language.TypeToString(type, includeNamespace: true)
+			
-						          });
+			public override string ToString()
-					}
+			{
+				return Name;
 			}
-				foreach (EventDefinition ev in type.Events) {
-					if (IsMatch(ev)) {
-						AddResult(new SearchResult {
-						          	Member = ev,
-						          	Image = EventTreeNode.GetIcon(ev),
-						          	Name = ev.Name,
-						          	LocationImage = TypeTreeNode.GetIcon(type),
-						          	Location = language.TypeToString(type, includeNamespace: true)
-						          });
 		}
 	}
-				foreach (MethodDefinition method in type.Methods) {
+
-					switch (method.SemanticsAttributes) {
+	internal class LiteralSearcher : SearcherBase
-						case MethodSemanticsAttributes.Setter:
+	{
-						case MethodSemanticsAttributes.Getter:
+		private readonly TypeCode searchTermLiteralType;
-						case MethodSemanticsAttributes.AddOn:
+		private readonly object searchTermLiteralValue;
-						case MethodSemanticsAttributes.RemoveOn:
+
-						case MethodSemanticsAttributes.Fire:
+		public LiteralSearcher(string[] terms) : base(terms)
-							continue;
+		{
+			if (1 == searchTerm.Length)
+			{
+				var parser = new CSharpParser();
+				var pe = parser.ParseExpression(searchTerm[0]) as PrimitiveExpression;
+				
+				if (pe != null && pe.Value != null)
+				{
+					TypeCode peValueType = Type.GetTypeCode(pe.Value.GetType());
+					switch (peValueType)
+					{
+						case TypeCode.Byte:
+						case TypeCode.SByte:
+						case TypeCode.Int16:
+						case TypeCode.UInt16:
+						case TypeCode.Int32:
+						case TypeCode.UInt32:
+						case TypeCode.Int64:
+						case TypeCode.UInt64:
+							searchTermLiteralType = TypeCode.Int64;
+							searchTermLiteralValue = CSharpPrimitiveCast.Cast(TypeCode.Int64, pe.Value, false);
+							break;
+						case TypeCode.Single:
+						case TypeCode.Double:
+						case TypeCode.String:
+							searchTermLiteralType = peValueType;
+							searchTermLiteralValue = pe.Value;
+							break;
 					}
-					if (IsMatch(method)) {
-						AddResult(new SearchResult {
-						          	Member = method,
-						          	Image = MethodTreeNode.GetIcon(method),
-						          	Name = method.Name,
-						          	LocationImage = TypeTreeNode.GetIcon(type),
-						          	Location = language.TypeToString(type, includeNamespace: true)
-						          });
 				}
 			}
 		}
 
-			bool IsMatch(FieldDefinition field)
+		protected override bool IsMatch(FieldDefinition field)
 		{
-				if (searchMode == SearchMode_Literal)
 			return IsLiteralMatch(field.Constant);
-				else
-					return IsMatch(field.Name);
 		}
 
-			bool IsMatch(PropertyDefinition property)
+		protected override bool IsMatch(PropertyDefinition property)
 		{
-				if (searchMode == SearchMode_Literal)
 			return MethodIsLiteralMatch(property.GetMethod) || MethodIsLiteralMatch(property.SetMethod);
-				else
-					return IsMatch(property.Name);
 		}
 
-			bool IsMatch(EventDefinition ev)
+		protected override bool IsMatch(EventDefinition ev)
 		{
-				if (searchMode == SearchMode_Literal)
 			return MethodIsLiteralMatch(ev.AddMethod) || MethodIsLiteralMatch(ev.RemoveMethod) || MethodIsLiteralMatch(ev.InvokeMethod);
-				else
-					return IsMatch(ev.Name);
 		}
 
-			bool IsMatch(MethodDefinition m)
+		protected override bool IsMatch(MethodDefinition m)
 		{
-				if (searchMode == SearchMode_Literal)
 			return MethodIsLiteralMatch(m);
-				else
-					return IsMatch(m.Name);
 		}
 
 		bool IsLiteralMatch(object val)
 		{
 			if (val == null)
 				return false;
-				switch (searchTermLiteralType) {
+			switch (searchTermLiteralType)
+			{
 				case TypeCode.Int64:
 					TypeCode tc = Type.GetTypeCode(val.GetType());
 					if (tc >= TypeCode.SByte && tc <= TypeCode.UInt64)
@@ -421,10 +386,13 @@ namespace ICSharpCode.ILSpy
 			var body = m.Body;
 			if (body == null)
 				return false;
-				if (searchTermLiteralType == TypeCode.Int64) {
+			if (searchTermLiteralType == TypeCode.Int64)
+			{
 				long val = (long)searchTermLiteralValue;
-					foreach (var inst in body.Instructions) {
+				foreach (var inst in body.Instructions)
-						switch (inst.OpCode.Code) {
+				{
+					switch (inst.OpCode.Code)
+					{
 						case Code.Ldc_I8:
 							if (val == (long)inst.Operand)
 								return true;
@@ -479,9 +447,12 @@ namespace ICSharpCode.ILSpy
 							break;
 					}
 				}
-				} else if (searchTermLiteralType != TypeCode.Empty) {
+			}
+			else if (searchTermLiteralType != TypeCode.Empty)
+			{
 				Code expectedCode;
-					switch (searchTermLiteralType) {
+				switch (searchTermLiteralType)
+				{
 					case TypeCode.Single:
 						expectedCode = Code.Ldc_R4;
 						break;
@@ -494,12 +465,16 @@ namespace ICSharpCode.ILSpy
 					default:
 						throw new InvalidOperationException();
 				}
-					foreach (var inst in body.Instructions) {
+				foreach (var inst in body.Instructions)
+				{
 					if (inst.OpCode.Code == expectedCode && searchTermLiteralValue.Equals(inst.Operand))
 						return true;
 				}
-				} else {
+			}
-					foreach (var inst in body.Instructions) {
+			else
+			{
+				foreach (var inst in body.Instructions)
+				{
 					if (inst.OpCode.Code == Code.Ldstr && IsMatch((string)inst.Operand))
 						return true;
 				}
@@ -508,23 +483,169 @@ namespace ICSharpCode.ILSpy
 		}
 	}
 
-		sealed class SearchResult : INotifyPropertyChanged, IMemberTreeNode
+	internal class MemberSearcher : SearcherBase
+	{
+		public MemberSearcher(string[] terms) : base(terms)
 		{
-			event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged {
-				add { }
-				remove { }
 		}
 
-			public MemberReference Member { get; set; }
+		protected override bool IsMatch(FieldDefinition field)
+		{
+			return IsMatch(field.Name);
+		}
 
-			public string Location { get; set; }
+		protected override bool IsMatch(PropertyDefinition property)
-			public string Name { get; set; }
+		{
-			public ImageSource Image { get; set; }
+			return IsMatch(property.Name);
-			public ImageSource LocationImage { get; set; }
+		}
 
-			public override string ToString()
+		protected override bool IsMatch(EventDefinition ev)
 		{
-				return Name;
+			return IsMatch(ev.Name);
+		}
+
+		protected override bool IsMatch(MethodDefinition m)
+		{
+			return IsMatch(m.Name);
+		}
+	}
+
+	internal abstract class SearcherBase : SearchPane.ISearch
+	{
+		protected string[] searchTerm;
+
+		protected SearcherBase(string[] terms)
+		{
+			if (terms.Length == 1 && terms[0].Length > 2 && terms[0][1] == ':')
+				terms[0] = terms[0].Substring(2);
+
+			searchTerm = terms;
+		}
+
+		protected bool IsMatch(string text)
+		{
+			for (int i = 0; i < searchTerm.Length; ++i)
+			{
+				// How to handle overlapping matches?
+				if (text.IndexOf(searchTerm[i], StringComparison.OrdinalIgnoreCase) < 0)
+					return false;
+			}
+			return true;
+		}
+
+		protected virtual bool IsMatch(FieldDefinition field)
+		{
+			return false;
+		}
+
+		protected virtual bool IsMatch(PropertyDefinition property)
+		{
+			return false;
+		}
+
+		protected virtual bool IsMatch(EventDefinition ev)
+		{
+			return false;
+		}
+
+		protected virtual bool IsMatch(MethodDefinition m)
+		{
+			return false;
+		}
+
+		public virtual void Search(TypeDefinition type, Language language, Action<SearchPane.SearchResult> addResult)
+		{
+			foreach (FieldDefinition field in type.Fields)
+			{
+				if (IsMatch(field))
+				{
+					addResult(new SearchPane.SearchResult
+					{
+						Member = field,
+						Image = FieldTreeNode.GetIcon(field),
+						Name = field.Name,
+						LocationImage = TypeTreeNode.GetIcon(type),
+						Location = language.TypeToString(type, includeNamespace: true)
+					});
+				}
+			}
+			foreach (PropertyDefinition property in type.Properties)
+			{
+				if (IsMatch(property))
+				{
+					addResult(new SearchPane.SearchResult
+					{
+						Member = property,
+						Image = PropertyTreeNode.GetIcon(property),
+						Name = property.Name,
+						LocationImage = TypeTreeNode.GetIcon(type),
+						Location = language.TypeToString(type, includeNamespace: true)
+					});
+				}
+			}
+			foreach (EventDefinition ev in type.Events)
+			{
+				if (IsMatch(ev))
+				{
+					addResult(new SearchPane.SearchResult
+					{
+						Member = ev,
+						Image = EventTreeNode.GetIcon(ev),
+						Name = ev.Name,
+						LocationImage = TypeTreeNode.GetIcon(type),
+						Location = language.TypeToString(type, includeNamespace: true)
+					});
+				}
+			}
+			foreach (MethodDefinition method in type.Methods)
+			{
+				switch (method.SemanticsAttributes)
+				{
+					case MethodSemanticsAttributes.Setter:
+					case MethodSemanticsAttributes.Getter:
+					case MethodSemanticsAttributes.AddOn:
+					case MethodSemanticsAttributes.RemoveOn:
+					case MethodSemanticsAttributes.Fire:
+						continue;
+				}
+				if (IsMatch(method))
+				{
+					addResult(new SearchPane.SearchResult
+					{
+						Member = method,
+						Image = MethodTreeNode.GetIcon(method),
+						Name = method.Name,
+						LocationImage = TypeTreeNode.GetIcon(type),
+						Location = language.TypeToString(type, includeNamespace: true)
+					});
+				}
+			}
+		}
+	}
+
+	internal class TypeSearcher : SearcherBase
+	{
+		public TypeSearcher(string[] terms) : base(terms)
+		{
+		}
+
+		public override void Search(TypeDefinition type, Language language, Action<SearchPane.SearchResult> addResult)
+		{
+			if (IsMatch(type.Name))
+			{
+				addResult(new SearchPane.SearchResult
+				{
+					Member = type,
+					Image = TypeTreeNode.GetIcon(type),
+					Name = language.TypeToString(type, includeNamespace: false),
+					LocationImage = type.DeclaringType != null ? TypeTreeNode.GetIcon(type.DeclaringType) : Images.Namespace,
+					Location = type.DeclaringType != null ? language.TypeToString(type.DeclaringType, includeNamespace: true) : type.Namespace
+				});
+			}
+
+			foreach (TypeDefinition nestedType in type.NestedTypes)
+			{
+				Search(nestedType, language, addResult);
 			}
 		}
 	}