Make Graph and Multigraph fully internal

src/EFCore/Metadata/Conventions/ModelCleanupConvention.cs

@@ -7,6 +7,7 @@
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata.Internal;
+using Microsoft.EntityFrameworkCore.Utilities;
 
 namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
 {
@@ -30,7 +31,8 @@ public ModelCleanupConvention([NotNull] ProviderConventionSetBuilderDependencies
         protected virtual ProviderConventionSetBuilderDependencies Dependencies { get; }
 
         /// <inheritdoc />
-        public virtual void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
+        public virtual void ProcessModelFinalizing(
+            IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
         {
             RemoveEntityTypesUnreachableByNavigations(modelBuilder, context);
             RemoveNavigationlessForeignKeys(modelBuilder);
@@ -44,7 +46,7 @@ private void RemoveEntityTypesUnreachableByNavigations(
             var rootEntityTypes = GetRoots(model, ConfigurationSource.DataAnnotation);
             using (context.DelayConventions())
             {
-                foreach (var orphan in new ModelNavigationsGraphAdapter(model).GetUnreachableVertices(rootEntityTypes))
+                foreach (var orphan in new GraphAdapter(model).GetUnreachableVertices(rootEntityTypes))
                 {
                     modelBuilder.HasNoEntityType(orphan, fromDataAnnotation: true);
                 }
@@ -90,5 +92,28 @@ private void RemoveModelBuildingAnnotations(IConventionModelBuilder modelBuilder
                 entityType.RemoveAnnotation(CoreAnnotationNames.NavigationCandidates);
             }
         }
+
+        private sealed class GraphAdapter : Graph<IConventionEntityType>
+        {
+            private readonly IConventionModel _model;
+
+            public GraphAdapter([NotNull] IConventionModel model)
+            {
+                _model = model;
+            }
+
+            public override IEnumerable<IConventionEntityType> Vertices => _model.GetEntityTypes();
+
+            public override IEnumerable<IConventionEntityType> GetOutgoingNeighbors(IConventionEntityType from)
+                => from.GetForeignKeys().Where(fk => fk.DependentToPrincipal != null).Select(fk => fk.PrincipalEntityType)
+                    .Union(
+                        from.GetReferencingForeignKeys().Where(fk => fk.PrincipalToDependent != null).Select(fk => fk.DeclaringEntityType));
+
+            public override IEnumerable<IConventionEntityType> GetIncomingNeighbors(IConventionEntityType to)
+                => to.GetForeignKeys().Where(fk => fk.PrincipalToDependent != null).Select(fk => fk.PrincipalEntityType)
+                    .Union(
+                        to.GetReferencingForeignKeys().Where(fk => fk.DependentToPrincipal != null).Select(fk => fk.DeclaringEntityType));
+        }
     }
 }
+

src/Shared/Graph.cs

@@ -0,0 +1,41 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using JetBrains.Annotations;
+
+namespace Microsoft.EntityFrameworkCore.Utilities
+{
+    internal abstract class Graph<TVertex>
+    {
+        public abstract IEnumerable<TVertex> Vertices { get; }
+
+        public abstract IEnumerable<TVertex> GetOutgoingNeighbors([NotNull] TVertex from);
+
+        public abstract IEnumerable<TVertex> GetIncomingNeighbors([NotNull] TVertex to);
+
+        public virtual ISet<TVertex> GetUnreachableVertices([NotNull] IReadOnlyList<TVertex> roots)
+        {
+            var unreachableVertices = new HashSet<TVertex>(Vertices);
+            unreachableVertices.ExceptWith(roots);
+            var visitingQueue = new List<TVertex>(roots);
+
+            var currentVertexIndex = 0;
+            while (currentVertexIndex < visitingQueue.Count)
+            {
+                var currentVertex = visitingQueue[currentVertexIndex];
+                currentVertexIndex++;
+                // ReSharper disable once LoopCanBeConvertedToQuery
+                foreach (var neighbor in GetOutgoingNeighbors(currentVertex))
+                {
+                    if (unreachableVertices.Remove(neighbor))
+                    {
+                        visitingQueue.Add(neighbor);
+                    }
+                }
+            }
+
+            return unreachableVertices;
+        }
+    }
+}

src/Shared/Multigraph.cs

@@ -6,13 +6,10 @@
 using System.Linq;
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Diagnostics;
-using Microsoft.EntityFrameworkCore.Internal;
 
 namespace Microsoft.EntityFrameworkCore.Utilities
 {
-#pragma warning disable EF1001 // Internal EF Core API usage.
     internal class Multigraph<TVertex, TEdge> : Graph<TVertex>
-#pragma warning restore EF1001 // Internal EF Core API usage.
     {
         private readonly HashSet<TVertex> _vertices = new HashSet<TVertex>();