Simplify enumeration.

src/Workspaces/Core/Portable/FindSymbols/SymbolFinder.cs

@@ -224,12 +224,9 @@ public static IEnumerable<TSymbol> FindSimilarSymbols<TSymbol>(TSymbol symbol, C
             // We may be talking about different compilations.  So do not try to resolve locations.
             var result = new HashSet<TSymbol>();
             var resolution = key.Resolve(compilation, resolveLocations: false, cancellationToken: cancellationToken);
-            foreach (var current in resolution)
+            foreach (var current in resolution.OfType<TSymbol>())
             {
-                if (current is TSymbol typedSymbol)
-                {
-                    result.Add(typedSymbol);
-                }
+                result.Add(current);
             }
 
             return result;

src/Workspaces/Core/Portable/SymbolKey/SymbolKey.ArrayTypeSymbolKey.cs

@@ -18,13 +18,10 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                 var rank = reader.ReadInteger();
 
                 using var result = PooledArrayBuilder<IArrayTypeSymbol>.GetInstance(elementTypeResolution.SymbolCount);
-                foreach (var symbol in elementTypeResolution)
-                {
-                    if (symbol is ITypeSymbol typeSymbol)
+                foreach (var typeSymbol in elementTypeResolution.OfType<ITypeSymbol>())
                 {
                     result.AddIfNotNull(reader.Compilation.CreateArrayTypeSymbol(typeSymbol, rank));
                 }
-                }
 
                 return CreateSymbolInfo(result);
             }

src/Workspaces/Core/Portable/SymbolKey/SymbolKey.ErrorTypeSymbolKey.cs

@@ -40,28 +40,25 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                 using var result = PooledArrayBuilder<INamedTypeSymbol>.GetInstance();
 
                 var typeArgumentsArray = arity > 0 ? typeArguments.Builder.ToArray() : null;
-                foreach (var container in containingSymbolResolution)
-                {
-                    if (container is INamespaceOrTypeSymbol containerTypeOrNS)
+                foreach (var container in containingSymbolResolution.OfType<INamespaceOrTypeSymbol>())
                 {
                     result.AddIfNotNull(Construct(
-                            reader, containerTypeOrNS, name, arity, typeArgumentsArray));
-                    }
+                        reader, container, name, arity, typeArgumentsArray));
                 }
 
                 // Always ensure at least one error type was created.
                 if (result.Count == 0)
                 {
                     result.AddIfNotNull(Construct(
-                        reader, containerTypeOrNS: null, name, arity, typeArgumentsArray));
+                        reader, container: null, name, arity, typeArgumentsArray));
                 }
 
                 return CreateSymbolInfo(result);
             }
 
-            private static INamedTypeSymbol Construct(SymbolKeyReader reader, INamespaceOrTypeSymbol containerTypeOrNS, string name, int arity, ITypeSymbol[] typeArguments)
+            private static INamedTypeSymbol Construct(SymbolKeyReader reader, INamespaceOrTypeSymbol container, string name, int arity, ITypeSymbol[] typeArguments)
             {
-                var result = reader.Compilation.CreateErrorTypeSymbol(containerTypeOrNS, name, arity);
+                var result = reader.Compilation.CreateErrorTypeSymbol(container, name, arity);
                 return typeArguments != null ? result.Construct(typeArguments) : result;
             }
         }

src/Workspaces/Core/Portable/SymbolKey/SymbolKey.MethodSymbolKey.cs

@@ -22,19 +22,13 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                 var receiverTypeResolution = reader.ReadSymbolKey();
 
                 using var result = PooledArrayBuilder<IMethodSymbol>.GetInstance();
-                foreach (var reducedFromSymbol in reducedFromResolution)
+                foreach (var reducedFrom in reducedFromResolution.OfType<IMethodSymbol>())
                 {
-                    if (reducedFromSymbol is IMethodSymbol reducedFrom)
-                    {
-                        foreach (var receiverSymbol in receiverTypeResolution)
-                        {
-                            if (receiverSymbol is ITypeSymbol receiverType)
+                    foreach (var receiverType in receiverTypeResolution.OfType<ITypeSymbol>())
                     {
                         result.AddIfNotNull(reducedFrom.ReduceExtensionMethod(receiverType));
                     }
                 }
-                    }
-                }
 
                 return CreateSymbolInfo(result);
             }
@@ -65,16 +59,13 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                 var typeArgumentArray = typeArguments.Builder.ToArray();
 
                 using var result = PooledArrayBuilder<IMethodSymbol>.GetInstance();
-                foreach (var symbol in constructedFrom)
-                {
-                    if (symbol is IMethodSymbol method)
+                foreach (var method in constructedFrom.OfType<IMethodSymbol>())
                 {
                     if (method.TypeParameters.Length == typeArgumentArray.Length)
                     {
                         result.AddIfNotNull(method.Construct(typeArgumentArray));
                     }
                 }
-                }
 
                 return CreateSymbolInfo(result);
             }

src/Workspaces/Core/Portable/SymbolKey/SymbolKey.ModuleSymbolKey.cs

@@ -14,15 +14,12 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                 var containingSymbolResolution = reader.ReadSymbolKey();
 
                 using var result = PooledArrayBuilder<IModuleSymbol>.GetInstance();
-                foreach (var containingSymbol in containingSymbolResolution)
-                {
-                    if (containingSymbol is IAssemblySymbol assembly)
+                foreach (var assembly in containingSymbolResolution.OfType<IAssemblySymbol>())
                 {
                     // Don't check ModuleIds for equality because in practice, no-one uses them,
                     // and there is no way to set netmodule name programmatically using Roslyn
                     result.AddValuesIfNotNull(assembly.Modules);
                 }
-                }
 
                 return CreateSymbolInfo(result);
             }

src/Workspaces/Core/Portable/SymbolKey/SymbolKey.NamedTypeSymbolKey.cs

@@ -43,15 +43,12 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                     ? Array.Empty<ITypeSymbol>()
                     : typeArguments.Builder.ToArray();
                 using var result = PooledArrayBuilder<INamedTypeSymbol>.GetInstance();
-                foreach (var resolution in containingSymbolResolution)
-                {
-                    if (resolution is INamespaceOrTypeSymbol nsOrType)
+                foreach (var nsOrType in containingSymbolResolution.OfType<INamespaceOrTypeSymbol>())
                 {
                     Resolve(
                         result, nsOrType, metadataName, arity,
                         isUnboundGenericType, typeArgumentArray);
                 }
-                }
 
                 return CreateSymbolInfo(result);
             }

src/Workspaces/Core/Portable/SymbolKey/SymbolKey.PointerTypeSymbolKey.cs

@@ -14,13 +14,10 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                 var pointedAtTypeResolution = reader.ReadSymbolKey();
 
                 using var result = PooledArrayBuilder<IPointerTypeSymbol>.GetInstance(pointedAtTypeResolution.SymbolCount);
-                foreach (var symbol in pointedAtTypeResolution)
-                {
-                    if (symbol is ITypeSymbol typeSymbol)
+                foreach (var typeSymbol in pointedAtTypeResolution.OfType<ITypeSymbol>())
                 {
                     result.AddIfNotNull(reader.Compilation.CreatePointerTypeSymbol(typeSymbol));
                 }
-                }
 
                 return CreateSymbolInfo(result);
             }

src/Workspaces/Core/Portable/SymbolKey/SymbolKey.TupleTypeSymbolKey.cs

@@ -80,14 +80,11 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                         using var result = PooledArrayBuilder<INamedTypeSymbol>.GetInstance();
 
                         var elementNames = elementNamesBuilder.ToImmutable();
-                        foreach (var symbol in underlyingTypeResolution)
-                        {
-                            if (symbol is INamedTypeSymbol namedType)
+                        foreach (var namedType in underlyingTypeResolution.OfType<INamedTypeSymbol>())
                         {
                             result.AddIfNotNull(reader.Compilation.CreateTupleTypeSymbol(
                                 namedType, elementNames, elementLocations));
                         }
-                        }
 
                         return CreateSymbolInfo(result);
                     }

src/Workspaces/Core/Portable/SymbolKey/SymbolKey.cs

@@ -250,9 +250,7 @@ private static string GetName(string metadataName)
             string metadataNameOpt) where TSymbol : ISymbol
         {
             var result = PooledArrayBuilder<TSymbol>.GetInstance();
-            foreach (var containingSymbol in containingTypeResolution)
-            {
-                if (containingSymbol is INamedTypeSymbol containingType)
+            foreach (var containingType in containingTypeResolution.OfType<INamedTypeSymbol>())
             {
                 var members = metadataNameOpt == null
                     ? containingType.GetMembers()
@@ -266,7 +264,6 @@ private static string GetName(string metadataName)
                     }
                 }
             }
-            }
 
             return result;
         }

src/Workspaces/Core/Portable/SymbolKey/SymbolKeyResolution.Enumerator.cs → src/Workspaces/Core/Portable/SymbolKey/SymbolKeyResolution.Enumeration.cs

@@ -4,12 +4,23 @@ namespace Microsoft.CodeAnalysis
 {
     internal partial struct SymbolKeyResolution
     {
-        public struct Enumerator
+        public struct Enumerable<TSymbol> where TSymbol : ISymbol
+        {
+            private readonly SymbolKeyResolution _resolution;
+
+            internal Enumerable(SymbolKeyResolution resolution)
+                => _resolution = resolution;
+
+            public Enumerator<TSymbol> GetEnumerator()
+                => new Enumerator<TSymbol>(_resolution);
+        }
+
+        public struct Enumerator<TSymbol> where TSymbol : ISymbol
         {
             private readonly SymbolKeyResolution _symbolKeyResolution;
             private int _index;
 
-            public Enumerator(SymbolKeyResolution symbolKeyResolution)
+            internal Enumerator(SymbolKeyResolution symbolKeyResolution)
             {
                 _symbolKeyResolution = symbolKeyResolution;
                 _index = -1;
@@ -17,25 +28,32 @@ public Enumerator(SymbolKeyResolution symbolKeyResolution)
 
             public bool MoveNext()
             {
-                _index++;
                 if (_symbolKeyResolution.Symbol != null)
                 {
-                    return _index == 0;
+                    return ++_index == 0 && _symbolKeyResolution.Symbol is TSymbol;
+                }
+
+                while (++_index < _symbolKeyResolution.CandidateSymbols.Length)
+                {
+                    if (_symbolKeyResolution.CandidateSymbols[_index] is TSymbol)
+                    {
+                        return true;
+                    }
                 }
 
-                return _index < _symbolKeyResolution.CandidateSymbols.Length;
+                return false;
             }
 
-            public ISymbol Current
+            public TSymbol Current
             {
                 get
                 {
                     if (_symbolKeyResolution.Symbol != null)
                     {
-                        return _symbolKeyResolution.Symbol;
+                        return (TSymbol)_symbolKeyResolution.Symbol;
                     }
 
-                    return _symbolKeyResolution.CandidateSymbols[_index];
+                    return (TSymbol)_symbolKeyResolution.CandidateSymbols[_index];
                 }
             }
         }

src/Workspaces/Core/Portable/SymbolKey/SymbolKeyResolution.cs

@@ -47,9 +47,10 @@ internal SymbolKeyResolution(ImmutableArray<ISymbol> candidateSymbols, Candidate
         public CandidateReason CandidateReason { get; }
         public ImmutableArray<ISymbol> CandidateSymbols => _candidateSymbols.NullToEmpty();
 
-        public Enumerator GetEnumerator()
-        {
-            return new Enumerator(this);
-        }
+        public Enumerator<ISymbol> GetEnumerator()
+            => new Enumerator<ISymbol>(this);
+
+        internal Enumerable<TSymbol> OfType<TSymbol>() where TSymbol : ISymbol
+            => new Enumerable<TSymbol>(this);
     }
 }