Remove the term "whitelist"

src/Compilers/Core/VBCSCompiler/AnalyzerConsistencyChecker.cs

@@ -12,19 +12,19 @@ namespace Microsoft.CodeAnalysis.CompilerServer
 {
     internal static class AnalyzerConsistencyChecker
     {
-        private static readonly ImmutableArray<string> s_defaultWhiteList = ImmutableArray.Create("mscorlib", "System", "Microsoft.CodeAnalysis");
+        private static readonly ImmutableArray<string> s_defaultIgnorableReferenceNames = ImmutableArray.Create("mscorlib", "System", "Microsoft.CodeAnalysis");
 
-        public static bool Check(string baseDirectory, IEnumerable<CommandLineAnalyzerReference> analyzerReferences, IAnalyzerAssemblyLoader loader, IEnumerable<string> referenceWhiteList = null)
+        public static bool Check(string baseDirectory, IEnumerable<CommandLineAnalyzerReference> analyzerReferences, IAnalyzerAssemblyLoader loader, IEnumerable<string> ignorableReferenceNames = null)
         {
-            if (referenceWhiteList == null)
+            if (ignorableReferenceNames == null)
             {
-                referenceWhiteList = s_defaultWhiteList;
+                ignorableReferenceNames = s_defaultIgnorableReferenceNames;
             }
 
             try
             {
                 CompilerServerLogger.Log("Begin Analyzer Consistency Check");
-                return CheckCore(baseDirectory, analyzerReferences, loader, referenceWhiteList);
+                return CheckCore(baseDirectory, analyzerReferences, loader, ignorableReferenceNames);
             }
             catch (Exception e)
             {
@@ -37,7 +37,7 @@ public static bool Check(string baseDirectory, IEnumerable<CommandLineAnalyzerRe
             }
         }
 
-        private static bool CheckCore(string baseDirectory, IEnumerable<CommandLineAnalyzerReference> analyzerReferences, IAnalyzerAssemblyLoader loader, IEnumerable<string> referenceWhiteList)
+        private static bool CheckCore(string baseDirectory, IEnumerable<CommandLineAnalyzerReference> analyzerReferences, IAnalyzerAssemblyLoader loader, IEnumerable<string> ignorableReferenceNames)
         {
             var resolvedPaths = new List<string>();
 
@@ -56,14 +56,14 @@ private static bool CheckCore(string baseDirectory, IEnumerable<CommandLineAnaly
                 // Don't worry about paths we can't resolve. The compiler will report an error for that later.
             }
 
-            // First, check that the set of references is complete, modulo items in the whitelist.
+            // First, check that the set of references is complete, modulo items in the safe list.
             foreach (var resolvedPath in resolvedPaths)
             {
                 var missingDependencies = AssemblyUtilities.IdentifyMissingDependencies(resolvedPath, resolvedPaths);
 
                 foreach (var missingDependency in missingDependencies)
                 {
-                    if (!referenceWhiteList.Any(name => missingDependency.Name.StartsWith(name)))
+                    if (!ignorableReferenceNames.Any(name => missingDependency.Name.StartsWith(name)))
                     {
                         CompilerServerLogger.Log($"Analyzer assembly {resolvedPath} depends on '{missingDependency}' but it was not found.");
                         return false;

src/VisualStudio/Core/Def/Implementation/AnalyzerDependencyChecker.cs

@@ -17,16 +17,16 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation
     internal sealed class AnalyzerDependencyChecker
     {
         private readonly HashSet<string> _analyzerFilePaths;
-        private readonly List<IAssemblyWhiteList> _assemblyWhiteLists;
+        private readonly List<IIgnorableAssemblyList> _ignorableAssemblyLists;
         private readonly IBindingRedirectionService _bindingRedirectionService;
 
-        public AnalyzerDependencyChecker(IEnumerable<string> analyzerFilePaths, IEnumerable<IAssemblyWhiteList> assemblyWhiteLists, IBindingRedirectionService bindingRedirectionService = null)
+        public AnalyzerDependencyChecker(IEnumerable<string> analyzerFilePaths, IEnumerable<IIgnorableAssemblyList> ignorableAssemblyLists, IBindingRedirectionService bindingRedirectionService = null)
         {
             Debug.Assert(analyzerFilePaths != null);
-            Debug.Assert(assemblyWhiteLists != null);
+            Debug.Assert(ignorableAssemblyLists != null);
 
             _analyzerFilePaths = new HashSet<string>(analyzerFilePaths, StringComparer.OrdinalIgnoreCase);
-            _assemblyWhiteLists = assemblyWhiteLists.ToList();
+            _ignorableAssemblyLists = ignorableAssemblyLists.ToList();
             _bindingRedirectionService = bindingRedirectionService;
         }
 
@@ -46,7 +46,7 @@ public AnalyzerDependencyResults Run(CancellationToken cancellationToken = defau
                 }
             }
 
-            _assemblyWhiteLists.Add(new AssemblyIdentityWhiteList(analyzerInfos.Select(info => info.Identity)));
+            _ignorableAssemblyLists.Add(new IgnorableAssemblyIdentityList(analyzerInfos.Select(info => info.Identity)));
 
             // First check for analyzers with the same identity but different
             // contents (that is, different MVIDs).
@@ -74,7 +74,7 @@ private ImmutableArray<MissingAnalyzerDependency> FindMissingDependencies(List<A
                         ? _bindingRedirectionService.ApplyBindingRedirects(reference)
                         : reference;
 
-                    if (!_assemblyWhiteLists.Any(whiteList => whiteList.Includes(redirectedReference)))
+                    if (!_ignorableAssemblyLists.Any(ignorableAssemblyList => ignorableAssemblyList.Includes(redirectedReference)))
                     {
                         builder.Add(new MissingAnalyzerDependency(
                             analyzerInfo.Path,

src/VisualStudio/Core/Def/Implementation/AnalyzerDependencyCheckingService.cs

@@ -20,7 +20,7 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation
     internal sealed class AnalyzerDependencyCheckingService
     {
         private static readonly object s_dependencyConflictErrorId = new object();
-        private static readonly IAssemblyWhiteList s_systemPrefixWhiteList = new AssemblyNamePrefixWhiteList("System");
+        private static readonly IIgnorableAssemblyList s_systemPrefixList = new IgnorableAssemblyNamePrefixList("System");
 
         private readonly VisualStudioWorkspaceImpl _workspace;
         private readonly HostDiagnosticUpdateSource _updateSource;
@@ -194,10 +194,10 @@ private Task<AnalyzerDependencyResults> GetConflictsAsync()
             _task = _task.SafeContinueWith(_ =>
             {
                 IEnumerable<AssemblyIdentity> loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().Select(assembly => AssemblyIdentity.FromAssemblyDefinition(assembly));
-                AssemblyIdentityWhiteList loadedAssembliesWhiteList = new AssemblyIdentityWhiteList(loadedAssemblies);
-                IAssemblyWhiteList[] whiteLists = new[] { s_systemPrefixWhiteList, loadedAssembliesWhiteList };
+                IgnorableAssemblyIdentityList loadedAssembliesList = new IgnorableAssemblyIdentityList(loadedAssemblies);
+                IIgnorableAssemblyList[] ignorableAssemblyLists = new[] { s_systemPrefixList, loadedAssembliesList };
 
-                return new AnalyzerDependencyChecker(currentAnalyzerPaths, whiteLists, _bindingRedirectionService).Run(_cancellationTokenSource.Token);
+                return new AnalyzerDependencyChecker(currentAnalyzerPaths, ignorableAssemblyLists, _bindingRedirectionService).Run(_cancellationTokenSource.Token);
             },
             TaskScheduler.Default);
 

src/VisualStudio/Core/Def/Implementation/IAssemblyWhiteList.cs → src/VisualStudio/Core/Def/Implementation/IIgnorableAssemblyList.cs

@@ -4,7 +4,7 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation
 {
-    internal interface IAssemblyWhiteList
+    internal interface IIgnorableAssemblyList
     {
         bool Includes(AssemblyIdentity assemblyIdentity);
     }

src/VisualStudio/Core/Def/Implementation/AssemblyIdentityWhiteList.cs → src/VisualStudio/Core/Def/Implementation/IgnorableAssemblyIdentityList.cs

@@ -6,11 +6,11 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation
 {
-    internal sealed class AssemblyIdentityWhiteList : IAssemblyWhiteList
+    internal sealed class IgnorableAssemblyIdentityList : IIgnorableAssemblyList
     {
         private readonly HashSet<AssemblyIdentity> _assemblyIdentities;
 
-        public AssemblyIdentityWhiteList(IEnumerable<AssemblyIdentity> assemblyIdentities)
+        public IgnorableAssemblyIdentityList(IEnumerable<AssemblyIdentity> assemblyIdentities)
         {
             Debug.Assert(assemblyIdentities != null);
 

src/VisualStudio/Core/Def/Implementation/AssemblyNamePrefixWhiteList.cs → src/VisualStudio/Core/Def/Implementation/IgnorableAssemblyNamePrefixList.cs

@@ -5,11 +5,11 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation
 {
-    internal sealed class AssemblyNamePrefixWhiteList : IAssemblyWhiteList
+    internal sealed class IgnorableAssemblyNamePrefixList : IIgnorableAssemblyList
     {
         private readonly string _prefix;
 
-        public AssemblyNamePrefixWhiteList(string prefix)
+        public IgnorableAssemblyNamePrefixList(string prefix)
         {
             Debug.Assert(prefix != null);
 

src/VisualStudio/Core/Def/ServicesVisualStudio.csproj

@@ -32,12 +32,12 @@
     <Compile Include="Implementation\AnalyzerDependencyChecker.cs" />
     <Compile Include="Implementation\AnalyzerDependencyCheckingService.cs" />
     <Compile Include="Implementation\AnalyzerDependencyConflict.cs" />
-    <Compile Include="Implementation\AssemblyIdentityWhiteList.cs" />
-    <Compile Include="Implementation\AssemblyNamePrefixWhiteList.cs" />
+    <Compile Include="Implementation\IgnorableAssemblyIdentityList.cs" />
+    <Compile Include="Implementation\IgnorableAssemblyNamePrefixList.cs" />
     <Compile Include="Implementation\CompilationErrorTelemetry\CompilationErrorTelemetryIncrementalAnalyzer.cs" />
     <Compile Include="Implementation\Diagnostics\VisualStudioVenusSpanMappingService.cs" />
     <Compile Include="Implementation\EditAndContinue\Interop\NativeMethods.cs" />
-    <Compile Include="Implementation\IAssemblyWhiteList.cs" />
+    <Compile Include="Implementation\IIgnorableAssemblyList.cs" />
     <Compile Include="Implementation\IBindingRedirectionService.cs" />
     <Compile Include="Implementation\LanguageService\AbstractLanguageService`2.IVsLanguageBlock.cs" />
     <Compile Include="Implementation\Library\FindResults\TreeItems\AbstractSourceTreeItem.cs" />