Rename @Alpha to @TargetNAME

odersky · odersky · commit 118f419d8fb5 · 2020-11-10T08:28:49.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
@@ -173,7 +173,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val YexplicitNulls: Setting[Boolean] = BooleanSetting("-Yexplicit-nulls", "Make reference types non-nullable. Nullable types can be expressed with unions: e.g. String|Null.")
   val YerasedTerms: Setting[Boolean] = BooleanSetting("-Yerased-terms", "Allows the use of erased terms.")
   val YcheckInit: Setting[Boolean] = BooleanSetting("-Ycheck-init", "Check initialization of objects")
-  val YrequireAlpha: Setting[Boolean] = BooleanSetting("-Yrequire-alpha", "Warn if an operator is defined without an @alpha annotation")
+  val YrequireTargetName: Setting[Boolean] = BooleanSetting("-Yrequire-targetName", "Warn if an operator is defined without a @targetName annotation")
 
   /** Area-specific debug output */
   val YexplainLowlevel: Setting[Boolean] = BooleanSetting("-Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -937,7 +937,7 @@ class Definitions {
   @tu lazy val ShowAsInfixAnnot: ClassSymbol = requiredClass("scala.annotation.showAsInfix")
   @tu lazy val FunctionalInterfaceAnnot: ClassSymbol = requiredClass("java.lang.FunctionalInterface")
   @tu lazy val InfixAnnot: ClassSymbol = requiredClass("scala.annotation.infix")
-  @tu lazy val AlphaAnnot: ClassSymbol = requiredClass("scala.annotation.alpha")
+  @tu lazy val TargetNameAnnot: ClassSymbol = requiredClass("scala.annotation.targetName")
   @tu lazy val VarargsAnnot: ClassSymbol = requiredClass("scala.annotation.varargs")
 
   // A list of annotations that are commonly used to indicate that a field/method argument or return
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -495,26 +495,21 @@ object SymDenotations {
     /** `fullName` where `.' is the separator character */
     def fullName(using Context): Name = fullNameSeparated(QualifiedName)
 
-    /** The name given in an `@alpha` annotation if one is present, `name` otherwise */
+    /** The name given in a `@targetName` annotation if one is present, `name` otherwise */
     final def erasedName(using Context): Name =
-      val alphaAnnot =
-        if isAllOf(ModuleClass | Synthetic) then companionClass.getAnnotation(defn.AlphaAnnot)
-        else getAnnotation(defn.AlphaAnnot)
-      alphaAnnot match {
+      val targetNameAnnot =
+        if isAllOf(ModuleClass | Synthetic) then companionClass.getAnnotation(defn.TargetNameAnnot)
+        else getAnnotation(defn.TargetNameAnnot)
+      targetNameAnnot match
         case Some(ann) =>
-          ann.arguments match {
+          ann.arguments match
             case Literal(Constant(str: String)) :: Nil =>
-              if (isType)
-                if (is(ModuleClass))
-                  str.toTypeName.moduleClassName
-                else
-                  str.toTypeName
-              else
-                str.toTermName
+              if isType then
+                if is(ModuleClass) then str.toTypeName.moduleClassName
+                else str.toTypeName
+              else str.toTermName
             case _ => name
-          }
         case _ => name
-      }
 
     // ----- Tests -------------------------------------------------
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -308,19 +308,20 @@ object Checking {
     }
   }
 
-  /** If `sym` has an operator name, check that it has an @alpha annotation in 3.1 and later
+  /** Under -Yrequire-targetName, if `sym` has an operator name, check that it has a
+   *  @targetName annotation.
    */
   def checkValidOperator(sym: Symbol)(using Context): Unit =
-    if ctx.settings.YrequireAlpha.value then
+    if ctx.settings.YrequireTargetName.value then
       sym.name.toTermName match
         case name: SimpleName
         if name.isOperatorName
           && !name.isSetterName
           && !name.isConstructorName
-          && !sym.getAnnotation(defn.AlphaAnnot).isDefined
+          && !sym.getAnnotation(defn.TargetNameAnnot).isDefined
           && !sym.is(Synthetic) =>
           report.warning(
-            i"$sym has an operator name; it should come with an @alpha annotation", sym.srcPos)
+            i"$sym has an operator name; it should come with an @targetName annotation", sym.srcPos)
         case _ =>
 
   /** Check that `info` of symbol `sym` is not cyclic.
@@ -1203,19 +1204,16 @@ trait Checking {
     }
 
   /** Check that symbol's external name does not clash with symbols defined in the same scope */
-  def checkNoAlphaConflict(stats: List[Tree])(using Context): Unit = {
+  def checkNoTargetNameConflict(stats: List[Tree])(using Context): Unit =
     var seen = Set[Name]()
-    for (stat <- stats) {
+    for stat <- stats do
       val sym = stat.symbol
       val ename = sym.erasedName
-      if (ename != sym.name) {
+      if ename != sym.name then
         val preExisting = ctx.effectiveScope.lookup(ename)
-        if (preExisting.exists || seen.contains(ename))
-          report.error(em"@alpha annotation ${'"'}$ename${'"'} clashes with other definition is same scope", stat.srcPos)
+        if preExisting.exists || seen.contains(ename) then
+          report.error(em"@targetName annotation ${'"'}$ename${'"'} clashes with other definition in same scope", stat.srcPos)
         if stat.isDef then seen += ename
-      }
-    }
-  }
 }
 
 trait ReChecking extends Checking {
@@ -1238,7 +1236,7 @@ trait NoChecking extends ReChecking {
   override def checkImplicitConversionUseOK(tree: Tree)(using Context): Unit = ()
   override def checkFeasibleParent(tp: Type, pos: SrcPos, where: => String = "")(using Context): Type = tp
   override def checkInlineConformant(tpt: Tree, tree: Tree, sym: Symbol)(using Context): Unit = ()
-  override def checkNoAlphaConflict(stats: List[Tree])(using Context): Unit = ()
+  override def checkNoTargetNameConflict(stats: List[Tree])(using Context): Unit = ()
   override def checkParentCall(call: Tree, caller: ClassSymbol)(using Context): Unit = ()
   override def checkSimpleKinded(tpt: Tree)(using Context): Tree = tpt
   override def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(using Context): Unit = ()
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -433,9 +433,9 @@ object RefChecks {
         overrideError("has incompatible type" + err.whyNoMatchStr(memberTp(self), otherTp(self)))
       else if (member.erasedName != other.erasedName)
         if (other.erasedName != other.name)
-          overrideError(i"needs to be declared with @alpha(${"\""}${other.erasedName}${"\""}) so that external names match")
+          overrideError(i"needs to be declared with @targetName(${"\""}${other.erasedName}${"\""}) so that external names match")
         else
-          overrideError("cannot have an @alpha annotation since external names would be different")
+          overrideError("cannot have a @targetName annotation since external names would be different")
       else
         checkOverrideDeprecated()
     }
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1982,7 +1982,7 @@ class Typer extends Namer
     if (sym.isConstructor && !sym.isPrimaryConstructor) {
       val ename = sym.erasedName
       if (ename != sym.name)
-        report.error(em"@alpha annotation ${'"'}$ename${'"'} may not be used on a constructor", ddef.srcPos)
+        report.error(em"@targetName annotation may not be used on a constructor", ddef.srcPos)
 
       for (param <- tparams1 ::: vparamss1.flatten)
         checkRefsLegal(param, sym.owner, (name, sym) => sym.is(TypeParam), "secondary constructor")
@@ -2665,7 +2665,7 @@ class Typer extends Namer
     }
     val (stats0, finalCtx) = traverse(stats)(using localCtx)
     val stats1 = stats0.mapConserve(finalize)
-    if (ctx.owner == exprOwner) checkNoAlphaConflict(stats1)
+    if ctx.owner == exprOwner then checkNoTargetNameConflict(stats1)
     (stats1, finalCtx)
   }
 
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -153,7 +153,7 @@ class CompilationTests {
         defaultOptions),
       compileFile("tests/neg-custom-args/i6300.scala", allowDeepSubtypes),
       compileFile("tests/neg-custom-args/infix.scala", defaultOptions.and("-source", "3.1", "-deprecation", "-Xfatal-warnings")),
-      compileFile("tests/neg-custom-args/missing-alpha.scala", defaultOptions.and("-Yrequire-alpha", "-Xfatal-warnings")),
+      compileFile("tests/neg-custom-args/missing-alpha.scala", defaultOptions.and("-Yrequire-targetName", "-Xfatal-warnings")),
       compileFile("tests/neg-custom-args/wildcards.scala", defaultOptions.and("-source", "3.1", "-deprecation", "-Xfatal-warnings")),
       compileFile("tests/neg-custom-args/indentRight.scala", defaultOptions.and("-noindent", "-Xfatal-warnings")),
       compileFile("tests/neg-custom-args/extmethods-tparams.scala", defaultOptions.and("-deprecation", "-Xfatal-warnings")),
diff --git a/library/src/scala/annotation/alpha.scala b/library/src/scala/annotation/alpha.scala
@@ -6,4 +6,5 @@ package scala.annotation
  *  the regular name. An `alpha` annotation is mandatory for definitions
  *  with symbolic names.
  */
+@deprecated("use @targetName instead")
 final class alpha(externalName: String) extends StaticAnnotation
diff --git a/library/src/scala/annotation/targetName.scala b/library/src/scala/annotation/targetName.scala
@@ -0,0 +1,8 @@
+package scala.annotation
+
+/** An annotation that defines an external name for a definition.
+ *  If an `targetName(extname)` annotation is given for a method or some other
+ *  definition, its implementation will use the name `extname` instead of
+ *  the regular name.
+ */
+final class targetName(name: String) extends StaticAnnotation
diff --git a/tests/neg-custom-args/missing-alpha.scala b/tests/neg-custom-args/missing-alpha.scala
@@ -1,8 +1,8 @@
 // Compile with -strict -Xfatal-warnings -deprecation
-import scala.annotation.alpha
+import scala.annotation.targetName
 class & {   // error
 
-  @alpha("op") def *(x: Int): Int = ???  // OK
+  @targetName("op") def *(x: Int): Int = ???  // OK
   def / (x: Int): Int       // error
   val frozen_& : Int = ???  // error
   object some_???           // error
diff --git a/tests/neg/7722.check b/tests/neg/7722.check
@@ -1,4 +1,4 @@
--- Error: tests/neg/7722.scala:2:35 ------------------------------------------------------------------------------------
-2 |  @scala.annotation.alpha("E") def this() = this(3) // error
-  |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |  @alpha annotation "E" may not be used on a constructor
+-- Error: tests/neg/7722.scala:2:40 ------------------------------------------------------------------------------------
+2 |  @scala.annotation.targetName("E") def this() = this(3) // error
+  |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |  @targetName annotation may not be used on a constructor
diff --git a/tests/neg/7722.scala b/tests/neg/7722.scala
@@ -1,5 +1,5 @@
 class A(i:Int){
-  @scala.annotation.alpha("E") def this() = this(3) // error
+  @scala.annotation.targetName("E") def this() = this(3) // error
 }
 object O{
   def main(args: Array[String]) = {
diff --git a/tests/neg/alpha-early.scala b/tests/neg/alpha-early.scala
@@ -1,14 +1,14 @@
 
-import annotation.alpha
+import annotation.targetName
 
 class Gamma {
 
   def foo2() = {
     def bar = 1
-    @alpha("bar") def baz = 2 // error: @alpha annotation clashes
+    @targetName("bar") def baz = 2 // error: @targetName annotation clashes
 
-    @alpha("bam") def x1 = 0
-    @alpha("bam") def y1 = 0 // error: @alpha annotation clashes
+    @targetName("bam") def x1 = 0
+    @targetName("bam") def y1 = 0 // error: @targetName annotation clashes
 
   }
 }
diff --git a/tests/neg/alpha-late.scala b/tests/neg/alpha-late.scala
@@ -1,5 +1,5 @@
 
-import annotation.alpha
+import annotation.targetName
 
 class Gamma {
 
@@ -8,5 +8,5 @@ class Gamma {
 }
 
 class Delta extends Gamma {      // error: name clash
-  @alpha("foo") def bar: Int = 1
+  @targetName("foo") def bar: Int = 1
 }
diff --git a/tests/neg/alpha-override/C_2.scala b/tests/neg/alpha-override/C_2.scala
@@ -1,4 +1,4 @@
-import annotation.alpha
+import annotation.targetName
 class C extends B_1 {   // error: Name clash between defined and inherited member
-  @alpha("bar") def foo(): Int = 3
+  @targetName("bar") def foo(): Int = 3
 }
diff --git a/tests/neg/alpha-override1/D_2.scala b/tests/neg/alpha-override1/D_2.scala
@@ -1,7 +1,7 @@
-import annotation.alpha
+import annotation.targetName
 class D extends B_1 {
-  @alpha("bar") def foo(): Int = 3
+  @targetName("bar") def foo(): Int = 3
 }
 class E extends B_1 {
-  @alpha("baz") override def bar(): Int = 3 // error: cannot have an @alpha annotation since external names would be different
+  @targetName("baz") override def bar(): Int = 3 // error: cannot have an @targetName annotation since external names would be different
 }
diff --git a/tests/neg/alpha.scala b/tests/neg/alpha.scala
@@ -1,21 +1,21 @@
-import annotation.alpha
+import annotation.targetName
 
 
 abstract class Alpha[T] {
 
   def foo() = 1
 
-  @alpha("bar") def foo(x: T): T
+  @targetName("bar") def foo(x: T): T
 
-  @alpha("append") def ++ (xs: Alpha[T]): Alpha[T] = this
+  @targetName("append") def ++ (xs: Alpha[T]): Alpha[T] = this
 
 }
 
 class Beta extends Alpha[String] {
 
-  @alpha("foo1") override def foo() = 1    // error
+  @targetName("foo1") override def foo() = 1    // error
 
-  @alpha("baz") def foo(x: String): String = x ++ x   // error
+  @targetName("baz") def foo(x: String): String = x ++ x   // error
 
   override def ++ (xs: Alpha[String]): Alpha[String] = this   // error
 
diff --git a/tests/neg/doubleDefinition-late.scala b/tests/neg/doubleDefinition-late.scala
@@ -1,10 +1,10 @@
 
-import annotation.alpha
+import annotation.targetName
 
 class Gamma {
 
   val v = 1
-  @alpha("v") val w = 2   // error: double definition
+  @targetName("v") val w = 2   // error: double definition
 
 }
 // Error when overloading polymorphic and non-polymorphic methods
diff --git a/tests/pos/alpha-override/A_1.scala b/tests/pos/alpha-override/A_1.scala
@@ -1,5 +1,5 @@
 // Scala
-import annotation.alpha
+import annotation.targetName
 class A_1 {
-  @alpha("bar") def foo(): Int = 1
+  @targetName("bar") def foo(): Int = 1
 }
diff --git a/tests/pos/alpha.scala b/tests/pos/alpha.scala
@@ -1,8 +1,8 @@
-import annotation.alpha
+import annotation.targetName
 
 object Test {
 
   def foo() = 1
 
-  @alpha("bar") def foo(x: Int) = 2
+  @targetName("bar") def foo(x: Int) = 2
 }
diff --git a/tests/pos/i8391.scala b/tests/pos/i8391.scala
@@ -1,7 +1,7 @@
-import scala.annotation.alpha
+import scala.annotation.targetName
 
 trait Foo {
-  @alpha("intersection")
+  @targetName("intersection")
   def *(other: Foo): Foo
 }
 
diff --git a/tests/run/alpha-interop/alpha_1.scala b/tests/run/alpha-interop/alpha_1.scala
@@ -1,20 +1,20 @@
 package alpha
-import annotation.alpha
+import annotation.targetName
 
 abstract class Alpha[T] {
 
   def foo() = 1
 
-  @alpha("bar") def foo(x: T): T
+  @targetName("bar") def foo(x: T): T
 
-  @alpha("append") def ++ (xs: Alpha[T]): Alpha[T] = this
+  @targetName("append") def ++ (xs: Alpha[T]): Alpha[T] = this
 
 }
 
-@alpha("Bar") class | extends Alpha[String] {
+@targetName("Bar") class | extends Alpha[String] {
 
-  @alpha("bar") override def foo(x: String) = x ++ x
+  @targetName("bar") override def foo(x: String) = x ++ x
 
-  @alpha("append") override def ++ (xs: Alpha[String]) = this
+  @targetName("append") override def ++ (xs: Alpha[String]) = this
 
 }
diff --git a/tests/run/alpha-modules-1/7721_1.scala b/tests/run/alpha-modules-1/7721_1.scala
@@ -1,5 +1,5 @@
 package alpha
 
-@scala.annotation.alpha("A") object B {
+@scala.annotation.targetName("A") object B {
   def foo = 23
 }
diff --git a/tests/run/alpha-modules-2/7723_1.scala b/tests/run/alpha-modules-2/7723_1.scala
@@ -1,3 +1,3 @@
 package alpha
 
-@scala.annotation.alpha("A") class B(val i: Int = 1)
+@scala.annotation.targetName("A") class B(val i: Int = 1)
diff --git a/tests/run/alpha.scala b/tests/run/alpha.scala
@@ -1,8 +1,8 @@
-import annotation.alpha
+import annotation.targetName
 
 object Test extends App {
   def foo(x: Any): Int = 1
-  @alpha("bar") def foo[A <: AnyRef](x: A) = 2
+  @targetName("bar") def foo[A <: AnyRef](x: A) = 2
 
   assert(foo("a") == 2)
 }
diff --git a/tests/run/i9155.scala b/tests/run/i9155.scala
@@ -1,5 +1,5 @@
 object Foo:
-  @scala.annotation.alpha("w") def \/\/ = "W"
+  @scala.annotation.targetName("w") def \/\/ = "W"
 
 object Bar:
   export Foo._
diff --git a/tests/run/infix.scala b/tests/run/infix.scala
@@ -1,10 +1,10 @@
-import annotation.{infix, alpha}
+import annotation.{infix, targetName}
 object Test extends App {
 
   case class Rational(n: Int, d: Int) {
     @infix def + (that: Rational) =
       Rational(this.n * that.d + that.n * this.d, this.d * that.d)
-    @infix @alpha("multiply") def * (that: Rational) =
+    @infix @targetName("multiply") def * (that: Rational) =
       Rational(this.n * that.n, this.d * that.d)
   }
 
