ApiDiff: Pass an ILog instance to the AssemblySymbolLoader constructor

src/Compatibility/ApiCompat/Microsoft.DotNet.ApiCompat.Shared/ApiCompatServiceProvider.cs

@@ -49,7 +49,7 @@ public ApiCompatServiceProvider(Func<ISuppressionEngine, ISuppressibleLog> logFa
                 return new ApiCompatRunner(SuppressibleLog,
                     SuppressionEngine,
                     new ApiComparerFactory(ruleFactory(SuppressibleLog), apiComparerSettings),
-                    new AssemblySymbolLoaderFactory(respectInternals));
+                    new AssemblySymbolLoaderFactory(SuppressibleLog, respectInternals));
             });
         }
 

src/Compatibility/ApiCompat/Microsoft.DotNet.ApiCompatibility/DiagnosticIds.cs

@@ -29,8 +29,5 @@ public static class DiagnosticIds
         public const string CannotReduceVisibility = "CP0019";
         public const string CannotExpandVisibility = "CP0020";
         public const string CannotChangeGenericConstraint = "CP0021";
-
-        // Assembly loading ids
-        public const string AssemblyReferenceNotFound = "CP1002";
     }
 }

src/Compatibility/ApiCompat/Microsoft.DotNet.ApiCompatibility/Mapping/AssemblyMapper.cs

@@ -121,20 +121,6 @@ Dictionary<INamespaceSymbol, List<INamedTypeSymbol>> ResolveTypeForwards(Element
 
                             types.Add(symbol);
                         }
-                        else
-                        {
-                            // If we should warn on missing references and we are unable to resolve the type forward, then we should log a diagnostic
-                            if (Settings.WithReferences)
-                            {
-                                _assemblyLoadErrors.Add(new CompatDifference(
-                                    side == ElementSide.Left ? assembly.MetadataInformation : MetadataInformation.DefaultLeft,
-                                    side == ElementSide.Right ? assembly.MetadataInformation : MetadataInformation.DefaultRight,
-                                    DiagnosticIds.AssemblyReferenceNotFound,
-                                    string.Format(Resources.MatchingAssemblyNotFound, $"{symbol.ContainingAssembly.Name}.dll"),
-                                    DifferenceType.Changed,
-                                    symbol.ContainingAssembly.Identity.GetDisplayName()));
-                            }
-                        }
                     }
 
                     return typeForwards;

src/Compatibility/ApiCompat/Microsoft.DotNet.ApiCompatibility/Resources.resx

@@ -147,9 +147,6 @@
   <data name="IndexShouldBeWithinSetSizeRange" xml:space="preserve">
     <value>The {0} index should be in the range zero through {1} inclusive.</value>
   </data>
-  <data name="MatchingAssemblyNotFound" xml:space="preserve">
-    <value>Could not find matching assembly: '{0}' in any of the search directories.</value>
-  </data>
   <data name="MemberExistsOnLeft" xml:space="preserve">
     <value>Member '{0}' exists on {1} but not on {2}</value>
   </data>

src/Compatibility/ApiCompat/Microsoft.DotNet.ApiCompatibility/Rules/CannotRemoveBaseTypeOrInterface.cs

@@ -48,11 +48,6 @@ private void ValidateBaseTypeNotRemoved(ITypeSymbol left, ITypeSymbol right, str
             if (leftBaseType == null)
                 return;
 
-            if (leftBaseType.TypeKind == TypeKind.Error && _settings.WithReferences)
-            {
-                AddAssemblyLoadError(leftMetadata, rightMetadata, differences, leftBaseType);
-            }
-
             while (rightBaseType != null)
             {
                 // If we found the immediate left base type on right we can assume
@@ -61,11 +56,6 @@ private void ValidateBaseTypeNotRemoved(ITypeSymbol left, ITypeSymbol right, str
                 if (_settings.SymbolEqualityComparer.Equals(leftBaseType, rightBaseType))
                     return;
 
-                if (rightBaseType.TypeKind == TypeKind.Error && _settings.WithReferences)
-                {
-                    AddAssemblyLoadError(leftMetadata, rightMetadata, differences, rightBaseType);
-                }
-
                 rightBaseType = rightBaseType.BaseType;
             }
 
@@ -84,11 +74,6 @@ private void ValidateInterfaceNotRemoved(ITypeSymbol left, ITypeSymbol right, st
 
             foreach (ITypeSymbol leftInterface in left.GetAllBaseInterfaces())
             {
-                if (leftInterface.TypeKind == TypeKind.Error && _settings.WithReferences)
-                {
-                    AddAssemblyLoadError(leftMetadata, rightMetadata, differences, leftInterface);
-                }
-
                 // Ignore non visible interfaces based on the run Settings
                 // If TypeKind == Error it means the Roslyn couldn't resolve it,
                 // so we are running with a missing assembly reference to where that type ef is defined.
@@ -108,25 +93,6 @@ private void ValidateInterfaceNotRemoved(ITypeSymbol left, ITypeSymbol right, st
                     return;
                 }
             }
-
-            foreach (ITypeSymbol rightInterface in rightInterfaces)
-            {
-                if (rightInterface.TypeKind == TypeKind.Error && _settings.WithReferences)
-                {
-                    AddAssemblyLoadError(leftMetadata, rightMetadata, differences, rightInterface);
-                }
-            }
-        }
-
-        private static void AddAssemblyLoadError(MetadataInformation leftMetadata, MetadataInformation rightMetadata, IList<CompatDifference> differences, ITypeSymbol type)
-        {
-            differences.Add(new CompatDifference(
-                leftMetadata,
-                rightMetadata,
-                DiagnosticIds.AssemblyReferenceNotFound,
-                string.Format(Resources.MatchingAssemblyNotFound, $"{type.ContainingAssembly.Name}.dll"),
-                DifferenceType.Changed,
-                type.ContainingAssembly.Identity.GetDisplayName()));
         }
     }
 }

src/Compatibility/ApiCompat/Microsoft.DotNet.ApiCompatibility/Rules/RuleSettings.cs

@@ -43,10 +43,5 @@ public interface IRuleSettings
         /// which are compared, should not differ.
         /// </summary>
         bool StrictMode { get; }
-
-        /// <summary>
-        /// If true, references are available. Necessary to know for following type forwards.
-        /// </summary>
-        bool WithReferences { get; }
     }
 }

src/Compatibility/GenAPI/Microsoft.DotNet.GenAPI/CSharpFileBuilder.cs

@@ -25,7 +25,7 @@ namespace Microsoft.DotNet.GenAPI
     /// </summary>
     public sealed class CSharpFileBuilder : IAssemblySymbolWriter, IDisposable
     {
-        private readonly ILog _logger;
+        private readonly ILog _log;
         private readonly TextWriter _textWriter;
         private readonly ISymbolFilter _symbolFilter;
         private readonly ISymbolFilter _attributeDataSymbolFilter;
@@ -36,7 +36,7 @@ public sealed class CSharpFileBuilder : IAssemblySymbolWriter, IDisposable
         private readonly IEnumerable<MetadataReference> _metadataReferences;
         private readonly bool _addPartialModifier;
 
-        public CSharpFileBuilder(ILog logger,
+        public CSharpFileBuilder(ILog log,
             ISymbolFilter symbolFilter,
             ISymbolFilter attributeDataSymbolFilter,
             TextWriter textWriter,
@@ -45,7 +45,7 @@ public CSharpFileBuilder(ILog logger,
             IEnumerable<MetadataReference> metadataReferences,
             bool addPartialModifier)
         {
-            _logger = logger;
+            _log = log;
             _textWriter = textWriter;
             _symbolFilter = symbolFilter;
             _attributeDataSymbolFilter = attributeDataSymbolFilter;
@@ -296,7 +296,7 @@ private SyntaxNode GenerateForwardedTypeAssemblyAttributes(IAssemblySymbol assem
                 }
                 else
                 {
-                    _logger.LogWarning(string.Format(
+                    _log.LogWarning(string.Format(
                         Resources.ResolveTypeForwardFailed,
                         symbol.ToDisplayString(),
                         $"{symbol.ContainingAssembly.Name}.dll"));

src/Compatibility/GenAPI/Microsoft.DotNet.GenAPI/GenAPIApp.cs

@@ -20,7 +20,7 @@ public static class GenAPIApp
         /// <summary>
         /// Initialize and run Roslyn-based GenAPI tool.
         /// </summary>
-        public static void Run(ILog logger,
+        public static void Run(ILog log,
             string[] assemblies,
             string[]? assemblyReferences,
             string? outputPath,
@@ -34,7 +34,7 @@ public static void Run(ILog logger,
             bool resolveAssemblyReferences = assemblyReferences?.Length > 0;
 
             // Create, configure and execute the assembly loader.
-            AssemblySymbolLoader loader = new(resolveAssemblyReferences, respectInternals);
+            AssemblySymbolLoader loader = new(log, resolveAssemblyReferences, respectInternals);
             if (assemblyReferences is not null)
             {
                 loader.AddReferenceSearchPaths(assemblyReferences);
@@ -74,7 +74,7 @@ public static void Run(ILog logger,
                 using TextWriter textWriter = GetTextWriter(outputPath, assemblySymbol.Name);
                 textWriter.Write(headerFileText);
 
-                using CSharpFileBuilder fileBuilder = new(logger,
+                using CSharpFileBuilder fileBuilder = new(log,
                     symbolFilter,
                     attributeDataSymbolFilter,
                     textWriter,
@@ -85,22 +85,6 @@ public static void Run(ILog logger,
 
                 fileBuilder.WriteAssembly(assemblySymbol);
             }
-
-            if (loader.HasRoslynDiagnostics(out IReadOnlyList<Diagnostic> roslynDiagnostics))
-            {
-                foreach (Diagnostic warning in roslynDiagnostics)
-                {
-                    logger.LogWarning(warning.Id, warning.ToString());
-                }
-            }
-
-            if (loader.HasLoadWarnings(out IReadOnlyList<AssemblyLoadWarning> loadWarnings))
-            {
-                foreach (AssemblyLoadWarning warning in loadWarnings)
-                {
-                    logger.LogWarning(warning.DiagnosticId, warning.Message);
-                }
-            }
         }
 
         // Creates a TextWriter capable of writing into Console or a cs file.