Add tests cases from review of #132289

Author: steffahn

tests/ui/coherence/auxiliary/pr_review_132289_2_lib.rs

@@ -0,0 +1,37 @@
+pubtypeA = &'static[usize;1];
+pubtypeB = &'static[usize;100];
+
+pubtraitTrait<P>{
+typeAssoc;
+}
+
+pubtypeDyn<P> = dynTrait<P,Assoc = A>;
+
+pubtraitLocallyUnimplemented<P>{}
+
+impl<P,T: ?Sized>Trait<P>forT
+where
+T:LocallyUnimplemented<P>,
+{
+typeAssoc = B;
+}
+
+traitMakeArray<Arr>{
+fnmake() -> &'staticArr;
+}
+impl<constN:usize>MakeArray<[usize;N]>for(){
+fnmake() -> &'static[usize;N]{
+&[1337;N]
+}
+}
+
+// it would be sound for this return type to be interpreted as being
+// either of A or B, if that's what a soundness fix for overlap of
+// dyn Trait's impls would entail
+
+// In this test, we check at the call-site that the interpretation
+// is consistent across crates in this specific scenario.
+pubfnfunction<P>() -> (<Dyn<P>asTrait<P>>::Assoc,usize){
+let val = <()asMakeArray<_>>::make();
+(val, val.len())
+}

tests/ui/coherence/auxiliary/pr_review_132289_3_lib.rs

@@ -0,0 +1,12 @@
+use std::ops::Index;
+
+pubtraitTrait{
+fnf(&self)
+where
+ dyn Index<(),Output = ()>:Index<()>;
+// rustc (correctly) determines ^^^^^^^^ this bound to be true
+}
+
+pubfncall(x:&dynTrait){
+ x.f();// so we can call `f`
+}

tests/ui/coherence/pr-review-132289-1.rs

@@ -0,0 +1,52 @@
+// This is a regression test for issues that came up during review of the (closed)
+// PR #132289; this single-crate test case is
+// the first example from @steffahn during review.
+// https://github.com/rust-lang/rust/pull/132289#issuecomment-2564492153
+
+//@ check-pass
+
+typeA = &'static[usize;1];
+typeB = &'static[usize;100];
+
+typeDynSomething = dynSomething<Assoc = A>;
+
+traitSuper{
+typeAssoc;
+}
+implSuperforFoo{
+typeAssoc = A;
+}
+
+traitIsDynSomething{}
+implIsDynSomethingforDynSomething{}
+
+impl<T: ?Sized>SuperforT
+where
+T:IsDynSomething,
+{
+typeAssoc = B;
+}
+
+traitSomething:Super{
+fnmethod(&self) -> Self::Assoc;
+}
+
+structFoo;
+implSomethingforFoo{
+fnmethod(&self) -> Self::Assoc{
+&[1337]
+}
+}
+
+fnmain(){
+let x = &Foo;
+let y:&DynSomething = x;
+
+// no surprises here
+let _arr1:A = x.method();
+
+// this (`_arr2`) can't ever become B either, soundly
+let _arr2:A = y.method();
+// there aren't any other arrays being defined anywhere in this
+// test case, besides the length-1 one containing [1337]
+}

tests/ui/coherence/pr-review-132289-2.rs

@@ -0,0 +1,26 @@
+// This is a regression test for issues that came up during review of the (closed)
+// PR #132289; this 2-crate test case is adapted from
+// the second example from @steffahn during review.
+// https://github.com/rust-lang/rust/pull/132289#issuecomment-2564587796
+
+//@ run-pass
+//@ aux-build: pr_review_132289_2_lib.rs
+
+externcrate pr_review_132289_2_lib;
+
+use pr_review_132289_2_lib::{function,Dyn,LocallyUnimplemented};
+
+structParam;
+
+implLocallyUnimplemented<Param>forDyn<Param>{}
+
+// it would be sound for `function::<Param>`'s return type to be
+// either of A or B, if that's what a soundness fix for overlap of
+// dyn Trait's impls would entail
+
+// In this test, we check at this call-site that the interpretation
+// is consistent with the function definition's body.
+fnmain(){
+let(arr, len) = function::<Param>();
+assert_eq!(arr.len(), len);
+}

tests/ui/coherence/pr-review-132289-3.rs

@@ -0,0 +1,50 @@
+// This is a regression test for issues that came up during review of the (closed)
+// PR #132289; this 3-ish-crate (including std) test case is adapted from
+// the third example from @steffahn during review.
+// https://github.com/rust-lang/rust/pull/132289#issuecomment-2564599221
+
+//@ run-pass
+//@ check-run-results
+//@ aux-build: pr_review_132289_3_lib.rs
+
+externcrate pr_review_132289_3_lib;
+
+use std::ops::Index;
+
+use pr_review_132289_3_lib::{call,Trait};
+
+traitSubIndex<I>:Index<I>{}
+
+structParam;
+
+traitProject{
+typeTy: ?Sized;
+}
+implProjectfor(){
+typeTy = dynSubIndex<Param,Output = ()>;
+}
+
+implIndex<Param>for <()asProject>::Ty{
+typeOutput = ();
+
+fnindex(&self, _:Param) -> &(){
+&()
+}
+}
+
+structStruct;
+
+implTraitforStruct{
+fnf(&self)
+where
+// higher-ranked to allow potentially-false bounds
+for<'a>dynIndex<(),Output = ()>:Index<()>,
+// after #132289 rustc used to believe this bound false
+{
+println!("hello!");
+}
+}
+
+fnmain(){
+call(&Struct);// <- would segfault if the method `f` wasn't part of the vtable
+}

tests/ui/coherence/pr-review-132289-3.run.stdout

@@ -0,0 +1 @@
+hello!