diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol_Bases.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol_Bases.cs
index e8bc2be3a8445..77a181093c2fc 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol_Bases.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol_Bases.cs
@@ -315,13 +315,36 @@ private Tuple<NamedTypeSymbol, ImmutableArray<NamedTypeSymbol>> MakeDeclaredBase
                         baseType = partBase;
                         baseTypeLocation = decl.NameLocation;
                     }
-                    else if ((object)partBase != null && !TypeSymbol.Equals(partBase, baseType, TypeCompareKind.ConsiderEverything2) && partBase.TypeKind != TypeKind.Error)
+                    else if ((object)partBase != null && !TypeSymbol.Equals(partBase, baseType, TypeCompareKind.ConsiderEverything) && partBase.TypeKind != TypeKind.Error)
                     {
                         // the parts do not agree
+                        if (partBase.Equals(baseType, TypeCompareKind.ObliviousNullableModifierMatchesAny))
+                        {
+                            if (containsOnlyOblivious(baseType))
+                            {
+                                baseType = partBase;
+                                baseTypeLocation = decl.NameLocation;
+                                continue;
+                            }
+                            else if (containsOnlyOblivious(partBase))
+                            {
+                                continue;
+                            }
+                        }
+
                         var info = diagnostics.Add(ErrorCode.ERR_PartialMultipleBases, Locations[0], this);
                         baseType = new ExtendedErrorTypeSymbol(baseType, LookupResultKind.Ambiguous, info);
                         baseTypeLocation = decl.NameLocation;
                         reportedPartialConflict = true;
+
+                        static bool containsOnlyOblivious(TypeSymbol type)
+                        {
+                            return TypeWithAnnotations.Create(type).VisitType(
+                                type: null,
+                                static (type, arg, flag) => !type.Type.IsValueType && !type.NullableAnnotation.IsOblivious(),
+                                typePredicate: null,
+                                arg: (object)null) is null;
+                        }
                     }
                 }
 
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
index 2f0f4b7ab8281..41801dbdd0d15 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
@@ -131349,6 +131349,598 @@ partial interface I4<out T> where T : I1
                 );
         }
 
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_01()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string> base1 = new C();
+Base<string?> base2 = new C(); // 1
+
+class Base<T> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string> { }
+";
+            var source2 = @"
+#nullable disable
+partial class C : Base<string> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,23): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string?>'.
+                    // Base<string?> base2 = new C(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string?>").WithLocation(5, 23)
+                    );
+
+                var cClass = comp.GetMember<NamedTypeSymbol>("C");
+                var @base = cClass.BaseTypeNoUseSiteDiagnostics;
+                // note: the symbol model doesn't include a nullable annotation for base types or implemented interfaces.
+                Assert.Equal("Base<System.String!>", @base.ToTestDisplayString(includeNonNullable: true));
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_02()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string> base1 = new C(); // 1
+Base<string?> base2 = new C();
+
+class Base<T> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string?> { }
+";
+            var source2 = @"
+#nullable disable
+partial class C : Base<string> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (4,22): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string>'.
+                    // Base<string> base1 = new C(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string>").WithLocation(4, 22)
+                    );
+
+                var cClass = comp.GetMember<NamedTypeSymbol>("C");
+                var @base = cClass.BaseTypeNoUseSiteDiagnostics;
+                // note: the symbol model doesn't include a nullable annotation for base types or implemented interfaces.
+                Assert.Equal("Base<System.String?>", @base.ToTestDisplayString(includeNonNullable: true));
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_03()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string> base1 = new C();
+Base<string?> base2 = new C(); // 1
+
+class Base<T> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string> { }
+";
+            var source2 = @"
+#nullable enable
+partial class C : Base<
+#nullable disable
+    string
+#nullable enable
+> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,23): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string?>'.
+                    // Base<string?> base2 = new C(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string?>").WithLocation(5, 23)
+                    );
+
+                var cClass = comp.GetMember<NamedTypeSymbol>("C");
+                var @base = cClass.BaseTypeNoUseSiteDiagnostics;
+                Assert.Equal("Base<System.String!>", @base.ToTestDisplayString(includeNonNullable: true));
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_04()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string> base1 = new C(); // 1
+Base<string?> base2 = new C();
+
+class Base<T> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string?> { }
+";
+            var source2 = @"
+#nullable enable
+partial class C : Base<
+#nullable disable
+    string
+#nullable enable
+> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (4,22): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string>'.
+                    // Base<string> base1 = new C(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string>").WithLocation(4, 22)
+                    );
+
+                var cClass = comp.GetMember<NamedTypeSymbol>("C");
+                var @base = cClass.BaseTypeNoUseSiteDiagnostics;
+                Assert.Equal("Base<System.String?>", @base.ToTestDisplayString(includeNonNullable: true));
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_05()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string> base1 = new C();
+Base<string?> base2 = new C(); // 1
+
+class Base<T> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string> { }
+";
+            var source2 = @"
+#nullable enable
+partial class C : Base<
+#nullable disable
+    string
+> { } // Note: the top-level nullability is oblivious here.
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,23): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string?>'.
+                    // Base<string?> base2 = new C(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string?>").WithLocation(5, 23)
+                    );
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_06()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string, object?> base1 = new C();
+Base<string, object> base2 = new C(); // 1
+Base<string?, object?> base3 = new C(); // 2
+
+class Base<T, U> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string, object?> { }
+";
+            var source2 = @"
+#nullable disable
+partial class C : Base<string, object> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,30): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string, object>'.
+                    // Base<string, object> base2 = new C(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string, object>").WithLocation(5, 30),
+                    // (6,32): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string?, object?>'.
+                    // Base<string?, object?> base3 = new C(); // 2
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string?, object?>").WithLocation(6, 32)
+                    );
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_07()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string, object?> base1 = new C(); // 1
+Base<string, object> base2 = new C(); // 2
+Base<string?, object?> base3 = new C(); // 3
+
+class Base<T, U> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string, object?> { } // 4
+";
+            var source2 = @"
+#nullable disable
+partial class C : Base<string, object> { }
+";
+            var source3 = @"
+#nullable enable
+partial class C : Base<string?, object> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2, source3 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source3, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (3,15): error CS0263: Partial declarations of 'C' must not specify different base classes
+                    // partial class C : Base<string, object?> { } // 4
+                    Diagnostic(ErrorCode.ERR_PartialMultipleBases, "C").WithArguments("C").WithLocation(3, 15),
+                    // (4,31): error CS0029: Cannot implicitly convert type 'C' to 'Base<string, object?>'
+                    // Base<string, object?> base1 = new C(); // 1
+                    Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C()").WithArguments("C", "Base<string, object?>").WithLocation(4, 31),
+                    // (5,30): error CS0029: Cannot implicitly convert type 'C' to 'Base<string, object>'
+                    // Base<string, object> base2 = new C(); // 2
+                    Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C()").WithArguments("C", "Base<string, object>").WithLocation(5, 30),
+                    // (6,32): error CS0029: Cannot implicitly convert type 'C' to 'Base<string?, object?>'
+                    // Base<string?, object?> base3 = new C(); // 3
+                    Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C()").WithArguments("C", "Base<string?, object?>").WithLocation(6, 32)
+                    );
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_08()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<S, object?> base1 = new C1();
+Base<S, object> base2 = new C1(); // 1
+
+Base<object?, S> base3 = new C2(); // 2
+Base<object, S> base4 = new C2();
+
+class Base<T, U> { }
+
+struct S { }
+";
+            var source1 = @"
+#nullable enable
+partial class C1 : Base<S, object?> { }
+partial class C2 : Base<object, S> { }
+";
+            var source2 = @"
+#nullable disable
+partial class C1 : Base<S, object> { }
+partial class C2 : Base<object, S> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,25): warning CS8619: Nullability of reference types in value of type 'C1' doesn't match target type 'Base<S, object>'.
+                    // Base<S, object> base2 = new C1(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C1()").WithArguments("C1", "Base<S, object>").WithLocation(5, 25),
+                    // (7,26): warning CS8619: Nullability of reference types in value of type 'C2' doesn't match target type 'Base<object?, S>'.
+                    // Base<object?, S> base3 = new C2(); // 2
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C2()").WithArguments("C2", "Base<object?, S>").WithLocation(7, 26)
+                    );
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_09()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<S?, object?> base1 = new C1();
+Base<S?, object> base2 = new C1(); // 1
+
+Base<object?, S?> base3 = new C2(); // 2
+Base<object, S?> base4 = new C2();
+
+class Base<T, U> { }
+
+struct S { }
+";
+            var source1 = @"
+#nullable enable
+partial class C1 : Base<S?, object?> { }
+partial class C2 : Base<object, S?> { }
+";
+            var source2 = @"
+#nullable disable
+partial class C1 : Base<S?, object> { }
+partial class C2 : Base<object, S?> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,26): warning CS8619: Nullability of reference types in value of type 'C1' doesn't match target type 'Base<S?, object>'.
+                    // Base<S?, object> base2 = new C1(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C1()").WithArguments("C1", "Base<S?, object>").WithLocation(5, 26),
+                    // (7,27): warning CS8619: Nullability of reference types in value of type 'C2' doesn't match target type 'Base<object?, S?>'.
+                    // Base<object?, S?> base3 = new C2(); // 2
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C2()").WithArguments("C2", "Base<object?, S?>").WithLocation(7, 27)
+                    );
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_10()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<S, object?> base1 = new C1();
+Base<S, object> base2 = new C1(); // 1
+
+Base<object?, S> base3 = new C2(); // 2
+Base<object, S> base4 = new C2();
+
+class Base<T, U> { }
+
+struct S { }
+";
+            var source1 = @"
+#nullable enable
+partial class C1 : Base<S, object?> { }
+partial class C2 : Base<object, S> { }
+";
+            var source2 = @"
+#nullable enable
+partial class C1 : Base<
+    S,
+#nullable disable
+    object> { }
+
+#nullable enable
+partial class C2 : Base<
+    object,
+#nullable disable
+    S> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,25): warning CS8619: Nullability of reference types in value of type 'C1' doesn't match target type 'Base<S, object>'.
+                    // Base<S, object> base2 = new C1(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C1()").WithArguments("C1", "Base<S, object>").WithLocation(5, 25),
+                    // (7,26): warning CS8619: Nullability of reference types in value of type 'C2' doesn't match target type 'Base<object?, S>'.
+                    // Base<object?, S> base3 = new C2(); // 2
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C2()").WithArguments("C2", "Base<object?, S>").WithLocation(7, 26)
+                    );
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_11()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<S?, object?> base1 = new C1();
+Base<S?, object> base2 = new C1(); // 1
+
+Base<object?, S?> base3 = new C2(); // 2
+Base<object, S?> base4 = new C2();
+
+class Base<T, U> { }
+
+struct S { }
+";
+            var source1 = @"
+#nullable enable
+partial class C1 : Base<S?, object?> { }
+partial class C2 : Base<object, S?> { }
+";
+            var source2 = @"
+#nullable enable
+partial class C1 : Base<
+    S?,
+#nullable disable
+    object> { }
+
+#nullable enable
+partial class C2 : Base<
+    object,
+#nullable disable
+    S?> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            comp.VerifyDiagnostics(
+                // (5,26): warning CS8619: Nullability of reference types in value of type 'C1' doesn't match target type 'Base<S?, object>'.
+                // Base<S?, object> base2 = new C1(); // 1
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C1()").WithArguments("C1", "Base<S?, object>").WithLocation(5, 26),
+                // (7,27): warning CS8619: Nullability of reference types in value of type 'C2' doesn't match target type 'Base<object?, S?>'.
+                // Base<object?, S?> base3 = new C2(); // 2
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C2()").WithArguments("C2", "Base<object?, S?>").WithLocation(7, 27)
+                );
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_12()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<S, object?> base1 = new C1<S>();
+Base<S, object> base2 = new C1<S>(); // 1
+
+Base<object?, S> base3 = new C2<S>(); // 2
+Base<object, S> base4 = new C2<S>();
+
+class Base<T, U> { }
+
+struct S { }
+";
+            var source1 = @"
+#nullable enable
+partial class C1<TStruct> : Base<TStruct, object?> where TStruct : struct { }
+partial class C2<TStruct> : Base<object, TStruct> where TStruct : struct { }
+";
+            var source2 = @"
+#nullable enable
+partial class C1<TStruct> : Base<
+    TStruct,
+#nullable disable
+    object> where TStruct : struct { }
+
+#nullable enable
+partial class C2<TStruct> : Base<
+    object,
+#nullable disable
+    TStruct> where TStruct : struct { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,25): warning CS8619: Nullability of reference types in value of type 'C1<S>' doesn't match target type 'Base<S, object>'.
+                    // Base<S, object> base2 = new C1<S>(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C1<S>()").WithArguments("C1<S>", "Base<S, object>").WithLocation(5, 25),
+                    // (7,26): warning CS8619: Nullability of reference types in value of type 'C2<S>' doesn't match target type 'Base<object?, S>'.
+                    // Base<object?, S> base3 = new C2<S>(); // 2
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C2<S>()").WithArguments("C2<S>", "Base<object?, S>").WithLocation(7, 26)
+                    );
+            }
+        }
+
+        [Theory, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        [InlineData("")]
+        [InlineData("where T : class")]
+        public void PartialBaseTypeDifference_13(string constraints)
+        {
+            var source0 = @"
+#nullable enable
+
+Base<C, object?> base1 = new C1<C>(); // 1
+Base<C, object> base2 = new C1<C>(); // 2
+
+Base<object?, C> base3 = new C2<C>(); // 3
+Base<object, C> base4 = new C2<C>(); // 4
+
+class Base<T, U> { }
+
+class C { }
+";
+            var source1 = @"
+#nullable enable
+partial class C1<T> : Base<T, object?> " + constraints + @" { } // 5
+partial class C2<T> : Base<object, T> " + constraints + @" { } // 6
+";
+            var source2 = @"
+#nullable enable
+partial class C1<T> : Base<
+    T,
+#nullable disable
+    object> " + constraints + @" { }
+
+#nullable enable
+partial class C2<T> : Base<
+    object,
+#nullable disable
+    T> " + constraints + @" { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            comp.VerifyDiagnostics(
+                // (3,15): error CS0263: Partial declarations of 'C1<T>' must not specify different base classes
+                // partial class C1<T> : Base<T, object?>  { } // 5
+                Diagnostic(ErrorCode.ERR_PartialMultipleBases, "C1").WithArguments("C1<T>").WithLocation(3, 15),
+                // (4,15): error CS0263: Partial declarations of 'C2<T>' must not specify different base classes
+                // partial class C2<T> : Base<object, T>  { } // 6
+                Diagnostic(ErrorCode.ERR_PartialMultipleBases, "C2").WithArguments("C2<T>").WithLocation(4, 15),
+                // (4,26): error CS0029: Cannot implicitly convert type 'C1<C>' to 'Base<C, object?>'
+                // Base<C, object?> base1 = new C1<C>(); // 1
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C1<C>()").WithArguments("C1<C>", "Base<C, object?>").WithLocation(4, 26),
+                // (5,25): error CS0029: Cannot implicitly convert type 'C1<C>' to 'Base<C, object>'
+                // Base<C, object> base2 = new C1<C>(); // 2
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C1<C>()").WithArguments("C1<C>", "Base<C, object>").WithLocation(5, 25),
+                // (7,26): error CS0029: Cannot implicitly convert type 'C2<C>' to 'Base<object?, C>'
+                // Base<object?, C> base3 = new C2<C>(); // 3
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C2<C>()").WithArguments("C2<C>", "Base<object?, C>").WithLocation(7, 26),
+                // (8,25): error CS0029: Cannot implicitly convert type 'C2<C>' to 'Base<object, C>'
+                // Base<object, C> base4 = new C2<C>(); // 4
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C2<C>()").WithArguments("C2<C>", "Base<object, C>").WithLocation(8, 25)
+                );
+        }
+
         [Fact]
         public void PartialMethodsWithConstraints_01()
         {