Imported From: https://issues.scala-lang.org/browse/SI-8740?orig=1
Reporter: Arek Burdach (ark_adius)
Affected Versions: 2.11.1

@paulp said:
Similar to #8709, but with reduced opportunity to deny that it's a bug.

@retronym said:
This is an interesting one. I was the same corners of subtyping recently to investigate a problem with refinement types with an existential as one of the parents. My patch for that didn't solve this problem.

But I pushed on to analyze why this fails. See the comments in the test case here: https://github.com/retronym/scala/compare/scala:2.11.x...ticket/8740?expand=1

That branch also sketches out a fix, in which I reorder the descent into a refinement's parent types on the LHS to avoid overconstraining type variables.

@milessabin said:
Any chance of this going in for 2.12.0-M4?

@retronym said:
M4 is already a bit late, so we're planning to ship in the next few days once we have SAM support merged. M5 would be possible, though.

I was never all that happy with my solution, it seemed very arbitrary.

Maybe this version would be a fraction less ugly.

  def check = parents exists (retry(_, tp2))
  if (tp.isGround)  check
  else suspendingTypeVars(typeVarsInType(tp))(check) else check

@benhutchison said:
It'd be great to see this fixed. I was wondering why I hadn't hit it myself, which lead me to a partial workaround:

In the failing example, TypeAlias is an alias that refers to another alias @@. Ive had success using aliases for tagged types, but Ive always defined directly in terms of unaliased types, eg

type Distance = Int with TagAs.Tagged[DistanceObj.type]

object TagAs {
  trait Tagged[+U]
}

That is, can't stack 2 aliases over a tagged type, but 1 seems OK.

@cvogt said:
Jason, did the expected fix end up not being a full solution?

B. Tommy Jensen (tommy-at-grindvoll.com) said:
I just bumped into this one today. Same behavior with 2.12.0. Any chance that a fix will be included in the near future?

Tweak the example a bit and I suspect the outlined fix breaks down again:

trait SomeTag
type @@[+A, T] = A with T
def withSomeTag[A, B](a: A): A @@ B  = a.asInstanceOf[A @@ B]
// def need(a: String @@ SomeTag) = ??? // <- it works
// but this not:
type TypeAlias = String @@ SomeTag
def need(a: TypeAlias) = ???
need(withSomeTag("foo"))

Now we have type variables in both parents of the refined type (not uncommon if we're defining an implicit typeclass instance for any tag) and isGround changes nothing.

This works though:

trait Tagged[T]
trait SomeTag
type @@[+A, T] = Tagged[T] with A
def withSomeTag[A, B](a: A): A @@ B  = a.asInstanceOf[A @@ B]
// def need(a: String @@ SomeTag) = ??? // <- it works
// but this not:
type TypeAlias = String @@ SomeTag
def need(a: TypeAlias) = ???
need(withSomeTag("foo"))

^ Sorry, now it infers the correct types, but the erasure is wrong 😩

A workaround that works:

object Main {
  trait SomeTag
  type @@[+A, T] <: A with T
  def withSomeTag[A, B](a: A): A @@ B  = a.asInstanceOf[A @@ B]
  // def need(a: String @@ SomeTag) = ??? // <- it works
  // but this not:
  type TypeAlias = String @@ SomeTag
  def need(a: TypeAlias) = ???
  need(withSomeTag("foo"))
}

The only downside is that primitives will be boxed.