Simplify

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

@@ -28,13 +28,12 @@ public static void Create(INamedTypeSymbol symbol, SymbolKeyWriter visitor)
 
             public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
             {
-                using var propertyTypes = reader.ReadSymbolArray<ITypeSymbol>();
+                using var propertyTypes = reader.ReadSymbolKeyArray<ITypeSymbol>();
                 using var propertyNames = reader.ReadStringArray();
                 using var propertyIsReadOnly = reader.ReadBooleanArray();
                 using var propertyLocations = reader.ReadLocationArray();
 
-                Debug.Assert(propertyTypes.Count == 0 || propertyTypes.Count == propertyNames.Count);
-                if (propertyTypes.Count == propertyNames.Count)
+                if (propertyTypes.IsDefault)
                 {
                     try
                     {

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

@@ -17,11 +17,11 @@ public static void Create(INamedTypeSymbol symbol, SymbolKeyWriter visitor)
 
                 if (!symbol.Equals(symbol.ConstructedFrom))
                 {
-                    visitor.WriteSymbolArray(symbol.TypeArguments);
+                    visitor.WriteSymbolKeyArray(symbol.TypeArguments);
                 }
                 else
                 {
-                    visitor.WriteSymbolArray(ImmutableArray<ITypeSymbol>.Empty);
+                    visitor.WriteSymbolKeyArray(ImmutableArray<ITypeSymbol>.Empty);
                 }
             }
 
@@ -31,49 +31,38 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                 var containingSymbolResolution = reader.ReadSymbolKey();
                 var arity = reader.ReadInteger();
 
-                using var typeArguments = reader.ReadSymbolArray<ITypeSymbol>();
-                if (typeArguments.Count != arity)
+                using var typeArguments = reader.ReadSymbolKeyArray<ITypeSymbol>();
+                if (typeArguments.IsDefault)
                 {
                     return default;
                 }
 
-                using var errorTypes = CreateErrorTypes(reader, containingSymbolResolution, name, arity);
-                if (arity == 0)
-                {
-                    return CreateSymbolInfo(errorTypes);
-                }
-
                 using var result = PooledArrayBuilder<INamedTypeSymbol>.GetInstance();
-                var typeArgumentsArray = typeArguments.Builder.ToArray();
-                foreach (var type in errorTypes)
-                {
-                    result.AddIfNotNull(type.Construct(typeArgumentsArray));
-                }
-
-                return CreateSymbolInfo(result);
-            }
-
-            private static PooledArrayBuilder<INamedTypeSymbol> CreateErrorTypes(
-                SymbolKeyReader reader,
-                SymbolKeyResolution containingSymbolResolution, string name, int arity)
-            {
-                var errorTypes = PooledArrayBuilder<INamedTypeSymbol>.GetInstance();
 
+                var typeArgumentsArray = arity > 0 ? typeArguments.Builder.ToArray() : null;
                 foreach (var container in containingSymbolResolution)
                 {
                     if (container is INamespaceOrTypeSymbol containerTypeOrNS)
                     {
-                        errorTypes.AddIfNotNull(reader.Compilation.CreateErrorTypeSymbol(containerTypeOrNS, name, arity));
+                        result.AddIfNotNull(Construct(
+                            reader, containerTypeOrNS, name, arity, typeArgumentsArray));
                     }
                 }
 
                 // Always ensure at least one error type was created.
-                if (errorTypes.Count == 0)
+                if (result.Count == 0)
                 {
-                    errorTypes.AddIfNotNull(reader.Compilation.CreateErrorTypeSymbol(null, name, arity));
+                    result.AddIfNotNull(Construct(
+                        reader, containerTypeOrNS: null, name, arity, typeArgumentsArray));
                 }
 
-                return errorTypes;
+                return CreateSymbolInfo(result);
+            }
+
+            private static INamedTypeSymbol Construct(SymbolKeyReader reader, INamespaceOrTypeSymbol containerTypeOrNS, string name, int arity, ITypeSymbol[] typeArguments)
+            {
+                var result = reader.Compilation.CreateErrorTypeSymbol(containerTypeOrNS, name, arity);
+                return typeArguments != null ? result.Construct(typeArguments) : result;
             }
         }
     }

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

@@ -48,15 +48,16 @@ private static class ConstructedMethodSymbolKey
             public static void Create(IMethodSymbol symbol, SymbolKeyWriter visitor)
             {
                 visitor.WriteSymbolKey(symbol.ConstructedFrom);
-                visitor.WriteSymbolArray(symbol.TypeArguments);
+                visitor.WriteSymbolKeyArray(symbol.TypeArguments);
             }
 
             public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
             {
                 var constructedFrom = reader.ReadSymbolKey();
-                using var typeArguments = reader.ReadSymbolArray<ITypeSymbol>();
+                using var typeArguments = reader.ReadSymbolKeyArray<ITypeSymbol>();
 
-                if (constructedFrom.SymbolCount == 0)
+                if (constructedFrom.SymbolCount == 0 ||
+                    typeArguments.IsDefault)
                 {
                     return default;
                 }
@@ -164,7 +165,7 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                     // read out the values.  We don't actually need to use them, but we have
                     // to effectively read past them in the string.
 
-                    using (reader.ReadSymbolArray<ITypeSymbol>())
+                    using (reader.ReadSymbolKeyArray<ITypeSymbol>())
                     {
                         _ = reader.ReadSymbolKey();
                     }
@@ -213,7 +214,7 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
             private static IMethodSymbol Resolve(
                 SymbolKeyReader reader, bool isPartialMethodImplementationPart, IMethodSymbol method)
             {
-                using var originalParameterTypes = reader.ReadSymbolArray<ITypeSymbol>();
+                using var originalParameterTypes = reader.ReadSymbolKeyArray<ITypeSymbol>();
                 var returnType = (ITypeSymbol)reader.ReadSymbolKey().GetAnySymbol();
 
                 if (reader.ParameterTypesMatch(method.OriginalDefinition.Parameters, originalParameterTypes))

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

@@ -18,13 +18,11 @@ public static void Create(INamedTypeSymbol symbol, SymbolKeyWriter visitor)
 
                 if (!symbol.Equals(symbol.ConstructedFrom) && !symbol.IsUnboundGenericType)
                 {
-                    visitor.WriteBoolean(/*instantiate*/true);
-                    visitor.WriteSymbolArray(symbol.TypeArguments);
+                    visitor.WriteSymbolKeyArray(symbol.TypeArguments);
                 }
                 else
                 {
-                    visitor.WriteBoolean(/*instantiate*/false);
-                    visitor.WriteSymbolArray(ImmutableArray<ITypeSymbol>.Empty);
+                    visitor.WriteSymbolKeyArray(ImmutableArray<ITypeSymbol>.Empty);
                 }
             }
 
@@ -34,10 +32,9 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                 var containingSymbolResolution = reader.ReadSymbolKey();
                 var arity = reader.ReadInteger();
                 var isUnboundGenericType = reader.ReadBoolean();
-                var instantiate = reader.ReadBoolean();
-                using var typeArguments = reader.ReadSymbolArray<ITypeSymbol>();
+                using var typeArguments = reader.ReadSymbolKeyArray<ITypeSymbol>();
 
-                if (instantiate && arity != typeArguments.Count)
+                if (typeArguments.IsDefault)
                 {
                     return default;
                 }
@@ -52,7 +49,7 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                     {
                         Resolve(
                             result, nsOrType, metadataName, arity,
-                            isUnboundGenericType, instantiate, typeArgumentArray);
+                            isUnboundGenericType, typeArgumentArray);
                     }
                 }
 
@@ -65,12 +62,11 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                 string metadataName,
                 int arity,
                 bool isUnboundGenericType,
-                bool instantiate,
                 ITypeSymbol[] typeArguments)
             {
                 foreach (var type in container.GetTypeMembers(GetName(metadataName), arity))
                 {
-                    var currentType = instantiate ? type.Construct(typeArguments) : type;
+                    var currentType = typeArguments.Length > 0 ? type.Construct(typeArguments) : type;
                     currentType = isUnboundGenericType ? currentType.ConstructUnboundGenericType() : currentType;
 
                     result.AddIfNotNull(currentType);

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

@@ -15,6 +15,7 @@ internal partial struct SymbolKey
             private PooledArrayBuilder(ArrayBuilder<T> builder)
                 => Builder = builder;
 
+            public bool IsDefault => Builder == null;
             public int Count => Builder.Count;
             public T this[int index] => Builder[index];
 
@@ -26,7 +27,7 @@ public void AddIfNotNull(T value)
                 }
             }
 
-            public void Dispose() => Builder.Free();
+            public void Dispose() => Builder?.Free();
 
             public ImmutableArray<T> ToImmutable() => Builder.ToImmutable();
 

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

@@ -24,10 +24,9 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                 var isIndexer = reader.ReadBoolean();
 
                 using var refKinds = reader.ReadRefKindArray();
-                using var parameterTypes = reader.ReadSymbolArray<ITypeSymbol>();
+                using var parameterTypes = reader.ReadSymbolKeyArray<ITypeSymbol>();
 
-                Debug.Assert(parameterTypes.Count == 0 || parameterTypes.Count == refKinds.Count);
-                if (refKinds.Count != parameterTypes.Count)
+                if (parameterTypes.IsDefault)
                 {
                     return default;
                 }

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

@@ -340,7 +340,7 @@ public override void Dispose()
                 ImmutableArray<IParameterSymbol> parameters,
                 PooledArrayBuilder<ITypeSymbol> originalParameterTypes)
             {
-                if (parameters.Length != originalParameterTypes.Count)
+                if (originalParameterTypes.IsDefault || parameters.Length != originalParameterTypes.Count)
                 {
                     return false;
                 }
@@ -455,12 +455,12 @@ private SymbolKeyResolution ReadWorker(SymbolKeyType type)
 
             /// <summary>
             /// Reads an array of symbols out from the key.  Note: the number of symbols returned 
-            /// will either be the same as the original amount writtern, or it will be zero. It will
-            /// never be less or more.  Zero will be returned if the original array written had zero
-            /// elements, <b>or</b> if any elements could not be resolved to the requested
-            /// <typeparamref name="TSymbol"/> type in the provided <see cref="Compilation"/>.
+            /// will either be the same as the original amount writtern, or <c>default</c> will be 
+            /// returned. It will never be less or more.  <c>default</c> will be returned if any 
+            /// elements could not be resolved to the requested <typeparamref name="TSymbol"/> type 
+            /// in the provided <see cref="Compilation"/>.
             /// </summary>
-            public PooledArrayBuilder<TSymbol> ReadSymbolArray<TSymbol>() where TSymbol : ISymbol
+            public PooledArrayBuilder<TSymbol> ReadSymbolKeyArray<TSymbol>() where TSymbol : ISymbol
             {
                 using var resolutions = ReadArray(_readSymbolKey);
 
@@ -473,8 +473,7 @@ private SymbolKeyResolution ReadWorker(SymbolKeyType type)
                     }
                     else
                     {
-                        result.Builder.Clear();
-                        break;
+                        return default;
                     }
                 }
 

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

@@ -265,7 +265,7 @@ internal void WriteLocation(Location location)
             /// Writes out the provided symbols to the key.  The array provided must not
             /// be <c>default</c>.
             /// </summary>
-            internal void WriteSymbolArray<TSymbol>(ImmutableArray<TSymbol> symbols)
+            internal void WriteSymbolKeyArray<TSymbol>(ImmutableArray<TSymbol> symbols)
                 where TSymbol : ISymbol
             {
                 WriteArray(symbols, _writeSymbolKey);

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

@@ -52,12 +52,11 @@ public static SymbolKeyResolution Resolve(SymbolKeyReader reader)
                 var isError = reader.ReadBoolean();
                 if (isError)
                 {
-                    using var elementTypes = reader.ReadSymbolArray<ITypeSymbol>();
+                    using var elementTypes = reader.ReadSymbolKeyArray<ITypeSymbol>();
                     using var elementNames = reader.ReadStringArray();
                     var elementLocations = ReadElementLocations(reader);
 
-                    Debug.Assert(elementTypes.Count == 0 || elementTypes.Count == elementNames.Count);
-                    if (elementTypes.Count == elementNames.Count)
+                    if (elementTypes.IsDefault)
                     {
                         try
                         {