From b03ecaec78383bda4080cf16a201db1a5abd86c3 Mon Sep 17 00:00:00 2001
From: Owen Smith <owen@omsmith.ca>
Date: Mon, 4 Jul 2022 09:12:46 -0400
Subject: [PATCH] use new GetTypesByMetadataName in ImmutabilityContext.Factory

Closes: https://github.com/Brightspace/D2L.CodeStyle/issues/851
---
 .../ImmutabilityContext.Factory.cs            | 56 ++++++++-----------
 1 file changed, 22 insertions(+), 34 deletions(-)

diff --git a/src/D2L.CodeStyle.Analyzers/Immutability/ImmutabilityContext.Factory.cs b/src/D2L.CodeStyle.Analyzers/Immutability/ImmutabilityContext.Factory.cs
index 030a1daa..06b715e0 100644
--- a/src/D2L.CodeStyle.Analyzers/Immutability/ImmutabilityContext.Factory.cs
+++ b/src/D2L.CodeStyle.Analyzers/Immutability/ImmutabilityContext.Factory.cs
@@ -101,13 +101,11 @@ internal static ImmutabilityContext Create(
 				additionalImmutableTypes = ImmutableHashSet<string>.Empty;
 			}
 
-			ImmutableDictionary<string, IAssemblySymbol> compilationAssemblies = GetCompilationAssemblies( compilation );
-
 			// Generate a dictionary of types that we have specifically determined
 			// should be considered Immutable by the Analyzer.
 			var extraImmutableTypesBuilder = ImmutableDictionary.CreateBuilder<INamedTypeSymbol, ImmutableTypeInfo>( SymbolEqualityComparer.Default );
 			foreach( ( string typeName, string qualifiedAssembly ) in DefaultExtraTypes ) {
-				INamedTypeSymbol type = GetTypeSymbol( compilationAssemblies, compilation, qualifiedAssembly, typeName );
+				INamedTypeSymbol type = GetTypeSymbol( compilation, qualifiedAssembly, typeName );
 
 				if( type == null ) {
 					continue;
@@ -122,7 +120,7 @@ internal static ImmutabilityContext Create(
 			}
 
 			foreach( string typeName in additionalImmutableTypes ) {
-				INamedTypeSymbol type = GetTypeSymbol( compilationAssemblies, compilation, qualifiedAssembly: default, typeName );
+				INamedTypeSymbol type = GetTypeSymbol( compilation, qualifiedAssembly: default, typeName );
 
 				if( type == null ) {
 					continue;
@@ -144,7 +142,7 @@ internal static ImmutabilityContext Create(
 			// have a return value which should be considered Immutable by the Analyzer.
 			var knownImmutableReturnsBuilder = ImmutableHashSet.CreateBuilder<IMethodSymbol>( SymbolEqualityComparer.Default );
 			foreach( ( string typeName, string methodName, string qualifiedAssembly ) in KnownImmutableReturningMethods ) {
-				INamedTypeSymbol type = GetTypeSymbol( compilationAssemblies, compilation, qualifiedAssembly, typeName );
+				INamedTypeSymbol type = GetTypeSymbol( compilation, qualifiedAssembly, typeName );
 
 				if( type == null ) {
 					continue;
@@ -169,51 +167,41 @@ internal static ImmutabilityContext Create(
 				knownImmutableReturns: knownImmutableReturnsBuilder.ToImmutable(),
 				conditionalTypeParamemters: ImmutableHashSet<ITypeParameterSymbol>.Empty,
 				regexInfo: (
-					GetTypeSymbol( compilationAssemblies, compilation, default, "System.Text.RegularExpressions.Regex" ),
-					GetTypeSymbol( compilationAssemblies, compilation, default, "System.CodeDom.Compiler.GeneratedCodeAttribute" )
+					GetTypeSymbol( compilation, default, "System.Text.RegularExpressions.Regex" ),
+					GetTypeSymbol( compilation, default, "System.CodeDom.Compiler.GeneratedCodeAttribute" )
 				)
 			);
 		}
 
-		private static ImmutableDictionary<string, IAssemblySymbol> GetCompilationAssemblies( Compilation compilation ) {
-			var builder = ImmutableDictionary.CreateBuilder<string, IAssemblySymbol>();
-
-			IAssemblySymbol compilationAssmebly = compilation.Assembly;
-
-			builder.Add( compilationAssmebly.Name, compilationAssmebly );
-
-			foreach( IModuleSymbol module in compilationAssmebly.Modules ) {
-				foreach( IAssemblySymbol assembly in module.ReferencedAssemblySymbols ) {
-					builder.Add( assembly.Name, assembly );
-				}
-			}
-
-			return builder.ToImmutable();
-		}
-
 		private static INamedTypeSymbol GetTypeSymbol(
-			ImmutableDictionary<string, IAssemblySymbol> compilationAssemblies,
 			Compilation compilation,
 			string qualifiedAssembly,
 			string typeName
 		) {
-			INamedTypeSymbol type;
 
-			if( string.IsNullOrEmpty( qualifiedAssembly ) ) {
-				type = compilation.GetTypeByMetadataName( typeName );
-			} else {
-				if( !compilationAssemblies.TryGetValue( qualifiedAssembly, out IAssemblySymbol assembly ) ) {
-					return null;
+			ImmutableArray<INamedTypeSymbol> types = compilation.GetTypesByMetadataName( typeName );
+
+			if( types.IsEmpty ) {
+				return null;
+			}
+
+			if( qualifiedAssembly == default ) {
+				if( types.Length > 1 ) {
+					throw new InvalidOperationException(
+						$"Found multiple {typeName} with no {nameof( qualifiedAssembly )} specified when building ImmutabilityContext."
+					);
 				}
 
-				type = assembly.GetTypeByMetadataName( typeName );
+				return types[ 0 ];
 			}
 
-			if( type == null || type.Kind == SymbolKind.ErrorType ) {
-				return null;
+			foreach( INamedTypeSymbol type in types ) {
+				if( type.ContainingAssembly.Name.Equals( qualifiedAssembly, StringComparison.Ordinal ) ) {
+					return type;
+				}
 			}
 
-			return type;
+			return null;
 		}
 
 	}