Merge pull request #1119 from TheOneAmir/master

Feature Request: Search by abbreviated qualified name #1090

ILSpy/SearchStrategies.cs

@@ -113,6 +113,10 @@ namespace ICSharpCode.ILSpy
 								return false;
 						}
 						break;
+					case '~':
+						if (term.Length > 1 && !IsNoncontiguousMatch(text.ToLower(), term.Substring(1).ToLower()))
+							return false;
+						break;
 					default:
 						if (text.IndexOf(term, StringComparison.OrdinalIgnoreCase) < 0)
 							return false;
@@ -122,6 +126,33 @@ namespace ICSharpCode.ILSpy
 			return true;
 		}
 
+		bool IsNoncontiguousMatch(string text, string searchTerm)
+		{
+			if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(searchTerm)) {
+				return false;
+			}
+			var textLength = text.Length;
+			if (searchTerm.Length > textLength) {
+				return false;
+			}
+			var i = 0;
+			for (int searchIndex = 0; searchIndex < searchTerm.Length;) {
+				while (i != textLength) {
+					if (text[i] == searchTerm[searchIndex]) {
+						// Check if all characters in searchTerm have been matched
+						if (searchTerm.Length == ++searchIndex)
+							return true;
+						i++;
+						break;
+					}
+					i++;
+				}
+				if (i == textLength)
+					return false;
+			}
+			return false;
+		}
+
 		string GetLanguageSpecificName(Language language, IMemberDefinition member, bool fullName = false)
 		{
 			switch (member) {
@@ -227,23 +258,23 @@ namespace ICSharpCode.ILSpy
 				if (value != null && value.LiteralValue != null) {
 					TypeCode valueType = Type.GetTypeCode(value.LiteralValue.GetType());
 					switch (valueType) {
-					case TypeCode.Byte:
+						case TypeCode.Byte:
-					case TypeCode.SByte:
+						case TypeCode.SByte:
-					case TypeCode.Int16:
+						case TypeCode.Int16:
-					case TypeCode.UInt16:
+						case TypeCode.UInt16:
-					case TypeCode.Int32:
+						case TypeCode.Int32:
-					case TypeCode.UInt32:
+						case TypeCode.UInt32:
-					case TypeCode.Int64:
+						case TypeCode.Int64:
-					case TypeCode.UInt64:
+						case TypeCode.UInt64:
-						searchTermLiteralType = TypeCode.Int64;
+							searchTermLiteralType = TypeCode.Int64;
-						searchTermLiteralValue = CSharpPrimitiveCast.Cast(TypeCode.Int64, value.LiteralValue, false);
+							searchTermLiteralValue = CSharpPrimitiveCast.Cast(TypeCode.Int64, value.LiteralValue, false);
-						break;
+							break;
-					case TypeCode.Single:
+						case TypeCode.Single:
-					case TypeCode.Double:
+						case TypeCode.Double:
-					case TypeCode.String:
+						case TypeCode.String:
-						searchTermLiteralType = valueType;
+							searchTermLiteralType = valueType;
-						searchTermLiteralValue = value.LiteralValue;
+							searchTermLiteralValue = value.LiteralValue;
-						break;
+							break;
 					}
 				}
 			}
@@ -301,74 +332,74 @@ namespace ICSharpCode.ILSpy
 				long val = (long)searchTermLiteralValue;
 				foreach (var inst in body.Instructions) {
 					switch (inst.OpCode.Code) {
-					case Code.Ldc_I8:
+						case Code.Ldc_I8:
-						if (val == (long)inst.Operand)
+							if (val == (long)inst.Operand)
-							return true;
+								return true;
-						break;
+							break;
-					case Code.Ldc_I4:
+						case Code.Ldc_I4:
-						if (val == (int)inst.Operand)
+							if (val == (int)inst.Operand)
-							return true;
+								return true;
-						break;
+							break;
-					case Code.Ldc_I4_S:
+						case Code.Ldc_I4_S:
-						if (val == (sbyte)inst.Operand)
+							if (val == (sbyte)inst.Operand)
-							return true;
+								return true;
-						break;
+							break;
-					case Code.Ldc_I4_M1:
+						case Code.Ldc_I4_M1:
-						if (val == -1)
+							if (val == -1)
-							return true;
+								return true;
-						break;
+							break;
-					case Code.Ldc_I4_0:
+						case Code.Ldc_I4_0:
-						if (val == 0)
+							if (val == 0)
-							return true;
+								return true;
-						break;
+							break;
-					case Code.Ldc_I4_1:
+						case Code.Ldc_I4_1:
-						if (val == 1)
+							if (val == 1)
-							return true;
+								return true;
-						break;
+							break;
-					case Code.Ldc_I4_2:
+						case Code.Ldc_I4_2:
-						if (val == 2)
+							if (val == 2)
-							return true;
+								return true;
-						break;
+							break;
-					case Code.Ldc_I4_3:
+						case Code.Ldc_I4_3:
-						if (val == 3)
+							if (val == 3)
-							return true;
+								return true;
-						break;
+							break;
-					case Code.Ldc_I4_4:
+						case Code.Ldc_I4_4:
-						if (val == 4)
+							if (val == 4)
-							return true;
+								return true;
-						break;
+							break;
-					case Code.Ldc_I4_5:
+						case Code.Ldc_I4_5:
-						if (val == 5)
+							if (val == 5)
-							return true;
+								return true;
-						break;
+							break;
-					case Code.Ldc_I4_6:
+						case Code.Ldc_I4_6:
-						if (val == 6)
+							if (val == 6)
-							return true;
+								return true;
-						break;
+							break;
-					case Code.Ldc_I4_7:
+						case Code.Ldc_I4_7:
-						if (val == 7)
+							if (val == 7)
-							return true;
+								return true;
-						break;
+							break;
-					case Code.Ldc_I4_8:
+						case Code.Ldc_I4_8:
-						if (val == 8)
+							if (val == 8)
-							return true;
+								return true;
-						break;
+							break;
 					}
 				}
 			} else if (searchTermLiteralType != TypeCode.Empty) {
 				Code expectedCode;
 				switch (searchTermLiteralType) {
-				case TypeCode.Single:
+					case TypeCode.Single:
-					expectedCode = Code.Ldc_R4;
+						expectedCode = Code.Ldc_R4;
-					break;
+						break;
-				case TypeCode.Double:
+					case TypeCode.Double:
-					expectedCode = Code.Ldc_R8;
+						expectedCode = Code.Ldc_R8;
-					break;
+						break;
-				case TypeCode.String:
+					case TypeCode.String:
-					expectedCode = Code.Ldstr;
+						expectedCode = Code.Ldstr;
-					break;
+						break;
-				default:
+					default:
-					throw new InvalidOperationException();
+						throw new InvalidOperationException();
 				}
 				foreach (var inst in body.Instructions) {
 					if (inst.OpCode.Code == expectedCode && searchTermLiteralValue.Equals(inst.Operand))