Don't keep join entity type around because a ForeignKeyAttribute used…

… to reference it. Instead, remove it and reattach the configuration.

Also, reuse the FKs that already were configured instead of creating new ones.

Fixes #27990
Fixes #26555

src/EFCore/Metadata/Builders/CollectionCollectionBuilder.cs

@@ -407,6 +407,7 @@ protected virtual IMutableEntityType UsingEntity(
 
         var existingJoinEntityType = (EntityType?)(LeftNavigation.JoinEntityType ?? RightNavigation.JoinEntityType);
         EntityType? newJoinEntityType = null;
+        EntityType.Snapshot? entityTypeSnapshot = null;
         if (existingJoinEntityType != null)
         {
             if ((joinEntityType == null || existingJoinEntityType.ClrType == joinEntityType)
@@ -416,7 +417,13 @@ protected virtual IMutableEntityType UsingEntity(
             }
             else
             {
-                ModelBuilder.RemoveImplicitJoinEntity(existingJoinEntityType);
+                ModelBuilder.RemoveImplicitJoinEntity(existingJoinEntityType, configurationSource: ConfigurationSource.DataAnnotation);
+
+                entityTypeSnapshot = InternalEntityTypeBuilder.DetachAllMembers(existingJoinEntityType);
+                if (entityTypeSnapshot != null)
+                {
+                    ModelBuilder.HasNoEntityType(existingJoinEntityType, ConfigurationSource.Explicit);
+                }
             }
         }
 
@@ -440,15 +447,36 @@ protected virtual IMutableEntityType UsingEntity(
             }
         }
 
-        var rightForeignKey = configureRight != null
-            ? configureRight(newJoinEntityType)
-            : GetOrCreateSkipNavigationForeignKey((SkipNavigation)RightNavigation, newJoinEntityType);
-        var leftForeignKey = configureLeft != null
-            ? configureLeft(newJoinEntityType)
-            : GetOrCreateSkipNavigationForeignKey((SkipNavigation)LeftNavigation, newJoinEntityType);
+        if (entityTypeSnapshot != null)
+        {
+            entityTypeSnapshot.Attach(newJoinEntityType.Builder);
+        }
 
+        IMutableForeignKey? rightForeignKey;
+        if (configureRight != null)
+        {
+            newJoinEntityType.SetAnnotation(CoreAnnotationNames.SkipNavigationBeingConfigured, RightNavigation);
+            rightForeignKey = configureRight(newJoinEntityType);
+            newJoinEntityType.RemoveAnnotation(CoreAnnotationNames.SkipNavigationBeingConfigured);
+        }
+        else
+        {
+            rightForeignKey = GetOrCreateSkipNavigationForeignKey((SkipNavigation)RightNavigation, newJoinEntityType);
+        }
         ((SkipNavigation)RightNavigation).Builder
             .HasForeignKey((ForeignKey)rightForeignKey, ConfigurationSource.Explicit);
+
+        IMutableForeignKey? leftForeignKey;
+        if (configureLeft != null)
+        {
+            newJoinEntityType.SetAnnotation(CoreAnnotationNames.SkipNavigationBeingConfigured, LeftNavigation);
+            leftForeignKey = configureLeft(newJoinEntityType);
+            newJoinEntityType.RemoveAnnotation(CoreAnnotationNames.SkipNavigationBeingConfigured);
+        }
+        else
+        {
+            leftForeignKey = GetOrCreateSkipNavigationForeignKey((SkipNavigation)LeftNavigation, newJoinEntityType);
+        }
         ((SkipNavigation)LeftNavigation).Builder
             .HasForeignKey((ForeignKey)leftForeignKey, ConfigurationSource.Explicit);
 

src/EFCore/Metadata/Builders/EntityTypeBuilder.cs

@@ -1055,8 +1055,7 @@ public virtual ReferenceNavigationBuilder HasOne(
         Check.NullButNotEmpty(navigationName, nameof(navigationName));
 
         var relatedEntityType = FindRelatedEntityType(relatedTypeName, navigationName);
-        var foreignKey = HasOneBuilder(
-            MemberIdentity.Create(navigationName), relatedEntityType);
+        var foreignKey = HasOneBuilder(MemberIdentity.Create(navigationName), relatedEntityType);
 
         return new ReferenceNavigationBuilder(
             Builder.Metadata,
@@ -1098,8 +1097,7 @@ public virtual ReferenceNavigationBuilder HasOne(
         Check.NullButNotEmpty(navigationName, nameof(navigationName));
 
         var relatedEntityType = FindRelatedEntityType(relatedType, navigationName);
-        var foreignKey = HasOneBuilder(
-            MemberIdentity.Create(navigationName), relatedEntityType);
+        var foreignKey = HasOneBuilder(MemberIdentity.Create(navigationName), relatedEntityType);
 
         return new ReferenceNavigationBuilder(
             Builder.Metadata,
@@ -1145,6 +1143,17 @@ protected virtual ForeignKey HasOneBuilder(
         MemberIdentity navigationId,
         EntityType relatedEntityType)
     {
+        if (Metadata[CoreAnnotationNames.SkipNavigationBeingConfigured] is SkipNavigation skipNavigation
+            && skipNavigation.DeclaringEntityType == relatedEntityType
+            && skipNavigation.ForeignKey?.DeclaringEntityType == Builder.Metadata)
+        {
+            return navigationId.MemberInfo != null
+                ? skipNavigation.ForeignKey.Builder.HasNavigation(navigationId.MemberInfo, pointsToPrincipal: true, ConfigurationSource.Explicit)
+                    !.Metadata
+                : skipNavigation.ForeignKey.Builder.HasNavigation(navigationId.Name, pointsToPrincipal: true, ConfigurationSource.Explicit)
+                    !.Metadata;
+        }
+
         ForeignKey foreignKey;
         if (navigationId.MemberInfo != null)
         {

src/EFCore/Metadata/Builders/EntityTypeBuilder`.cs

@@ -1336,8 +1336,7 @@ public virtual ReferenceNavigationBuilder<TEntity, TRelatedEntity> HasOne
         where TRelatedEntity : class
     {
         var relatedEntityType = FindRelatedEntityType(typeof(TRelatedEntity), navigationName);
-        var foreignKey = HasOneBuilder(
-            MemberIdentity.Create(navigationName), relatedEntityType);
+        var foreignKey = HasOneBuilder(MemberIdentity.Create(navigationName), relatedEntityType);
 
         return new ReferenceNavigationBuilder<TEntity, TRelatedEntity>(
             Builder.Metadata,
@@ -1381,8 +1380,7 @@ public virtual ReferenceNavigationBuilder<TEntity, TRelatedEntity> HasOne
     {
         var navigationMember = navigationExpression?.GetMemberAccess();
         var relatedEntityType = FindRelatedEntityType(typeof(TRelatedEntity), navigationMember?.GetSimpleMemberName());
-        var foreignKey = HasOneBuilder(
-            MemberIdentity.Create(navigationMember), relatedEntityType);
+        var foreignKey = HasOneBuilder(MemberIdentity.Create(navigationMember), relatedEntityType);
 
         return new ReferenceNavigationBuilder<TEntity, TRelatedEntity>(
             Builder.Metadata,

src/EFCore/Metadata/Builders/OwnedNavigationBuilder.cs

@@ -861,14 +861,13 @@ public virtual ReferenceNavigationBuilder HasOne(
         Check.NullButNotEmpty(navigationName, nameof(navigationName));
 
         var relatedEntityType = FindRelatedEntityType(relatedTypeName, navigationName);
+        var foreignKey = HasOneBuilder(MemberIdentity.Create(navigationName), relatedEntityType);
 
         return new ReferenceNavigationBuilder(
             DependentEntityType,
             relatedEntityType,
             navigationName,
-            DependentEntityType.Builder.HasRelationship(
-                relatedEntityType, navigationName, ConfigurationSource.Explicit,
-                targetIsPrincipal: DependentEntityType == relatedEntityType ? true : null)!.Metadata);
+            foreignKey);
     }
 
     /// <summary>
@@ -936,14 +935,41 @@ public virtual ReferenceNavigationBuilder HasOne(
         Check.NullButNotEmpty(navigationName, nameof(navigationName));
 
         var relatedEntityType = FindRelatedEntityType(relatedType, navigationName);
+        var foreignKey = HasOneBuilder(MemberIdentity.Create(navigationName), relatedEntityType);
 
         return new ReferenceNavigationBuilder(
             DependentEntityType,
             relatedEntityType,
             navigationName,
-            DependentEntityType.Builder.HasRelationship(
-                relatedEntityType, navigationName, ConfigurationSource.Explicit,
-                targetIsPrincipal: DependentEntityType == relatedEntityType ? true : null)!.Metadata);
+            foreignKey);
+    }
+
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    [EntityFrameworkInternal]
+    protected virtual ForeignKey HasOneBuilder(
+        MemberIdentity navigationId,
+        EntityType relatedEntityType)
+    {
+        ForeignKey foreignKey;
+        if (navigationId.MemberInfo != null)
+        {
+            foreignKey = DependentEntityType.Builder.HasRelationship(
+                relatedEntityType, navigationId.MemberInfo, ConfigurationSource.Explicit,
+                targetIsPrincipal: DependentEntityType == relatedEntityType ? true : null)!.Metadata;
+        }
+        else
+        {
+            foreignKey = DependentEntityType.Builder.HasRelationship(
+                relatedEntityType, navigationId.Name, ConfigurationSource.Explicit,
+                targetIsPrincipal: DependentEntityType == relatedEntityType ? true : null)!.Metadata;
+        }
+
+        return foreignKey;
     }
 
     /// <summary>

src/EFCore/Metadata/Builders/OwnedNavigationBuilder`.cs

@@ -1104,14 +1104,13 @@ public virtual ReferenceNavigationBuilder<TDependentEntity, TNewRelatedEntity> H
         where TNewRelatedEntity : class
     {
         var relatedEntityType = FindRelatedEntityType(typeof(TNewRelatedEntity), navigationName);
+        var foreignKey = HasOneBuilder(MemberIdentity.Create(navigationName), relatedEntityType);
 
         return new ReferenceNavigationBuilder<TDependentEntity, TNewRelatedEntity>(
             DependentEntityType,
             relatedEntityType,
             navigationName,
-            DependentEntityType.Builder.HasRelationship(
-                relatedEntityType, navigationName, ConfigurationSource.Explicit,
-                targetIsPrincipal: DependentEntityType == relatedEntityType ? true : null)!.Metadata);
+            foreignKey);
     }
 
     /// <summary>
@@ -1147,16 +1146,15 @@ public virtual ReferenceNavigationBuilder<TDependentEntity, TNewRelatedEntity> H
             Expression<Func<TDependentEntity, TNewRelatedEntity?>>? navigationExpression = null)
         where TNewRelatedEntity : class
     {
-        var navigation = navigationExpression?.GetMemberAccess();
-        var relatedEntityType = FindRelatedEntityType(typeof(TNewRelatedEntity), navigation?.GetSimpleMemberName());
+        var navigationMember = navigationExpression?.GetMemberAccess();
+        var relatedEntityType = FindRelatedEntityType(typeof(TNewRelatedEntity), navigationMember?.GetSimpleMemberName());
+        var foreignKey = HasOneBuilder(MemberIdentity.Create(navigationMember), relatedEntityType);
 
         return new ReferenceNavigationBuilder<TDependentEntity, TNewRelatedEntity>(
             DependentEntityType,
             relatedEntityType,
-            navigation,
-            DependentEntityType.Builder.HasRelationship(
-                relatedEntityType, navigation, ConfigurationSource.Explicit,
-                targetIsPrincipal: DependentEntityType == relatedEntityType ? true : null)!.Metadata);
+            navigationMember,
+            foreignKey);
     }
 
     /// <summary>

src/EFCore/Metadata/Conventions/KeyDiscoveryConvention.cs

@@ -279,7 +279,8 @@ public virtual void ProcessForeignKeyPropertiesChanged(
         IConventionContext<IReadOnlyList<IConventionProperty>> context)
     {
         var foreignKey = relationshipBuilder.Metadata;
-        if (foreignKey.IsOwnership
+        if ((foreignKey.IsOwnership
+            || foreignKey.GetReferencingSkipNavigations().Any(n => n.IsCollection))
             && !foreignKey.Properties.SequenceEqual(oldDependentProperties)
             && relationshipBuilder.Metadata.IsInModel)
         {

src/EFCore/Metadata/Internal/CoreAnnotationNames.cs

@@ -348,6 +348,14 @@ public static class CoreAnnotationNames
     /// </summary>
     public const string ElementType = "ElementType";
 
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public const string SkipNavigationBeingConfigured = "SkipNavigationBeingConfigured";
+
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
@@ -399,6 +407,7 @@ public static class CoreAnnotationNames
         FullChangeTrackingNotificationsRequired,
         AdHocModel,
         JsonValueReaderWriterType,
-        ElementType
+        ElementType,
+        SkipNavigationBeingConfigured
     };
 }

src/EFCore/Metadata/Internal/InternalModelBuilder.cs

@@ -385,16 +385,13 @@ public virtual bool CanHaveEntity(
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    public virtual InternalModelBuilder? RemoveImplicitJoinEntity(EntityType joinEntityType)
-    {
-        Check.NotNull(joinEntityType, nameof(joinEntityType));
-
-        return !joinEntityType.IsInModel
+    public virtual InternalModelBuilder? RemoveImplicitJoinEntity(
+        EntityType joinEntityType, ConfigurationSource configurationSource = ConfigurationSource.Convention)
+        => !Check.NotNull(joinEntityType, nameof(joinEntityType)).IsInModel
             ? this
             : !joinEntityType.IsImplicitlyCreatedJoinEntityType
                 ? null
-                : HasNoEntityType(joinEntityType, ConfigurationSource.Convention);
-    }
+                : HasNoEntityType(joinEntityType, configurationSource);
 
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore/Metadata/Internal/InternalSkipNavigationBuilder.cs

@@ -68,7 +68,7 @@ protected override InternalSkipNavigationBuilder This
             && oldForeignKey != foreignKey
             && oldForeignKey.ReferencingSkipNavigations?.Any() != true)
         {
-            oldForeignKey.DeclaringEntityType.Builder.HasNoRelationship(oldForeignKey, ConfigurationSource.Convention);
+            oldForeignKey.DeclaringEntityType.Builder.HasNoRelationship(oldForeignKey, ConfigurationSource.Explicit);
         }
 
         return this;

test/EFCore.Cosmos.FunctionalTests/ModelBuilding/CosmosModelBuilderGenericTest.cs

@@ -920,23 +920,30 @@ public virtual void Can_use_shared_type_as_join_entity_with_partition_keys()
                     mb.HasPartitionKey("PartitionId");
                 });
 
+            modelBuilder.Entity<ManyToManyNavPrincipal>()
+                .HasMany(e => e.Dependents)
+                .WithMany(e => e.ManyToManyPrincipals)
+                .UsingEntity<Dictionary<string, object>>(
+                    "JoinType",
+                    e => e.HasOne<NavDependent>().WithMany().HasAnnotation("Right", "Foo"),
+                    e => e.HasOne<ManyToManyNavPrincipal>().WithMany().HasAnnotation("Left", "Bar"));
+
             modelBuilder.Entity<ManyToManyNavPrincipal>()
                 .HasMany(e => e.Dependents)
                 .WithMany(e => e.ManyToManyPrincipals)
                 .UsingEntity<Dictionary<string, object>>(
                     "JoinType",
                     e => e.HasOne<NavDependent>().WithMany().HasForeignKey("DependentId", "PartitionId"),
                     e => e.HasOne<ManyToManyNavPrincipal>().WithMany().HasForeignKey("PrincipalId", "PartitionId"),
-                    e =>
-                    {
-                        e.HasPartitionKey("PartitionId");
-                    });
+                    e => e.HasPartitionKey("PartitionId"));
 
             var model = modelBuilder.FinalizeModel();
 
             var joinType = model.FindEntityType("JoinType")!;
             Assert.NotNull(joinType);
-            Assert.Equal(2, joinType.GetForeignKeys().Count());
+            Assert.Collection(joinType.GetForeignKeys(),
+                fk => Assert.Equal("Foo", fk["Right"]),
+                fk => Assert.Equal("Bar", fk["Left"]));
             Assert.Equal(3, joinType.FindPrimaryKey()!.Properties.Count);
             Assert.Equal(6, joinType.GetProperties().Count());
             Assert.Equal("DbContext", joinType.GetContainer());

test/EFCore.Cosmos.FunctionalTests/TestUtilities/CosmosModelAsserter.cs

@@ -19,8 +19,8 @@ public override void AssertEqual(
         bool assertOrder = false,
         bool compareAnnotations = false)
     {
-        expectedProperties = expectedProperties.Where(p => p.Name != "__jObject" && p.Name != "__id");
-        actualProperties = actualProperties.Where(p => p.Name != "__jObject" && p.Name != "__id");
+        expectedProperties = expectedProperties.Where(p => p.Name != "__jObject" && p.Name != "__id" && p.Name != "Discriminator");
+        actualProperties = actualProperties.Where(p => p.Name != "__jObject" && p.Name != "__id" && p.Name != "Discriminator");
 
         base.AssertEqual(expectedProperties, actualProperties, assertOrder, compareAnnotations);
     }