Implement @Alpha annotation

Author: odersky

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -734,6 +734,8 @@ object Denotations {
         case _ => Signature.NotAMethod
       }
 
+    def erasedName(implicit ctx: Context): Name = symbol.erasedName
+
     def derivedSingleDenotation(symbol: Symbol, info: Type)(implicit ctx: Context): SingleDenotation =
       if ((symbol eq this.symbol) && (info eq this.info)) this
       else newLikeThis(symbol, info)

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -5,11 +5,13 @@ package core
 import Periods._, Contexts._, Symbols._, Denotations._, Names._, NameOps._, Annotations._
 import Types._, Flags._, Decorators._, DenotTransformers._, StdNames._, Scopes._
 import NameOps._, NameKinds._, Phases._
+import Constants.Constant
 import TypeApplications.TypeParamInfo
 import Scopes.Scope
 import dotty.tools.io.AbstractFile
 import Decorators.SymbolIteratorDecorator
 import ast._
+import Trees.Literal
 import annotation.tailrec
 import util.SimpleIdentityMap
 import util.Stats
@@ -442,6 +444,24 @@ object SymDenotations {
     /** `fullName` where `.' is the separator character */
     def fullName(implicit ctx: Context): Name = fullNameSeparated(QualifiedName)
 
+    private var myErasedName: Name = null
+
+    final override def erasedName(implicit ctx: Context): Name = {
+      if (myErasedName == null) {
+        myErasedName = name
+        if (isTerm)
+          getAnnotation(defn.AlphaAnnot) match {
+            case Some(ann) =>
+              ann.arguments match {
+                case Literal(Constant(str: String)) :: Nil => myErasedName = str.toTermName
+                case _ =>
+              }
+            case _ =>
+          }
+      }
+      myErasedName
+    }
+
     // ----- Tests -------------------------------------------------
 
     /** Is this denotation a type? */

compiler/src/dotty/tools/dotc/core/TypeErasure.scala

@@ -537,7 +537,11 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
   private def eraseDerivedValueClassRef(tref: TypeRef)(implicit ctx: Context): Type = {
     val cls = tref.symbol.asClass
     val underlying = underlyingOfValueClass(cls)
-    if (underlying.exists && !isCyclic(cls)) ErasedValueType(tref, valueErasure(underlying))
+    if (underlying.exists && !isCyclic(cls)) {
+      val erasedValue = valueErasure(underlying)
+      assert(erasedValue.exists, i"no erasure for $underlying")
+      ErasedValueType(tref, erasedValue)
+    }
     else NoType
   }
 
@@ -605,7 +609,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       case tp: TypeVar =>
         val inst = tp.instanceOpt
         if (inst.exists) sigName(inst) else tpnme.Uninstantiated
-      case tp @ RefinedType(parent, nme.apply, _) if parent.typeSymbol eq defn.PolyFunctionClass => 
+      case tp @ RefinedType(parent, nme.apply, _) if parent.typeSymbol eq defn.PolyFunctionClass =>
         // we need this case rather than falling through to the default
         // because RefinedTypes <: TypeProxy and it would be caught by
         // the case immediately below

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -2145,6 +2145,7 @@ object messages {
   case class DoubleDefinition(decl: Symbol, previousDecl: Symbol, base: Symbol)(implicit ctx: Context) extends Message(DoubleDefinitionID) {
     val kind: String = "Duplicate Symbol"
     val msg: String = {
+      def nameAnd = if (decl.name != previousDecl.name) " name and" else ""
       val details = if (decl.isRealMethod && previousDecl.isRealMethod) {
         // compare the signatures when both symbols represent methods
         decl.signature.matchDegree(previousDecl.signature) match {
@@ -2153,7 +2154,7 @@ object messages {
           case Signature.ParamMatch =>
             "have matching parameter types."
           case Signature.FullMatch =>
-            "have the same type after erasure."
+            i"have the same$nameAnd type after erasure."
         }
       } else ""
       def symLocation(sym: Symbol) = {

compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala

@@ -8,6 +8,7 @@ import Types._, Contexts._, Flags._, DenotTransformers._
 import Symbols._, StdNames._, Trees._
 import TypeErasure.ErasedValueType, ValueClasses._
 import reporting.diagnostic.messages.DoubleDefinition
+import NameKinds.SuperAccessorName
 
 object ElimErasedValueType {
   val name: String = "elimErasedValueType"
@@ -95,7 +96,12 @@ class ElimErasedValueType extends MiniPhase with InfoTransformer { thisPhase =>
         (sym1.owner.derivesFrom(defn.PolyFunctionClass) ||
          sym2.owner.derivesFrom(defn.PolyFunctionClass))
 
-      if (!info1.matchesLoosely(info2) && !bothPolyApply)
+      if (sym1.name != sym2.name && 
+          !(sym1.name.is(SuperAccessorName) && sym2.name.is(SuperAccessorName))
+            // super-accessors start as private, and their expanded name can clash after
+            // erasure. TODO: Verify that this is OK.
+          ||
+          !info1.matchesLoosely(info2) && !bothPolyApply)
         ctx.error(DoubleDefinition(sym1, sym2, root), root.sourcePos)
     }
     val earlyCtx = ctx.withPhase(ctx.elimRepeatedPhase.next)

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

@@ -69,6 +69,8 @@ class Erasure extends Phase with DenotTransformer {
         else oldSymbol
         val oldOwner = ref.owner
         val newOwner = if (oldOwner eq defn.AnyClass) defn.ObjectClass else oldOwner
+        val oldName = ref.name
+        val newName = ref.erasedName
         val oldInfo = ref.info
         val newInfo = transformInfo(oldSymbol, oldInfo)
         val oldFlags = ref.flags
@@ -77,10 +79,11 @@ class Erasure extends Phase with DenotTransformer {
           else oldFlags &~ Flags.HasDefaultParams // HasDefaultParams needs to be dropped because overriding might become overloading
 
         // TODO: define derivedSymDenotation?
-        if ((oldSymbol eq newSymbol) && (oldOwner eq newOwner) && (oldInfo eq newInfo) && (oldFlags == newFlags)) ref
+        if ((oldSymbol eq newSymbol) && (oldOwner eq newOwner) && (oldName eq newName) && (oldInfo eq newInfo) && (oldFlags == newFlags))
+          ref
         else {
           assert(!ref.is(Flags.PackageClass), s"trans $ref @ ${ctx.phase} oldOwner = $oldOwner, newOwner = $newOwner, oldInfo = $oldInfo, newInfo = $newInfo ${oldOwner eq newOwner} ${oldInfo eq newInfo}")
-          ref.copySymDenotation(symbol = newSymbol, owner = newOwner, initFlags = newFlags, info = newInfo)
+          ref.copySymDenotation(symbol = newSymbol, owner = newOwner, name = newName, initFlags = newFlags, info = newInfo)
         }
       }
     case ref: JointRefDenotation =>

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

@@ -864,7 +864,7 @@ trait Checking {
         def javaFieldMethodPair =
           decl.is(JavaDefined) && other.is(JavaDefined) &&
           decl.is(Method) != other.is(Method)
-        if ((decl.signature.clashes(other.signature) || decl.matches(other)) && !javaFieldMethodPair) {
+        if (decl.matches(other) && !javaFieldMethodPair) {
           def doubleDefError(decl: Symbol, other: Symbol): Unit =
             if (!decl.info.isErroneous && !other.info.isErroneous)
               ctx.error(DoubleDefinition(decl, other, cls), decl.sourcePos)
@@ -1124,6 +1124,21 @@ trait Checking {
       case _ =>
     }
   }
+
+  /** Check that symbol's external name does not clash with symbols defined in the same scope */
+  def checkNoAlphaConflict(stats: List[Tree])(implicit ctx: Context): Unit = {
+    var seen = Set[Name]()
+    for (stat <- stats) {
+      val sym = stat.symbol
+      val ename = sym.erasedName
+      if (ename != sym.name) {
+        val preExisting = ctx.effectiveScope.lookup(ename)
+        if (preExisting.exists || seen.contains(ename))
+          ctx.error(em"@alpha annotation ${'"'}$ename${'"'} clashes with other definition is same scope", stat.sourcePos)
+        seen += ename
+      }
+    }
+  }
 }
 
 trait ReChecking extends Checking {
@@ -1144,7 +1159,7 @@ trait NoChecking extends ReChecking {
   override def checkImplicitConversionUseOK(sym: Symbol, posd: Positioned)(implicit ctx: Context): Unit = ()
   override def checkFeasibleParent(tp: Type, pos: SourcePosition, where: => String = "")(implicit ctx: Context): Type = tp
   override def checkInlineConformant(tree: Tree, isFinal: Boolean, what: => String)(implicit ctx: Context): Unit = ()
-  override def checkNoDoubleDeclaration(cls: Symbol)(implicit ctx: Context): Unit = ()
+  override def checkNoAlphaConflict(stats: List[Tree])(implicit ctx: Context): Unit = ()
   override def checkParentCall(call: Tree, caller: ClassSymbol)(implicit ctx: Context): Unit = ()
   override def checkSimpleKinded(tpt: Tree)(implicit ctx: Context): Tree = tpt
   override def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context): Unit = ()

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -408,6 +408,11 @@ object RefChecks {
       } else if (!compatibleTypes(memberTp(self), otherTp(self)) &&
                  !compatibleTypes(memberTp(upwardsSelf), otherTp(upwardsSelf))) {
         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")
+        else
+          overrideError("cannot have an @alpha annotation since external names would be different")
       } else {
         checkOverrideDeprecated()
       }

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

@@ -2312,7 +2312,9 @@ class Typer extends Namer
       case _ =>
         stat
     }
-    traverse(stats)(localCtx).mapConserve(finalize)
+    val stats1 = traverse(stats)(localCtx).mapConserve(finalize)
+    if (ctx.owner == exprOwner) checkNoAlphaConflict(stats1)
+    stats1
   }
 
   /** Given an inline method `mdef`, the method rewritten so that its body

tests/neg/alpha-early.scala

@@ -0,0 +1,14 @@
+
+import annotation.alpha
+
+class Gamma {
+
+  def foo2() = {
+    def bar = 1
+    @alpha("bar") def baz = 2 // error: @alpha annotation clashes
+
+    @alpha("bam") def x1 = 0
+    @alpha("bam") def y1 = 0 // error: @alpha annotation clashes
+
+  }
+}

tests/neg/alpha-late.scala

@@ -0,0 +1,12 @@
+
+import annotation.alpha
+
+class Gamma {
+
+  def foo: Int = 1
+
+}
+
+class Delta extends Gamma {      // error: name clash
+  @alpha("foo") def bar: Int = 1
+}

tests/neg/alpha.scala

@@ -0,0 +1,22 @@
+import annotation.alpha
+
+
+abstract class Alpha[T] {
+
+  def foo() = 1
+
+  @alpha("bar") def foo(x: T): T
+
+  @alpha("append") def ++ (xs: Alpha[T]): Alpha[T] = this
+
+}
+
+class Beta extends Alpha[String] {
+
+  @alpha("foo1") override def foo() = 1    // error
+
+  @alpha("baz") def foo(x: String): String = x ++ x   // error
+
+  override def ++ (xs: Alpha[String]): Alpha[String] = this   // error
+
+}

tests/neg/doubleDefinition-late.scala

@@ -0,0 +1,20 @@
+
+import annotation.alpha
+
+class Gamma {
+
+  val v = 1
+  @alpha("v") val w = 2   // error: double definition
+
+}
+// Error when overloading polymorphic and non-polymorphic methods
+class Test19 {
+  def foo[T <: Int](x: T): T = x
+  def foo(x: Int): Int = x // error
+}
+
+// Error when overloading polymorphic methods
+class Test20 {
+  def foo[T <: Int](x: T): T = x
+  def foo[S <: Int, T <: Int](x: S): T = ??? // error
+}

tests/neg/doubleDefinition.check

@@ -122,17 +122,3 @@
     |	    Double definition:
     |	    var foo: Int in class Test16 at line 115 and
     |	    def foo: => Int in class Test16 at line 116
--- [E120] Duplicate Symbol Error: tests/neg/doubleDefinition.scala:138:6 -----------------------------------------------
-138 |  def foo(x: Int): Int = x // error
-    |      ^
-    |      Double definition:
-    |      def foo: [T <: Int](x: T): T in class Test19 at line 137 and
-    |      def foo(x: Int): Int in class Test19 at line 138
-    |      have the same type after erasure.
--- [E120] Duplicate Symbol Error: tests/neg/doubleDefinition.scala:144:6 -----------------------------------------------
-144 |  def foo[S <: Int, T <: Int](x: S): T = ??? // error
-    |      ^
-    |      Double definition:
-    |      def foo: [T <: Int](x: T): T in class Test20 at line 143 and
-    |      def foo: [S <: Int, T <: Int](x: S): T in class Test20 at line 144
-    |      have the same type after erasure.

tests/neg/doubleDefinition.scala

@@ -82,7 +82,7 @@ class Test8d {
 	def foo = 2 // error
 }
 
-// test method and contructor argument clashing
+// test method and constructor argument clashing
 
 class Test9(val foo: Int) {
 	def foo: String // error
@@ -132,14 +132,3 @@ class Test18 {
 	def foo(b: B) = 1
 }
 
-// Error when overloading polymorphic and non-polymorphic methods
-class Test19 {
-  def foo[T <: Int](x: T): T = x
-  def foo(x: Int): Int = x // error
-}
-
-// Error when overloading polymorphic methods
-class Test20 {
-  def foo[T <: Int](x: T): T = x
-  def foo[S <: Int, T <: Int](x: S): T = ??? // error
-}

tests/pos/alpha.scala

@@ -0,0 +1,9 @@
+import annotation.alpha
+
+object Test {
+
+  def foo() = 1
+
+  @alpha("bar") def foo(x: Int) = 2
+
+}

tests/run/alpha/Test_2.java

@@ -0,0 +1,12 @@
+
+package alpha;
+
+public class Test_2 {
+
+  public static void main(String[] args) {
+    Alpha<String> a = new Beta();
+    assert a.foo() == 1;
+    assert a.bar("a").equals("aa");
+    Alpha<String> aa = a.append(a);
+  }
+}

tests/run/alpha/Test_3.scala

@@ -0,0 +1,5 @@
+
+object Test {
+  def main(args: Array[String]): Unit =
+    alpha.Test_2.main(args)
+}

tests/run/alpha/alpha_1.scala

@@ -0,0 +1,20 @@
+package alpha
+import annotation.alpha
+
+abstract class Alpha[T] {
+
+  def foo() = 1
+
+  @alpha("bar") def foo(x: T): T
+
+  @alpha("append") def ++ (xs: Alpha[T]): Alpha[T] = this
+
+}
+
+class Beta extends Alpha[String] {
+
+  @alpha("bar") override def foo(x: String) = x ++ x
+
+  @alpha("append") override def ++ (xs: Alpha[String]) = this
+
+}