diff --git a/src/EFCore/Query/NotParameterizedAttribute.cs b/src/EFCore.Abstractions/Query/NotParameterizedAttribute.cs
similarity index 100%
rename from src/EFCore/Query/NotParameterizedAttribute.cs
rename to src/EFCore.Abstractions/Query/NotParameterizedAttribute.cs
diff --git a/src/EFCore/Extensions/ConventionForeignKeyExtensions.cs b/src/EFCore/Extensions/ConventionForeignKeyExtensions.cs
index 6c92de2c571..10493c7fb4d 100644
--- a/src/EFCore/Extensions/ConventionForeignKeyExtensions.cs
+++ b/src/EFCore/Extensions/ConventionForeignKeyExtensions.cs
@@ -18,9 +18,9 @@ public static class ConventionForeignKeyExtensions
         /// <param name="foreignKey"> The foreign key. </param>
         /// <param name="entityType"> One of the entity types related by the foreign key. </param>
         /// <returns> The entity type related to the given one. </returns>
-        public static IConventionEntityType ResolveOtherEntityType(
+        public static IConventionEntityType GetRelatedEntityType(
             [NotNull] this IConventionForeignKey foreignKey, [NotNull] IConventionEntityType entityType)
-            => (IConventionEntityType)((IForeignKey)foreignKey).ResolveOtherEntityType(entityType);
+            => (IConventionEntityType)((IForeignKey)foreignKey).GetRelatedEntityType(entityType);
 
         /// <summary>
         ///     Returns a navigation associated with this foreign key.
diff --git a/src/EFCore/Extensions/ConventionModelExtensions.cs b/src/EFCore/Extensions/ConventionModelExtensions.cs
index c5f63820bf0..49a8aeb8101 100644
--- a/src/EFCore/Extensions/ConventionModelExtensions.cs
+++ b/src/EFCore/Extensions/ConventionModelExtensions.cs
@@ -223,10 +223,10 @@ public static void AddOwned([NotNull] this IConventionModel model, [NotNull] Typ
         ///     Indicates whether the given entity type name is ignored.
         /// </summary>
         /// <param name="model"> The model to check for ignored type. </param>
-        /// <param name="name"> The name of the entity type that could be ignored. </param>
+        /// <param name="typeName"> The name of the entity type that could be ignored. </param>
         /// <returns> <c>true</c> if the given entity type name is ignored. </returns>
-        public static bool IsIgnored([NotNull] this IConventionModel model, [NotNull] string name)
-            => model.FindIgnoredConfigurationSource(name) != null;
+        public static bool IsIgnored([NotNull] this IConventionModel model, [NotNull] string typeName)
+            => model.FindIgnoredConfigurationSource(typeName) != null;
 
         /// <summary>
         ///     Indicates whether the given entity type is ignored.
diff --git a/src/EFCore/Extensions/ConventionTypeBaseExtensions.cs b/src/EFCore/Extensions/ConventionTypeBaseExtensions.cs
index a17ed845510..bfba70d169e 100644
--- a/src/EFCore/Extensions/ConventionTypeBaseExtensions.cs
+++ b/src/EFCore/Extensions/ConventionTypeBaseExtensions.cs
@@ -18,10 +18,10 @@ public static class ConventionTypeBaseExtensions
         ///     Indicates whether the given member name is ignored.
         /// </summary>
         /// <param name="entityType"> The type to check the ignored member. </param>
-        /// <param name="name"> The name of the member that might be ignored. </param>
+        /// <param name="memberName"> The name of the member that might be ignored. </param>
         /// <returns> <c>true</c> if the given member name is ignored. </returns>
-        public static bool IsIgnored([NotNull] this IConventionTypeBase entityType, [NotNull] string name)
-            => entityType.FindIgnoredConfigurationSource(name) != null;
+        public static bool IsIgnored([NotNull] this IConventionTypeBase entityType, [NotNull] string memberName)
+            => entityType.FindIgnoredConfigurationSource(memberName) != null;
 
         /// <summary>
         ///     <para>
diff --git a/src/EFCore/Extensions/ForeignKeyExtensions.cs b/src/EFCore/Extensions/ForeignKeyExtensions.cs
index 8004d25ba4a..2dd4db6afd5 100644
--- a/src/EFCore/Extensions/ForeignKeyExtensions.cs
+++ b/src/EFCore/Extensions/ForeignKeyExtensions.cs
@@ -20,7 +20,7 @@ public static class ForeignKeyExtensions
         /// <param name="foreignKey"> The foreign key. </param>
         /// <param name="entityType"> One of the entity types related by the foreign key. </param>
         /// <returns> The entity type related to the given one. </returns>
-        public static IEntityType ResolveOtherEntityType([NotNull] this IForeignKey foreignKey, [NotNull] IEntityType entityType)
+        public static IEntityType GetRelatedEntityType([NotNull] this IForeignKey foreignKey, [NotNull] IEntityType entityType)
         {
             if (foreignKey.DeclaringEntityType != entityType
                 && foreignKey.PrincipalEntityType != entityType)
diff --git a/src/EFCore/Extensions/MutableForeignKeyExtensions.cs b/src/EFCore/Extensions/MutableForeignKeyExtensions.cs
index 63ed6f2445b..f5a8dd1fb23 100644
--- a/src/EFCore/Extensions/MutableForeignKeyExtensions.cs
+++ b/src/EFCore/Extensions/MutableForeignKeyExtensions.cs
@@ -18,9 +18,9 @@ public static class MutableForeignKeyExtensions
         /// <param name="foreignKey"> The foreign key. </param>
         /// <param name="entityType"> One of the entity types related by the foreign key. </param>
         /// <returns> The entity type related to the given one. </returns>
-        public static IMutableEntityType ResolveOtherEntityType(
+        public static IMutableEntityType GetRelatedEntityType(
             [NotNull] this IMutableForeignKey foreignKey, [NotNull] IMutableEntityType entityType)
-            => (IMutableEntityType)((IForeignKey)foreignKey).ResolveOtherEntityType(entityType);
+            => (IMutableEntityType)((IForeignKey)foreignKey).GetRelatedEntityType(entityType);
 
         /// <summary>
         ///     Returns a navigation associated with this foreign key.
diff --git a/src/EFCore/Metadata/Conventions/RelationshipDiscoveryConvention.cs b/src/EFCore/Metadata/Conventions/RelationshipDiscoveryConvention.cs
index 9249413d176..ee94edb3a1d 100644
--- a/src/EFCore/Metadata/Conventions/RelationshipDiscoveryConvention.cs
+++ b/src/EFCore/Metadata/Conventions/RelationshipDiscoveryConvention.cs
@@ -406,7 +406,7 @@ private static bool CanMergeWith(
         {
             var fk = existingNavigation.ForeignKey;
             return (fk.IsSelfReferencing()
-                    || fk.ResolveOtherEntityType(existingNavigation.DeclaringEntityType) == inverseEntityTypeBuilder.Metadata)
+                    || fk.GetRelatedEntityType(existingNavigation.DeclaringEntityType) == inverseEntityTypeBuilder.Metadata)
                    && fk.Builder.CanSetNavigation(inverse, !existingNavigation.IsDependentToPrincipal());
         }
 
diff --git a/src/EFCore/Metadata/Internal/ForeignKey.cs b/src/EFCore/Metadata/Internal/ForeignKey.cs
index c060278d578..9bb53ccb5ae 100644
--- a/src/EFCore/Metadata/Internal/ForeignKey.cs
+++ b/src/EFCore/Metadata/Internal/ForeignKey.cs
@@ -713,7 +713,7 @@ public virtual IEnumerable<Navigation> FindNavigationsTo([NotNull] EntityType en
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
         public virtual EntityType ResolveOtherEntityType([NotNull] EntityType entityType)
-            => (EntityType)((IForeignKey)this).ResolveOtherEntityType(entityType);
+            => (EntityType)((IForeignKey)this).GetRelatedEntityType(entityType);
 
         // Note: This is set and used only by IdentityMapFactoryFactory, which ensures thread-safety
         /// <summary>
diff --git a/src/EFCore/Query/Pipeline/EntityEqualityRewritingExpressionVisitor.cs b/src/EFCore/Query/Pipeline/EntityEqualityRewritingExpressionVisitor.cs
index 1f8dcefdea9..4fbc6eec30c 100644
--- a/src/EFCore/Query/Pipeline/EntityEqualityRewritingExpressionVisitor.cs
+++ b/src/EFCore/Query/Pipeline/EntityEqualityRewritingExpressionVisitor.cs
@@ -14,7 +14,6 @@
 using Microsoft.EntityFrameworkCore.Query.Expressions.Internal;
 using Microsoft.EntityFrameworkCore.Query.Internal;
 using Microsoft.EntityFrameworkCore.Query.NavigationExpansion;
-using Microsoft.EntityFrameworkCore.Query.NavigationExpansion.Visitors;
 
 namespace Microsoft.EntityFrameworkCore.Query.Pipeline
 {
@@ -768,7 +767,8 @@ protected static Expression UnwrapLastNavigation(Expression expression)
                    : null);
 
         protected static Expression Unwrap(Expression expression)
-            => expression switch {
+            => expression switch
+            {
                 EntityReferenceExpression wrapper => wrapper.Underlying,
                 LambdaExpression lambda when lambda.Body is EntityReferenceExpression wrapper =>
                     Expression.Lambda(
@@ -777,9 +777,9 @@ protected static Expression Unwrap(Expression expression)
                         lambda.TailCall,
                         lambda.Parameters),
                 _ => expression
-                };
+            };
 
-        public class EntityReferenceExpression : Expression
+        protected class EntityReferenceExpression : Expression
         {
             public override ExpressionType NodeType => ExpressionType.Extension;
 
@@ -900,7 +900,7 @@ public virtual void Print(ExpressionPrinter expressionPrinter)
                 }
             }
 
-            public override string ToString() => $"{Underlying}[{(IsEntityType ? EntityType.ShortName(): "AnonymousObject")}{(SubqueryTraversed ? ", Subquery" : "")}]";
+            public override string ToString() => $"{Underlying}[{(IsEntityType ? EntityType.ShortName() : "AnonymousObject")}{(SubqueryTraversed ? ", Subquery" : "")}]";
         }
     }
 }
diff --git a/test/EFCore.Tests/Metadata/Internal/ForeignKeyTest.cs b/test/EFCore.Tests/Metadata/Internal/ForeignKeyTest.cs
index d13096f977f..94815b4c783 100644
--- a/test/EFCore.Tests/Metadata/Internal/ForeignKeyTest.cs
+++ b/test/EFCore.Tests/Metadata/Internal/ForeignKeyTest.cs
@@ -593,8 +593,8 @@ public void Can_find_targets_for_non_hierarchical_foreign_keys()
         {
             var fk = CreateOneToManyFK();
 
-            Assert.Same(fk.PrincipalEntityType, fk.ResolveOtherEntityType(fk.DeclaringEntityType));
-            Assert.Same(fk.DeclaringEntityType, fk.ResolveOtherEntityType(fk.PrincipalEntityType));
+            Assert.Same(fk.PrincipalEntityType, fk.GetRelatedEntityType(fk.DeclaringEntityType));
+            Assert.Same(fk.DeclaringEntityType, fk.GetRelatedEntityType(fk.PrincipalEntityType));
             Assert.Equal(new[] { fk.PrincipalToDependent }, fk.FindNavigationsFrom(fk.PrincipalEntityType));
             Assert.Equal(new[] { fk.DependentToPrincipal }, fk.FindNavigationsFrom(fk.DeclaringEntityType));
             Assert.Equal(new[] { fk.DependentToPrincipal }, fk.FindNavigationsTo(fk.PrincipalEntityType));
@@ -622,8 +622,8 @@ public void Can_find_targets_for_same_base_foreign_keys()
             var derivedDependent = model.AddEntityType(typeof(DerivedOneToManyDependent));
             derivedDependent.BaseType = fk.DeclaringEntityType;
 
-            Assert.Same(fk.PrincipalEntityType, fk.ResolveOtherEntityType(fk.DeclaringEntityType));
-            Assert.Same(fk.DeclaringEntityType, fk.ResolveOtherEntityType(fk.PrincipalEntityType));
+            Assert.Same(fk.PrincipalEntityType, fk.GetRelatedEntityType(fk.DeclaringEntityType));
+            Assert.Same(fk.DeclaringEntityType, fk.GetRelatedEntityType(fk.PrincipalEntityType));
             Assert.Same(fk.PrincipalToDependent, fk.FindNavigationsFrom(fk.PrincipalEntityType).SingleOrDefault());
             Assert.Same(fk.DependentToPrincipal, fk.FindNavigationsFrom(fk.DeclaringEntityType).SingleOrDefault());
             Assert.Same(fk.DependentToPrincipal, fk.FindNavigationsTo(fk.PrincipalEntityType).SingleOrDefault());
@@ -641,11 +641,11 @@ public void Can_find_targets_for_same_base_foreign_keys()
             Assert.Equal(
                 CoreStrings.EntityTypeNotInRelationshipStrict(
                     derivedDependent.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
-                Assert.Throws<InvalidOperationException>(() => fk.ResolveOtherEntityType(derivedDependent)).Message);
+                Assert.Throws<InvalidOperationException>(() => fk.GetRelatedEntityType(derivedDependent)).Message);
             Assert.Equal(
                 CoreStrings.EntityTypeNotInRelationshipStrict(
                     derivedPrincipal.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
-                Assert.Throws<InvalidOperationException>(() => fk.ResolveOtherEntityType(derivedPrincipal)).Message);
+                Assert.Throws<InvalidOperationException>(() => fk.GetRelatedEntityType(derivedPrincipal)).Message);
             Assert.Equal(
                 CoreStrings.EntityTypeNotInRelationshipStrict(
                     derivedPrincipal.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
@@ -678,8 +678,8 @@ public void Can_find_targets_for_self_ref_foreign_keys()
         {
             var fk = CreateSelfRefFK();
 
-            Assert.Same(fk.PrincipalEntityType, fk.ResolveOtherEntityType(fk.DeclaringEntityType));
-            Assert.Same(fk.DeclaringEntityType, fk.ResolveOtherEntityType(fk.PrincipalEntityType));
+            Assert.Same(fk.PrincipalEntityType, fk.GetRelatedEntityType(fk.DeclaringEntityType));
+            Assert.Same(fk.DeclaringEntityType, fk.GetRelatedEntityType(fk.PrincipalEntityType));
 
             Assert.Equal(
                 new[] { fk.PrincipalToDependent, fk.DependentToPrincipal },
@@ -713,8 +713,8 @@ public void Can_finding_targets_for_same_hierarchy_foreign_keys()
         {
             var fk = CreateOneToManySameHierarchyFK();
 
-            Assert.Same(fk.PrincipalEntityType, fk.ResolveOtherEntityType(fk.DeclaringEntityType));
-            Assert.Same(fk.DeclaringEntityType, fk.ResolveOtherEntityType(fk.PrincipalEntityType));
+            Assert.Same(fk.PrincipalEntityType, fk.GetRelatedEntityType(fk.DeclaringEntityType));
+            Assert.Same(fk.DeclaringEntityType, fk.GetRelatedEntityType(fk.PrincipalEntityType));
             Assert.Same(fk.PrincipalToDependent, fk.FindNavigationsFrom(fk.PrincipalEntityType).SingleOrDefault());
             Assert.Same(fk.DependentToPrincipal, fk.FindNavigationsFrom(fk.DeclaringEntityType).SingleOrDefault());
             Assert.Same(fk.DependentToPrincipal, fk.FindNavigationsTo(fk.PrincipalEntityType).SingleOrDefault());
@@ -765,11 +765,11 @@ public void Finding_targets_throws_for_entity_types_not_in_the_relationship()
             Assert.Equal(
                 CoreStrings.EntityTypeNotInRelationshipStrict(
                     unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
-                Assert.Throws<InvalidOperationException>(() => fk.ResolveOtherEntityType(unrelatedType)).Message);
+                Assert.Throws<InvalidOperationException>(() => fk.GetRelatedEntityType(unrelatedType)).Message);
             Assert.Equal(
                 CoreStrings.EntityTypeNotInRelationshipStrict(
                     unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
-                Assert.Throws<InvalidOperationException>(() => fk.ResolveOtherEntityType(unrelatedType)).Message);
+                Assert.Throws<InvalidOperationException>(() => fk.GetRelatedEntityType(unrelatedType)).Message);
 
             Assert.Equal(
                 CoreStrings.EntityTypeNotInRelationshipStrict(