Handle Ranges in dependent annotations

# Conflicts: # compiler/src/dotty/tools/dotc/core/Types.scala
scala · Aug 25, 2021 · 645d988 · 645d988
1 parent b3d7433
commit 645d988
Show file tree

Hide file tree

Showing 2 changed files with 28 additions and 13 deletions.
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -5392,6 +5392,17 @@ object Types {
       variance = saved
       derivedLambdaType(tp)(ptypes1, this(restpe))
 
+    protected def isRange(tp: Type): Boolean = tp.isInstanceOf[Range]
+
+    private def diffType(ann: Tree): Type =
+      val acc = new TreeAccumulator[Type]:
+        def apply(x: Type, tree: Tree)(using Context): Type =
+          if isRange(x) then x
+          else
+            val tp1 = thisMap(tree.tpe)
+            foldOver(if tp1 =:= tree.tpe then x else tp1, tree)
+      acc(NoType, ann)
+
     /** Map this function over given type */
     def mapOver(tp: Type): Type = {
       record(s"TypeMap mapOver ${getClass}")
@@ -5435,17 +5446,16 @@ object Types {
 
         case tp @ AnnotatedType(underlying, annot) =>
           val underlying1 = this(underlying)
-          val annot1 =
-            if underlying1 ne underlying then mapOver(annot)
-            else annot match
-              case ConcreteAnnotation(ann)
-              if ann.existsSubTree { t =>
-                  val tpe = t.typeOpt
-                  tpe.exists && !(this(tpe) =:= tpe)
-                } => mapOver(annot)
-              case _ => annot
-          if (underlying1 eq underlying) && (annot eq annot1) then tp
-          else derivedAnnotatedType(tp, underlying1, annot1)
+          if (underlying1 ne underlying) || annot.isInstanceOf[ConcreteAnnotation] then
+            val diff = diffType(annot.tree)
+            if isRange(diff) then
+              // Can't map a tree type to a Range, drop annotation instead
+              underlying1
+            else
+              val annot1 = if diff.exists then mapOver(annot) else annot
+              derivedAnnotatedType(tp, underlying1, annot1)
+          else
+            derivedAnnotatedType(tp, underlying1, annot)
 
         case _: ThisType
           | _: BoundType
@@ -5566,8 +5576,6 @@ object Types {
 
     protected def emptyRange = range(defn.NothingType, defn.AnyType)
 
-    protected def isRange(tp: Type): Boolean = tp.isInstanceOf[Range]
-
     protected def lower(tp: Type): Type = tp match {
       case tp: Range => tp.lo
       case _ => tp

diff --git a/tests/pos/dependent-annot.scala b/tests/pos/dependent-annot.scala
@@ -0,0 +1,7 @@
+class C
+class ann(x: Any*) extends annotation.Annotation
+
+def f(y: Cap, z: Cap) =
+  def g(): C @ann(y, z) = ???
+  val ac: ((x: C) => Array[String @retains(x)]) = ???
+  val dc = ac(g())