Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
SI-5189 fixed: safe type infer for constr pattern
several fixes to the standard library due to
- the safer type checker this fix gives us (thus, some casts had to be inserted)
- SI-5548
- type inference gets a bit more complicated, it needs help (chainl1 in combinator.Parsers)
To deal with the type slack between actual (run-time) types and statically known
types, for each abstract type T, reflect its variance as a skolem that is
upper-bounded by T (covariant position), or lower-bounded by T (contravariant).
Consider the following example:
class AbsWrapperCov[+A]
case class Wrapper[B](x: Wrapped[B]) extends AbsWrapperCov[B]
def unwrap[T](x: AbsWrapperCov[T]): Wrapped[T] = x match {
case Wrapper(wrapped) =>
// Wrapper's type parameter must not be assumed to be equal to T,
// it's *upper-bounded* by it
wrapped // : Wrapped[_ <: T]
}
this method should type check if and only if Wrapped is covariant in its type
parameter
before inferring Wrapper's type parameter B from x's type AbsWrapperCov[T], we must
take into account that x's actual type is:
AbsWrapperCov[Tactual] forSome {type Tactual <: T}
since AbsWrapperCov is covariant in A -- in other words, we must not assume we know
T exactly, all we know is its upper bound
since method application is the only way to generate this slack between run-time and
compile-time types (TODO: right!?), we can simply replace skolems that represent
method type parameters as seen from the method's body by other skolems that are
(upper/lower)-bounded by that type-parameter skolem (depending on the variance
position of the skolem in the statically assumed type of the scrutinee, pt)
this type slack is introduced by adaptConstrPattern: before it calls
inferConstructorInstance, it creates a new context that holds the new existential
skolems
the context created by adaptConstrPattern must not be a CaseDef, since that
confuses instantiateTypeVar and the whole pushTypeBounds/restoreTypeBounds dance
(CaseDef contexts remember the bounds of the type params that we clobbered
during GADT typing)
typedCase deskolemizes the existential skolems back to the method skolems,
since they don't serve any further purpose (except confusing the old pattern
matcher)
typedCase is now better at finding that context (using nextEnclosing)- Loading branch information
Showing
12 changed files
with
180 additions
and
31 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,8 @@ | ||
| t5189b.scala:25: error: type mismatch; | ||
| found : TestNeg.Wrapped[?T2] where type ?T2 <: T | ||
| required: TestNeg.Wrapped[T] | ||
| Note: ?T2 <: T, but class Wrapped is invariant in type W. | ||
| You may wish to define W as +W instead. (SLS 4.5) | ||
| case Wrapper/*[_ <: T ]*/(wrapped) => wrapped // : Wrapped[_ <: T], which is a subtype of Wrapped[T] if and only if Wrapped is covariant in its type parameter | ||
| ^ | ||
| one error found |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,62 @@ | ||
| class TestPos { | ||
| class AbsWrapperCov[+A] | ||
| case class Wrapper[B](x: B) extends AbsWrapperCov[B] | ||
|
|
||
| def unwrap[T](x: AbsWrapperCov[T]): T = x match { | ||
| case Wrapper/*[_ <: T ]*/(x) => x // _ <: T, which is a subtype of T | ||
| } | ||
| } | ||
|
|
||
| object TestNeg extends App { | ||
| class AbsWrapperCov[+A] | ||
| case class Wrapper[B](x: Wrapped[B]) extends AbsWrapperCov[B] | ||
|
|
||
| /* | ||
| when inferring Wrapper's type parameter B from x's type AbsWrapperCov[T], | ||
| we must take into account that x's actual type is AbsWrapperCov[Tactual] forSome {type Tactual <: T} | ||
| as AbsWrapperCov is covariant in A -- in other words, we must not assume we know T exactly, all we know is its upper bound | ||
| since method application is the only way to generate this slack between run-time and compile-time types, | ||
| we'll simply replace the skolems that represent method type parameters as seen from the method's body by | ||
| other skolems that are (upper/lower)-bounded by the type-parameter skolems | ||
| (depending on whether the skolem appears in a covariant/contravariant position) | ||
| */ | ||
| def unwrap[T](x: AbsWrapperCov[T]): Wrapped[T] = x match { | ||
| case Wrapper/*[_ <: T ]*/(wrapped) => wrapped // : Wrapped[_ <: T], which is a subtype of Wrapped[T] if and only if Wrapped is covariant in its type parameter | ||
| } | ||
|
|
||
| class Wrapped[W](var cell: W) // must be invariant (to trigger the bug) | ||
|
|
||
| // class A { def imNotAB = println("notB")} | ||
| // class B | ||
| // | ||
| // val w = new Wrapped(new A) | ||
| // unwrap[Any](Wrapper(w)).cell = new B | ||
| // w.cell.imNotAB | ||
| } | ||
|
|
||
| // class TestPos1 { | ||
| // class Base[T] | ||
| // case class C[T](x: T) extends Base[T] | ||
| // def foo[T](b: Base[T]): T = b match { case C(x) => x } | ||
| // | ||
| // case class Span[K <: Ordered[K]](low: Option[K], high: Option[K]) extends Function1[K, Boolean] { | ||
| // override def equals(x$1: Any): Boolean = x$1 match { | ||
| // case Span((low$0 @ _), (high$0 @ _)) if low$0.equals(low).$amp$amp(high$0.equals(high)) => true | ||
| // case _ => false | ||
| // } | ||
| // def apply(k: K): Boolean = this match { | ||
| // case Span(Some(low), Some(high)) => (k >= low && k <= high) | ||
| // case Span(Some(low), None) => (k >= low) | ||
| // case Span(None, Some(high)) => (k <= high) | ||
| // case _ => false | ||
| // } | ||
| // } | ||
| // } | ||
| // | ||
| // class TestNeg1 { | ||
| // case class Foo[T, U](f: T => U) | ||
| // def f(x: Any): Any => Any = x match { case Foo(bar) => bar } | ||
| // // uh-oh, Any => Any should be Nothing => Any. | ||
| // } | ||
|
|