Skip to content

Commit 651fb83

Browse files
oderskyodersky
authored
Merge pull request #3723 from dotty-staging/fix-#3564
Fix #3564: Allow annotated singleton types
2 parents dc1bf9f + 862817f commit 651fb83

File tree

12 files changed

+68
-46
lines changed

12 files changed

+68
-46
lines changed

‎compiler/src/dotty/tools/dotc/ast/tpd.scala‎

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -337,10 +337,11 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
337337
followOuterLinks(This(tp.symbol.moduleClass.asClass))
338338
else if (tp.symbol hasAnnotation defn.ScalaStaticAnnot)
339339
Ident(tp)
340-
else tp.prefix match {
341-
case pre: SingletonType => followOuterLinks(singleton(pre)).select(tp)
342-
case pre => Select(TypeTree(pre), tp)
343-
} // no checks necessary
340+
else {
341+
val pre = tp.prefix
342+
if (pre.isSingleton) followOuterLinks(singleton(pre.dealias)).select(tp)
343+
else Select(TypeTree(pre), tp)
344+
}
344345

345346
def ref(sym: Symbol)(implicit ctx: Context): Tree =
346347
ref(NamedType(sym.owner.thisType, sym.name, sym.denot))
@@ -776,7 +777,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
776777
applyOverloaded(tree, nme.EQ, that :: Nil, Nil, defn.BooleanType)
777778

778779
/** `tree.isInstanceOf[tp]`, with special treatment of singleton types */
779-
def isInstance(tp: Type)(implicit ctx: Context): Tree = tp match {
780+
def isInstance(tp: Type)(implicit ctx: Context): Tree = tp.dealias match {
780781
case tp: SingletonType =>
781782
if (tp.widen.derivesFrom(defn.ObjectClass))
782783
tree.ensureConforms(defn.ObjectType).select(defn.Object_eq).appliedTo(singleton(tp))

‎compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -247,10 +247,10 @@ trait ConstraintHandling {
247247
*/
248248
def instanceType(param: TypeParamRef, fromBelow: Boolean): Type = {
249249
def upperBound = constraint.fullUpperBound(param)
250-
def isSingleton(tp: Type): Boolean = tp match {
250+
def isMultiSingleton(tp: Type): Boolean = tp.stripAnnots match {
251251
case tp: SingletonType => true
252-
case AndType(tp1, tp2) => isSingleton(tp1) | isSingleton(tp2)
253-
case OrType(tp1, tp2) => isSingleton(tp1) & isSingleton(tp2)
252+
case AndType(tp1, tp2) => isMultiSingleton(tp1) | isMultiSingleton(tp2)
253+
case OrType(tp1, tp2) => isMultiSingleton(tp1) & isMultiSingleton(tp2)
254254
case _ => false
255255
}
256256
def isFullyDefined(tp: Type): Boolean = tp match {
@@ -274,7 +274,7 @@ trait ConstraintHandling {
274274
// 1. If instance is from below and is a singleton type, yet upper bound is
275275
// not a singleton type or a reference to `scala.Singleton`, widen the
276276
// instance.
277-
if (fromBelow && isSingleton(inst) && !isSingleton(upperBound)
277+
if (fromBelow && isMultiSingleton(inst) && !isMultiSingleton(upperBound)
278278
&& !upperBound.isRef(defn.SingletonClass))
279279
inst = inst.widen
280280

‎compiler/src/dotty/tools/dotc/core/Types.scala‎

Lines changed: 10 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -114,6 +114,7 @@ object Types {
114114
case _: SingletonType | NoPrefix => true
115115
case tp: RefinedOrRecType => tp.parent.isStable
116116
case tp: ExprType => tp.resultType.isStable
117+
case tp: AnnotatedType => tp.tpe.isStable
117118
case _ => false
118119
}
119120

@@ -247,6 +248,9 @@ object Types {
247248
case _ => NoType
248249
}
249250

251+
/** Is this type a (possibly aliased) singleton type? */
252+
def isSingleton(implicit ctx: Context) = dealias.isInstanceOf[SingletonType]
253+
250254
/** Is this type guaranteed not to have `null` as a value? */
251255
final def isNotNull(implicit ctx: Context): Boolean = this match {
252256
case tp: ConstantType => tp.value.value != null
@@ -354,7 +358,6 @@ object Types {
354358
@tailrec final def typeSymbol(implicit ctx: Context): Symbol = this match {
355359
case tp: TypeRef => tp.symbol
356360
case tp: ClassInfo => tp.cls
357-
// case ThisType(cls) => cls // needed?
358361
case tp: SingletonType => NoSymbol
359362
case tp: TypeProxy => tp.underlying.typeSymbol
360363
case _ => NoSymbol
@@ -918,7 +921,7 @@ object Types {
918921
/** Widen from singleton type to its underlying non-singleton
919922
* base type by applying one or more `underlying` dereferences.
920923
*/
921-
final def widenSingleton(implicit ctx: Context): Type = stripTypeVar match {
924+
final def widenSingleton(implicit ctx: Context): Type = stripTypeVar.stripAnnots match {
922925
case tp: SingletonType if !tp.isOverloaded => tp.underlying.widenSingleton
923926
case _ => this
924927
}
@@ -3555,16 +3558,18 @@ object Types {
35553558
// ----- Annotated and Import types -----------------------------------------------
35563559

35573560
/** An annotated type tpe @ annot */
3558-
case class AnnotatedType(tpe: Type, annot: Annotation)
3559-
extends UncachedProxyType with ValueType {
3561+
case class AnnotatedType(tpe: Type, annot: Annotation) extends UncachedProxyType with ValueType {
35603562
// todo: cache them? but this makes only sense if annotations and trees are also cached.
3563+
35613564
override def underlying(implicit ctx: Context): Type = tpe
3565+
35623566
def derivedAnnotatedType(tpe: Type, annot: Annotation) =
35633567
if ((tpe eq this.tpe) && (annot eq this.annot)) this
35643568
else AnnotatedType(tpe, annot)
35653569

35663570
override def stripTypeVar(implicit ctx: Context): Type =
35673571
derivedAnnotatedType(tpe.stripTypeVar, annot)
3572+
35683573
override def stripAnnots(implicit ctx: Context): Type = tpe.stripAnnots
35693574
}
35703575

@@ -3965,7 +3970,7 @@ object Types {
39653970
*/
39663971
def tryWiden(tp: NamedType, pre: Type): Type = pre.member(tp.name) match {
39673972
case d: SingleDenotation =>
3968-
d.info match {
3973+
d.info.dealias match {
39693974
case TypeAlias(alias) =>
39703975
// if H#T = U, then for any x in L..H, x.T =:= U,
39713976
// hence we can replace with U under all variances

‎compiler/src/dotty/tools/dotc/transform/Erasure.scala‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -244,12 +244,12 @@ object Erasure {
244244
* in ExtensionMethods#transform.
245245
*/
246246
def cast(tree: Tree, pt: Type)(implicit ctx: Context): Tree = trace(i"cast ${tree.tpe.widen} --> $pt", show = true) {
247+
247248
def wrap(tycon: TypeRef) =
248249
ref(u2evt(tycon.typeSymbol.asClass)).appliedTo(tree)
249250
def unwrap(tycon: TypeRef) =
250251
ref(evt2u(tycon.typeSymbol.asClass)).appliedTo(tree)
251252

252-
253253
assert(!pt.isInstanceOf[SingletonType], pt)
254254
if (pt isRef defn.UnitClass) unbox(tree, pt)
255255
else (tree.tpe.widen, pt) match {

‎compiler/src/dotty/tools/dotc/transform/patmat/Space.scala‎

Lines changed: 15 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -806,22 +806,23 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
806806
def checkable(tree: Match): Boolean = {
807807
// Possible to check everything, but be compatible with scalac by default
808808
def isCheckable(tp: Type): Boolean =
809-
!tp.hasAnnotation(defn.UncheckedAnnot) && (
810-
ctx.settings.YcheckAllPatmat.value ||
811-
tp.typeSymbol.is(Sealed) ||
812-
tp.isInstanceOf[OrType] ||
813-
(tp.isInstanceOf[AndType] && {
814-
val and = tp.asInstanceOf[AndType]
815-
isCheckable(and.tp1) || isCheckable(and.tp2)
816-
}) ||
817-
tp.isRef(defn.BooleanClass) ||
818-
tp.typeSymbol.is(Enum) ||
819-
canDecompose(tp) ||
820-
(defn.isTupleType(tp) && tp.dealias.argInfos.exists(isCheckable(_)))
821-
)
809+
!tp.hasAnnotation(defn.UncheckedAnnot) && {
810+
val tpw = tp.widen.dealias
811+
ctx.settings.YcheckAllPatmat.value ||
812+
tpw.typeSymbol.is(Sealed) ||
813+
tpw.isInstanceOf[OrType] ||
814+
(tpw.isInstanceOf[AndType] && {
815+
val and = tpw.asInstanceOf[AndType]
816+
isCheckable(and.tp1) || isCheckable(and.tp2)
817+
}) ||
818+
tpw.isRef(defn.BooleanClass) ||
819+
tpw.typeSymbol.is(Enum) ||
820+
canDecompose(tpw) ||
821+
(defn.isTupleType(tpw) && tpw.argInfos.exists(isCheckable(_)))
822+
}
822823

823824
val Match(sel, cases) = tree
824-
val res = isCheckable(sel.tpe.widen.dealiasKeepAnnots)
825+
val res = isCheckable(sel.tpe)
825826
debug.println(s"checkable: ${sel.show} = $res")
826827
res
827828
}

‎compiler/src/dotty/tools/dotc/typer/Checking.scala‎

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -561,8 +561,7 @@ trait Checking {
561561
*/
562562
def checkImplicitParamsNotSingletons(vparamss: List[List[ValDef]])(implicit ctx: Context): Unit = vparamss match {
563563
case (vparam :: Nil) :: _ if !(vparam.symbol is Implicit) =>
564-
if (vparam.tpt.tpe.isInstanceOf[SingletonType])
565-
ctx.error(s"implicit conversion may not have a parameter of singleton type", vparam.tpt.pos)
564+
checkNotSingleton(vparam.tpt, " to be parameter type of an implicit conversion")
566565
case _ =>
567566
}
568567

@@ -660,9 +659,7 @@ trait Checking {
660659

661660
/** Check that `tpt` does not refer to a singleton type */
662661
def checkNotSingleton(tpt: Tree, where: String)(implicit ctx: Context): Tree =
663-
if (tpt.tpe.isInstanceOf[SingletonType]) {
664-
errorTree(tpt, ex"Singleton type ${tpt.tpe} is not allowed $where")
665-
}
662+
if (tpt.tpe.isSingleton) errorTree(tpt, ex"Singleton type ${tpt.tpe} is not allowed $where")
666663
else tpt
667664

668665
/** Verify classes extending AnyVal meet the requirements */

‎compiler/src/dotty/tools/dotc/typer/Inliner.scala‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -352,8 +352,8 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
352352
case tp: MethodType =>
353353
(tp.paramNames, tp.paramInfos, argss.head).zipped.foreach { (name, paramtp, arg) =>
354354
def isByName = paramtp.dealias.isInstanceOf[ExprType]
355-
paramBinding(name) = arg.tpe.stripAnnots.stripTypeVar match {
356-
case argtpe: SingletonType if isIdempotentExpr(arg) => argtpe
355+
paramBinding(name) = arg.tpe.dealias match {
356+
case _: SingletonType if isIdempotentExpr(arg) => arg.tpe
357357
case argtpe =>
358358
val inlineFlag = if (paramtp.hasAnnotation(defn.InlineParamAnnot)) Inline else EmptyFlags
359359
val (bindingFlags, bindingType) =
@@ -476,7 +476,7 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
476476
}
477477
case _: Ident =>
478478
paramProxy.get(tree.tpe) match {
479-
case Some(t: SingletonType) if tree.isTerm => singleton(t).withPos(tree.pos)
479+
case Some(t) if tree.isTerm && t.isSingleton => singleton(t).withPos(tree.pos)
480480
case Some(t) if tree.isType => TypeTree(t).withPos(tree.pos)
481481
case None => tree
482482
}

‎compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -93,7 +93,7 @@ trait TypeAssigner {
9393
def apply(tp: Type): Type = tp match {
9494
case tp: TermRef
9595
if toAvoid(tp.symbol) || partsToAvoid(mutable.Set.empty, tp.info).nonEmpty =>
96-
tp.info.widenExpr match {
96+
tp.info.widenExpr.dealias match {
9797
case info: SingletonType => apply(info)
9898
case info => range(tp.info.bottomType, apply(info))
9999
}
@@ -124,7 +124,7 @@ trait TypeAssigner {
124124
* 1. We first try a widening conversion to the type's info with
125125
* the original prefix. Since the original prefix is known to
126126
* be a subtype of the returned prefix, this can improve results.
127-
* 2. IThen, if the approximation result is a singleton reference C#x.type, we
127+
* 2. Then, if the approximation result is a singleton reference C#x.type, we
128128
* replace by the widened type, which is usually more natural.
129129
* 3. Finally, we need to handle the case where the prefix type does not have a member
130130
* named `tp.name` anymmore. In that case, we need to fall back to Bot..Top.
@@ -133,7 +133,7 @@ trait TypeAssigner {
133133
if (pre eq tp.prefix)
134134
tp
135135
else tryWiden(tp, tp.prefix).orElse {
136-
if (tp.isTerm && variance > 0 && !pre.isInstanceOf[SingletonType])
136+
if (tp.isTerm && variance > 0 && !pre.isSingleton)
137137
apply(tp.info.widenExpr)
138138
else if (upper(pre).member(tp.name).exists)
139139
super.derivedSelect(tp, pre)
@@ -538,7 +538,7 @@ trait TypeAssigner {
538538
tree.withType(sym.termRef)
539539

540540
def assignType(tree: untpd.Annotated, arg: Tree, annot: Tree)(implicit ctx: Context) =
541-
tree.withType(AnnotatedType(arg.tpe.widen, Annotation(annot)))
541+
tree.withType(AnnotatedType(arg.tpe, Annotation(annot)))
542542

543543
def assignType(tree: untpd.PackageDef, pid: Tree)(implicit ctx: Context) =
544544
tree.withType(pid.symbol.termRef)

‎compiler/src/dotty/tools/dotc/typer/Typer.scala‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1593,7 +1593,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
15931593
if (ctx.mode is Mode.Type)
15941594
assignType(cpy.Annotated(tree)(arg1, annot1), arg1, annot1)
15951595
else {
1596-
val tpt = TypeTree(AnnotatedType(arg1.tpe.widen, Annotation(annot1)))
1596+
val tpt = TypeTree(AnnotatedType(arg1.tpe, Annotation(annot1)))
15971597
assignType(cpy.Typed(tree)(arg1, tpt), tpt)
15981598
}
15991599
}
@@ -2268,7 +2268,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
22682268
// is tried. See strawman-contrib MapDecoratorTest.scala for an example where this happens.
22692269
err.typeMismatch(tree, pt)
22702270
}
2271-
case wtp: MethodType if !pt.isInstanceOf[SingletonType] =>
2271+
case wtp: MethodType if !pt.isSingleton =>
22722272
val arity =
22732273
if (functionExpected)
22742274
if (!isFullyDefined(pt, ForceDegree.none) && isFullyDefined(wtp, ForceDegree.none))

‎compiler/test-resources/repl/patdef‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,8 +5,8 @@ scala> val (Const, List(`x`, _, a), b) = (0, List(0, 1337, 1), 2)
55
val a: Int = 1
66
val b: Int = 2
77
scala> val a@b = 0
8-
val a: Int @unchecked = 0
9-
val b: Int @unchecked = 0
8+
val a: Int = 0
9+
val b: Int = 0
1010
scala> val Y = 2
1111
val Y: Int = 2
1212
scala> val X, Y = 3
@@ -15,7 +15,7 @@ val Y: Int = 3
1515
scala> val foo = Y
1616
val foo: Int = 3
1717
scala> val X @ List(_) = List(1)
18-
val X: List[Int] @unchecked = List(1)
18+
val X: List[Int] = List(1)
1919
scala> val _ @ _ = 1
2020
scala> val _ @ List(x) = List(1)
2121
val x: Int = 1

0 commit comments

Comments
 (0)