Sugar for tuples does not preserve singleton types.

[scabug]

The following works:

scala> val x = "foo"
x: java.lang.String = foo

scala> Tuple2[x.type, x.type](x,x)
res0: (x.type, x.type) = (foo,foo)

But all of the following do not:

scala> val y = (x : x.type, x : x.type)
y: (java.lang.String, java.lang.String) = (foo,foo)

scala> val y : (x.type, x.type) = (x, x)
<console>:5: error: type mismatch;
 found   : (java.lang.String, java.lang.String)
 required: (x.type, x.type)
       val y : (x.type, x.type) = (x, x)
                                  ^

scala> val y : (x.type, x.type) = (x : x.type, x : x.type)
<console>:5: error: type mismatch;
 found   : (java.lang.String, java.lang.String)
 required: (x.type, x.type)
       val y : (x.type, x.type) = (x : x.type, x : x.type)
                                  ^
scala> val y : (x.type, x.type) = (x, x) : (x.type, x.type)
<console>:5: error: type mismatch;
 found   : (java.lang.String, java.lang.String)
 required: (x.type, x.type)
       val y : (x.type, x.type) = (x, x) : (x.type, x.type)
                                  ^

[scabug]

Imported From: https://issues.scala-lang.org/browse/SI-837?orig=1
Reporter: Geoffrey Alan Washburn (washburn)

[scabug]

@paulp said:
Slightly surprisingly, this looks unrelated to tuple sugar per se, but a consequence of type inference in a pattern context.

[scabug]

@retronym said:
Versions 2, 3, and 4 work with master.

scala> (x: x.type, x: x.type)
res3: (String, String) = (foo,foo)

scala> val y : (x.type, x.type) = (x, x)
y: (x.type, x.type) = (foo,foo)

scala> val y = (x : x.type, x : x.type)
y: (String, String) = (foo,foo)

scala> val y : (x.type, x.type) = (x, x)
y: (x.type, x.type) = (foo,foo)

scala> val y : (x.type, x.type) = (x : x.type, x : x.type)
y: (x.type, x.type) = (foo,foo)

scala> val y : (x.type, x.type) = (x, x) : (x.type, x.type)
y: (x.type, x.type) = (foo,foo)

[scabug]

@retronym said (edited on May 30, 2013 8:15:50 PM UTC):
Not sure if this is exactly what Paul was referring to, but here's an example of unwanted widening in a pattern match:

scala> val x = ""
x: String = ""

scala> (x match { case y => y }): x.type
<console>:9: error: type mismatch;
 found   : y.type (with underlying type String)
 required: x.type
              (x match { case y => y }): x.type
                                   ^

// scala/tools/nsc/transform/patmat/MatchTranslation.scala:134
val selectorTp = repeatedToSeq(elimAnonymousClass(selector.tpe.widen.withoutAnnotations))

[SethTisue]

@milessabin is this of interest?

[milessabin]

@SethTisue yes it is.

[milessabin]

As of scala/scala#5310 the situation is,

scala> val x = "foo"
x: String = foo

scala> Tuple2[x.type, x.type](x,x)
res0: (x.type, x.type) = (foo,foo)

scala> val y = (x : x.type, x : x.type)
y: (String, String) = (foo,foo)

scala> val y : (x.type, x.type) = (x, x)
y: (x.type, x.type) = (foo,foo)

scala> val y : (x.type, x.type) = (x : x.type, x : x.type)
y: (x.type, x.type) = (foo,foo)

scala> val y : (x.type, x.type) = (x, x) : (x.type, x.type)
y: (x.type, x.type) = (foo,foo)

The widening in the val y = (x : x.type, x : x.type) case matches this example using Tuple2,

scala> Tuple2(x: x.type, x: x.type)
res1: (String, String) = (foo,foo)

which is the correct behaviour given the absence of <: Singleton bounds on Tuple2's type parameters and the lack of a target type. So I think the sugar is doing the right thing here too.

So I'm declaring victory on this one.