Sort Analyzer results.

ILSpy/TreeNodes/Analyzer/AnalyzedEventFiredByTreeNode.cs

@@ -77,7 +77,7 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 		{
 			foundMethods = new ConcurrentDictionary<MethodDefinition, int>();
 
-			foreach (var child in FindReferencesInType(analyzedEvent.DeclaringType)) {
+			foreach (var child in FindReferencesInType(analyzedEvent.DeclaringType).OrderBy(n => n.Text)) {
 				yield return child;
 			}
 
@@ -117,7 +117,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 				if (found) {
 					MethodDefinition codeLocation = this.Language.GetOriginalCodeLocation(method) as MethodDefinition;
 					if (codeLocation != null && !HasAlreadyBeenFound(codeLocation)) {
-						yield return new AnalyzedMethodTreeNode(codeLocation);
+						var node = new AnalyzedMethodTreeNode(codeLocation);
+						node.Language = this.Language;
+						yield return node;
 					}
 				}
 			}

ILSpy/TreeNodes/Analyzer/AnalyzedEventOverridesTreeNode.cs

@@ -71,7 +71,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 			ScopedWhereUsedAnalyzer<SharpTreeNode> analyzer;
 
 			analyzer = new ScopedWhereUsedAnalyzer<SharpTreeNode>(analyzedEvent, FindReferencesInType);
-			return analyzer.PerformAnalysis(ct);
+			foreach (var child in analyzer.PerformAnalysis(ct).OrderBy(n => n.Text)) {
+				yield return child;
+			}
 		}
 
 		private IEnumerable<SharpTreeNode> FindReferencesInType(TypeDefinition type)
@@ -86,7 +88,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 				if (TypesHierarchyHelpers.IsBaseEvent(analyzedEvent, eventDef)) {
 					MethodDefinition anyAccessor = eventDef.AddMethod ?? eventDef.RemoveMethod;
 					bool hidesParent = !anyAccessor.IsVirtual ^ anyAccessor.IsNewSlot;
-					yield return new AnalyzedEventTreeNode(eventDef, hidesParent ? "(hides) " : "");
+					var node = new AnalyzedEventTreeNode(eventDef, hidesParent ? "(hides) " : "");
+					node.Language = this.Language;
+					yield return node;
 				}
 			}
 		}

ILSpy/TreeNodes/Analyzer/AnalyzedFieldAccessTreeNode.cs

@@ -18,6 +18,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using ICSharpCode.TreeView;
 using Mono.Cecil;
@@ -74,7 +75,7 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 			foundMethods = new Lazy<Hashtable>(LazyThreadSafetyMode.ExecutionAndPublication);
 
 			var analyzer = new ScopedWhereUsedAnalyzer<SharpTreeNode>(analyzedField, FindReferencesInType);
-			foreach (var child in analyzer.PerformAnalysis(ct)) {
+			foreach (var child in analyzer.PerformAnalysis(ct).OrderBy(n => n.Text)) {
 				yield return child;
 			}
 
@@ -93,8 +94,8 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 				foreach (Instruction instr in method.Body.Instructions) {
 					if (CanBeReference(instr.OpCode.Code)) {
 						FieldReference fr = instr.Operand as FieldReference;
-						if (fr != null && fr.Name == name && 
+						if (fr != null && fr.Name == name &&
-							Helpers.IsReferencedBy(analyzedField.DeclaringType, fr.DeclaringType) && 
+							Helpers.IsReferencedBy(analyzedField.DeclaringType, fr.DeclaringType) &&
 							fr.Resolve() == analyzedField) {
 							found = true;
 							break;
@@ -107,7 +108,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 				if (found) {
 					MethodDefinition codeLocation = this.Language.GetOriginalCodeLocation(method) as MethodDefinition;
 					if (codeLocation != null && !HasAlreadyBeenFound(codeLocation)) {
-						yield return new AnalyzedMethodTreeNode(codeLocation);
+						var node = new AnalyzedMethodTreeNode(codeLocation);
+						node.Language = this.Language;
+						yield return node;
 					}
 				}
 			}

ILSpy/TreeNodes/Analyzer/AnalyzedInterfaceEventImplementedByTreeNode.cs

@@ -71,7 +71,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 		{
 			ScopedWhereUsedAnalyzer<SharpTreeNode> analyzer;
 			analyzer = new ScopedWhereUsedAnalyzer<SharpTreeNode>(analyzedMethod, FindReferencesInType);
-			return analyzer.PerformAnalysis(ct);
+			foreach (var child in analyzer.PerformAnalysis(ct).OrderBy(n => n.Text)) {
+				yield return child;
+			}
 		}
 
 		private IEnumerable<SharpTreeNode> FindReferencesInType(TypeDefinition type)
@@ -84,15 +86,20 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 
 			foreach (EventDefinition ev in type.Events.Where(e => e.Name == analyzedEvent.Name)) {
 				MethodDefinition accessor = ev.AddMethod ?? ev.RemoveMethod;
-				if (TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef))
+				if (TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef)) {
-					yield return new AnalyzedEventTreeNode(ev);
+					var node = new AnalyzedEventTreeNode(ev);
+					node.Language = this.Language;
+					yield return node;
+				}
 				yield break;
 			}
 
 			foreach (EventDefinition ev in type.Events.Where(e => e.Name.EndsWith(analyzedEvent.Name))) {
 				MethodDefinition accessor = ev.AddMethod ?? ev.RemoveMethod;
 				if (accessor.HasOverrides && accessor.Overrides.Any(m => m.Resolve() == analyzedMethod)) {
-					yield return new AnalyzedEventTreeNode(ev);
+					var node = new AnalyzedEventTreeNode(ev);
+					node.Language = this.Language;
+					yield return node;
 				}
 			}
 		}

ILSpy/TreeNodes/Analyzer/AnalyzedInterfaceMethodImplementedByTreeNode.cs

@@ -69,7 +69,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 		{
 			ScopedWhereUsedAnalyzer<SharpTreeNode> analyzer;
 			analyzer = new ScopedWhereUsedAnalyzer<SharpTreeNode>(analyzedMethod, FindReferencesInType);
-			return analyzer.PerformAnalysis(ct);
+			foreach (var child in analyzer.PerformAnalysis(ct).OrderBy(n => n.Text)) {
+				yield return child;
+			}
 		}
 
 		private IEnumerable<SharpTreeNode> FindReferencesInType(TypeDefinition type)
@@ -81,14 +83,19 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 				yield break;
 
 			foreach (MethodDefinition method in type.Methods.Where(m => m.Name == analyzedMethod.Name)) {
-				if (TypesHierarchyHelpers.MatchInterfaceMethod(method, analyzedMethod, implementedInterfaceRef))
+				if (TypesHierarchyHelpers.MatchInterfaceMethod(method, analyzedMethod, implementedInterfaceRef)) {
-					yield return new AnalyzedMethodTreeNode(method);
+					var node = new AnalyzedMethodTreeNode(method);
+					node.Language = this.Language;
+					yield return node;
+				}
 				yield break;
 			}
 
 			foreach (MethodDefinition method in type.Methods) {
 				if (method.HasOverrides && method.Overrides.Any(m => m.Resolve() == analyzedMethod)) {
-					yield return new AnalyzedMethodTreeNode(method);
+					var node =  new AnalyzedMethodTreeNode(method);
+					node.Language = this.Language;
+					yield return node;
 				}
 			}
 		}

ILSpy/TreeNodes/Analyzer/AnalyzedInterfacePropertyImplementedByTreeNode.cs

@@ -71,7 +71,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 		{
 			ScopedWhereUsedAnalyzer<SharpTreeNode> analyzer;
 			analyzer = new ScopedWhereUsedAnalyzer<SharpTreeNode>(analyzedMethod, FindReferencesInType);
-			return analyzer.PerformAnalysis(ct);
+			foreach (var child in analyzer.PerformAnalysis(ct).OrderBy(n => n.Text)) {
+				yield return child;
+			}
 		}
 
 		private IEnumerable<SharpTreeNode> FindReferencesInType(TypeDefinition type)
@@ -84,15 +86,20 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 
 			foreach (PropertyDefinition property in type.Properties.Where(e => e.Name == analyzedProperty.Name)) {
 				MethodDefinition accessor = property.GetMethod ?? property.SetMethod;
-				if (TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef))
+				if (TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef)) {
-					yield return new AnalyzedPropertyTreeNode(property);
+					var node = new AnalyzedPropertyTreeNode(property);
+					node.Language = this.Language;
+					yield return node;
+				}
 				yield break;
 			}
 
 			foreach (PropertyDefinition property in type.Properties.Where(e => e.Name.EndsWith(analyzedProperty.Name))) {
 				MethodDefinition accessor = property.GetMethod ?? property.SetMethod;
 				if (accessor.HasOverrides && accessor.Overrides.Any(m => m.Resolve() == analyzedMethod)) {
-					yield return new AnalyzedPropertyTreeNode(property);
+					var node = new AnalyzedPropertyTreeNode(property);
+					node.Language = this.Language;
+					yield return node;
 				}
 			}
 		}

ILSpy/TreeNodes/Analyzer/AnalyzedMethodOverridesTreeNode.cs

@@ -76,12 +76,14 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 			ScopedWhereUsedAnalyzer<SharpTreeNode> analyzer;
 
 			analyzer = new ScopedWhereUsedAnalyzer<SharpTreeNode>(analyzedMethod, FindReferencesInType);
-			return analyzer.PerformAnalysis(ct);
+			foreach (var child in analyzer.PerformAnalysis(ct).OrderBy(n => n.Text)) {
+				yield return child;
+			}
 		}
 
 		private IEnumerable<SharpTreeNode> FindReferencesInType(TypeDefinition type)
 		{
-			SharpTreeNode newNode = null;
+			AnalyzerTreeNode newNode = null;
 			try {
 				if (!TypesHierarchyHelpers.IsBaseType(analyzedMethod.DeclaringType, type, resolveTypeArguments: false))
 					yield break;
@@ -97,8 +99,10 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 				// ignore this type definition. maybe add a notification about such cases.
 			}
 
-			if (newNode != null)
+			if (newNode != null) {
+				newNode.Language = this.Language;
 				yield return newNode;
+			}
 		}
 
 		public static bool CanShow(MethodDefinition method)

ILSpy/TreeNodes/Analyzer/AnalyzedMethodUsedByTreeNode.cs

@@ -19,6 +19,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using ICSharpCode.TreeView;
 using Mono.Cecil;
@@ -71,7 +72,7 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 			foundMethods = new ConcurrentDictionary<MethodDefinition, int>();
 
 			var analyzer = new ScopedWhereUsedAnalyzer<SharpTreeNode>(analyzedMethod, FindReferencesInType);
-			foreach (var child in analyzer.PerformAnalysis(ct)) {
+			foreach (var child in analyzer.PerformAnalysis(ct).OrderBy(n => n.Text)) {
 				yield return child;
 			}
 
@@ -100,7 +101,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 				if (found) {
 					MethodDefinition codeLocation = this.Language.GetOriginalCodeLocation(method) as MethodDefinition;
 					if (codeLocation != null && !HasAlreadyBeenFound(codeLocation)) {
-						yield return new AnalyzedMethodTreeNode(codeLocation);
+						var node= new AnalyzedMethodTreeNode(codeLocation);
+						node.Language = this.Language;
+						yield return node;
 					}
 				}
 			}

ILSpy/TreeNodes/Analyzer/AnalyzedMethodUsesTreeNode.cs

@@ -51,14 +51,25 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 		}
 
 		protected override void LoadChildren()
+		{
+			analyzedMethod.Body = null;
+			foreach (var child in GetChildren().OrderBy(n => n.Text)) {
+				this.Children.Add(child);
+			}
+		}
+
+		private IEnumerable<AnalyzerTreeNode> GetChildren()
 		{
 			foreach (var f in GetUsedFields().Distinct()) {
-				this.Children.Add(new AnalyzedFieldTreeNode(f));
+				var node = new AnalyzedFieldTreeNode(f);
+				node.Language = this.Language;
+				yield return node;
 			}
 			foreach (var m in GetUsedMethods().Distinct()) {
-				this.Children.Add(new AnalyzedMethodTreeNode(m));
+				var node = new AnalyzedMethodTreeNode(m);
+				node.Language = this.Language;
+				yield return node;
 			}
-			analyzedMethod.Body = null;
 		}
 
 		private IEnumerable<MethodDefinition> GetUsedMethods()

ILSpy/TreeNodes/Analyzer/AnalyzedPropertyOverridesTreeNode.cs

@@ -72,7 +72,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 			ScopedWhereUsedAnalyzer<SharpTreeNode> analyzer;
 
 			analyzer = new ScopedWhereUsedAnalyzer<SharpTreeNode>(analyzedProperty, FindReferencesInType);
-			return analyzer.PerformAnalysis(ct);
+			foreach (var child in analyzer.PerformAnalysis(ct).OrderBy(n => n.Text)) {
+				yield return child;
+			}
 		}
 
 		private IEnumerable<SharpTreeNode> FindReferencesInType(TypeDefinition type)
@@ -88,7 +90,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 				if (TypesHierarchyHelpers.IsBaseProperty(analyzedProperty, property)) {
 					MethodDefinition anyAccessor = property.GetMethod ?? property.SetMethod;
 					bool hidesParent = !anyAccessor.IsVirtual ^ anyAccessor.IsNewSlot;
-					yield return new AnalyzedPropertyTreeNode(property, hidesParent ? "(hides) " : "");
+					var node = new AnalyzedPropertyTreeNode(property, hidesParent ? "(hides) " : "");
+					node.Language = this.Language;
+					yield return node;
 				}
 			}
 		}

ILSpy/TreeNodes/Analyzer/AnalyzedTypeExposedByTreeNode.cs

@@ -18,6 +18,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using ICSharpCode.TreeView;
 using Mono.Cecil;
@@ -68,7 +69,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 			ScopedWhereUsedAnalyzer<SharpTreeNode> analyzer;
 
 			analyzer = new ScopedWhereUsedAnalyzer<SharpTreeNode>(analyzedType, FindReferencesInType);
-			return analyzer.PerformAnalysis(ct);
+			foreach (var child in analyzer.PerformAnalysis(ct).OrderBy(n => n.Text)) {
+				yield return child;
+			}
 		}
 
 		private IEnumerable<SharpTreeNode> FindReferencesInType(TypeDefinition type)
@@ -80,23 +83,35 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 				yield break;
 
 			foreach (FieldDefinition field in type.Fields) {
-				if (TypeIsExposedBy(field))
+				if (TypeIsExposedBy(field)) {
-					yield return new AnalyzedFieldTreeNode(field);
+					var node = new AnalyzedFieldTreeNode(field);
+					node.Language = this.Language;
+					yield return node;
+				}
 			}
 
 			foreach (PropertyDefinition property in type.Properties) {
-				if (TypeIsExposedBy(property))
+				if (TypeIsExposedBy(property)) {
-					yield return new AnalyzedPropertyTreeNode(property);
+					var node = new AnalyzedPropertyTreeNode(property);
+					node.Language = this.Language;
+					yield return node;
+				}
 			}
 
 			foreach (EventDefinition eventDef in type.Events) {
-				if (TypeIsExposedBy(eventDef))
+				if (TypeIsExposedBy(eventDef)) {
-					yield return new AnalyzedEventTreeNode(eventDef);
+					var node = new AnalyzedEventTreeNode(eventDef);
+					node.Language = this.Language;
+					yield return node;
+				}
 			}
 
 			foreach (MethodDefinition method in type.Methods) {
-				if (TypeIsExposedBy(method))
+				if (TypeIsExposedBy(method)) {
-					yield return new AnalyzedMethodTreeNode(method);
+					var node = new AnalyzedMethodTreeNode(method);
+					node.Language = this.Language;
+					yield return node;
+				}
 			}
 		}
 

ILSpy/TreeNodes/Analyzer/AnalyzedTypeExtensionMethodsTreeNode.cs

@@ -69,7 +69,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 			ScopedWhereUsedAnalyzer<SharpTreeNode> analyzer;
 
 			analyzer = new ScopedWhereUsedAnalyzer<SharpTreeNode>(analyzedType, FindReferencesInType);
-			return analyzer.PerformAnalysis(ct);
+			foreach (var child in analyzer.PerformAnalysis(ct).OrderBy(n => n.Text)) {
+				yield return child;
+			}
 		}
 
 		private IEnumerable<SharpTreeNode> FindReferencesInType(TypeDefinition type)
@@ -79,7 +81,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 			foreach (MethodDefinition method in type.Methods) {
 				if (method.IsStatic && HasExtensionAttribute(method)) {
 					if (method.HasParameters && method.Parameters[0].ParameterType.Resolve() == analyzedType) {
-						yield return new AnalyzedMethodTreeNode(method);
+						var node = new AnalyzedMethodTreeNode(method);
+						node.Language = this.Language;
+						yield return node;
 					}
 				}
 			}

ILSpy/TreeNodes/Analyzer/AnalyzedTypeInstantiationsTreeNode.cs

@@ -74,7 +74,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 			ScopedWhereUsedAnalyzer<SharpTreeNode> analyzer;
 
 			analyzer = new ScopedWhereUsedAnalyzer<SharpTreeNode>(analyzedType, FindReferencesInType);
-			return analyzer.PerformAnalysis(ct);
+			foreach (var child in analyzer.PerformAnalysis(ct).OrderBy(n => n.Text)) {
+				yield return child;
+			}
 		}
 
 		private IEnumerable<SharpTreeNode> FindReferencesInType(TypeDefinition type)
@@ -102,8 +104,11 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 
 				method.Body = null;
 
-				if (found)
+				if (found) {
-					yield return new AnalyzedMethodTreeNode(method);
+					var node = new AnalyzedMethodTreeNode(method);
+					node.Language = this.Language;
+					yield return node;
+				}
 			}
 		}
 

ILSpy/TreeNodes/Analyzer/AnalyzedVirtualMethodUsedByTreeNode.cs

@@ -75,7 +75,7 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 			InitializeAnalyzer();
 
 			var analyzer = new ScopedWhereUsedAnalyzer<SharpTreeNode>(analyzedMethod, FindReferencesInType);
-			foreach (var child in analyzer.PerformAnalysis(ct)) {
+			foreach (var child in analyzer.PerformAnalysis(ct).OrderBy(n => n.Text)) {
 				yield return child;
 			}
 
@@ -95,8 +95,7 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 			possibleTypes = new List<TypeReference>();
 
 			TypeReference type = analyzedMethod.DeclaringType.BaseType;
-			while (type !=null)
+			while (type != null) {
-			{
 				possibleTypes.Add(type);
 				type = type.Resolve().BaseType;
 			}
@@ -120,8 +119,8 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 					MethodReference mr = instr.Operand as MethodReference;
 					if (mr != null && mr.Name == name) {
 						// explicit call to the requested method 
-						if (instr.OpCode.Code == Code.Call 
+						if (instr.OpCode.Code == Code.Call
-							&& Helpers.IsReferencedBy(analyzedMethod.DeclaringType, mr.DeclaringType) 
+							&& Helpers.IsReferencedBy(analyzedMethod.DeclaringType, mr.DeclaringType)
 							&& mr.Resolve() == analyzedMethod) {
 							found = true;
 							prefix = "(as base) ";
@@ -147,7 +146,9 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 				if (found) {
 					MethodDefinition codeLocation = this.Language.GetOriginalCodeLocation(method) as MethodDefinition;
 					if (codeLocation != null && !HasAlreadyBeenFound(codeLocation)) {
-						yield return new AnalyzedMethodTreeNode(codeLocation, prefix);
+						var node = new AnalyzedMethodTreeNode(codeLocation);
+						node.Language = this.Language;
+						yield return node;
 					}
 				}
 			}