Remove Reflection.LambdaType #9861
Conversation
|
|
||
| case ParamRef(lambda, idx) => | ||
| lambda match { | ||
| (lambda: @unchecked) match { |
There was a problem hiding this comment.
@liufengyun I was getting the following exhaustivity fatal warning where lambda: MethodType | PolyType | TypeLambda. Same if did the cases with case lambda: MethodType => .... It might be related to having a class tag preforming the type test.
[error] 1182 | lambda match {
[error] | ^^^^^^
[error] |match may not be exhaustive.
[error] |
[error] |It would fail on pattern case: _: MethodType, _: PolyType, _: TypeLambda
There was a problem hiding this comment.
Yes, it's unknown that the extractors are irrefutable for the corresponding type MethodType or PolyType .
There was a problem hiding this comment.
Should we make ClassTag.unapply (and later TypeTest.unapply) extractors irrefutable? It feels like they should be.
There was a problem hiding this comment.
ClassTag.unapply is defined as follows:
def unapply(x: Any): Option[T] =
if (runtimeClass.isInstance(x)) Some(x.asInstanceOf[T])
else NoneIt's not irrefutable in general. Semantically, we may assume it's irrefutable if we know x takes the type T.
There was a problem hiding this comment.
That is the contract of the method. If x does not take the type T then implementation is broken and we cannot reason about the patterns correctly anyway.
There was a problem hiding this comment.
Is the following supposed to be irrefutable?
lambda match
case lambda: MethodType =>
case lambda: PolyType =>
case lambda: TypeLambda =>
| trait ParamRefMethods: | ||
| extension (self: ParamRef): | ||
| def binder: LambdaType | ||
| def binder: MethodType | PolyType | TypeLambda |
There was a problem hiding this comment.
We could also just use
def binder: TypeIn theory, this should only help with pattern matching exhaustivity which currently fails. See other comments.
This can be encoded with intersection types in the few places where it is relevant
nicolasstucki
force-pushed
the
remove-reflection-lambdatype
branch
from
b962805 to
4a8a1a7
Compare
| end extension | ||
| end RecursiveTypeMethodsImpl | ||
|
|
||
| type LambdaType = dotc.core.Types.LambdaType |
There was a problem hiding this comment.
What do we gain by removing this? And if a union is preferable but needs to be used in multiple context, maybe we could have type LambdaType = MethodType | PolyType | TypeLambda ?
3 participants
This can be encoded with intersection types in the few places where it is relevant
Based on #9818