diff options
author | Jason Zaugg <jzaugg@gmail.com> | 2013-04-20 13:10:47 -0700 |
---|---|---|
committer | Jason Zaugg <jzaugg@gmail.com> | 2013-04-20 13:10:47 -0700 |
commit | df7cf4f3d9c35949436038728850927e782e587b (patch) | |
tree | b7e50c79077061a5ceddeedfe9641341b70f2cdd /test/files/pos | |
parent | 5147bb278c326e60956bac93cba95d4e07d95e84 (diff) | |
parent | 8703e00b3876cad8750abf82949737cac8bde6fe (diff) | |
download | scala-df7cf4f3d9c35949436038728850927e782e587b.tar.gz scala-df7cf4f3d9c35949436038728850927e782e587b.tar.bz2 scala-df7cf4f3d9c35949436038728850927e782e587b.zip |
Merge pull request #2322 from retronym/ticket/7200
SI-7200 Test case for fixed type inference error.
Diffstat (limited to 'test/files/pos')
-rw-r--r-- | test/files/pos/t7200b.scala | 50 |
1 files changed, 50 insertions, 0 deletions
diff --git a/test/files/pos/t7200b.scala b/test/files/pos/t7200b.scala new file mode 100644 index 0000000000..9d579c6ef9 --- /dev/null +++ b/test/files/pos/t7200b.scala @@ -0,0 +1,50 @@ +import language.higherKinds + +trait T { + def t = 0 +} +trait Foo { + def coflatMap[A <: T](f: A): A +} + +object O extends Foo { + def coflatMap[A <: T](f: A) = { + val f2 = coflatMap(f) // inferred in 2.9.2 / 2.10.0 as [Nothing] + f2.t // so this does't type check. + f2 + } +} + +// Why? When a return type is inherited, the derived method +// symbol first gets a preliminary type assigned, based on the +// 1) method type of a unique matching super member +// 2) viewed as a member type of the inheritor (to substitute, +// e.g. class type parameters) +// 3) substituted to replace the super-method's type parameters +// with those of the inheritor +// 4) dissected to take just the return type wrapped in thisMethodType(). +// +// In Scala 2.10.0 and earlier, this preliminary method type +// +// 1) [A#11329 <: <empty>#3.this.T#7068](<param> f#11333: A#11329)A#11329 +// 2) [A#11329 <: <empty>#3.this.T#7068](<param> f#11333: A#11329)A#11329 +// 3) (<param> f#12556: A#11336)A#11336 +// 4) [A#11336 <: <empty>#3.this.T#7068](<param> f#12552: A#11337&0)A#11336 +// +// The type #4 from the old version is problematic: the parameter is typed with +// a skolem for the type parameter `A`. It won't be considered to match the +// method it overrides, instead they are seen as being overloaded, and type inference +// goes awry (Nothing is inferred as the type argument for the recursive call +// to coflatMap. +// +// The Namers patch adds one step here: it subsitutes the type parameter symbols +// for the skolems: +// +// https://github.com/scala/scala/commit/b74c33eb#L2R1014 +// +// So we end up with a method symbol info: +// +// 5) [A#11336 <: <empty>#3.this.T#7068](<param> f#12505: A#11336)A#11336 +// +// This *does* match the method in the super class, and type inference +// chooses the correct type argument.
\ No newline at end of file |