Enforce restrictions on typelevel methods

odersky · odersky · commit a019a4e4532a · 2018-07-26T10:20:55.000+02:00
Typelevel methods are transparent methods with toplevel matches. We now
track this property with a flag. To be done: merge with the Macro flag.

Typelevel methods

 - cannot be eta-expanded
 - cannot override anything

Also, fixes the "missing args" error message, which previously claimed that `()`
was missing even for nonempty argument lists.
diff --git a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -433,7 +433,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   val Flag_METHOD: Flags = Flags.Method.bits
   val ExcludedForwarderFlags: Flags = {
       Flags.Specialized | Flags.Lifted | Flags.Protected | Flags.JavaStatic |
-      Flags.Bridge | Flags.VBridge | Flags.Private | Flags.Macro
+      Flags.Bridge | Flags.Private | Flags.TypeLevel | Flags.Macro
   }.bits
 
   def isQualifierSafeToElide(qual: Tree): Boolean = tpd.isIdempotentExpr(qual)
diff --git a/compiler/src/dotty/tools/dotc/core/Flags.scala b/compiler/src/dotty/tools/dotc/core/Flags.scala
@@ -351,8 +351,8 @@ object Flags {
   /** A bridge method. Set by Erasure */
   final val Bridge = termFlag(34, "<bridge>")
 
-  /** Symbol is a Java varargs bridge */ // (needed?)
-  final val VBridge = termFlag(35, "<vbridge>") // TODO remove
+  /** Symbol is a typelevel method, cannot be used in normal code */
+  final val TypeLevel = termFlag(35, "<type-level>")
 
   /** Symbol is a method which should be marked ACC_SYNCHRONIZED */
   final val Synchronized = termFlag(36, "<synchronized>")
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -600,7 +600,7 @@ object SymDenotations {
 
     /** Is this a denotation of a stable term (or an arbitrary type)? */
     final def isStable(implicit ctx: Context) =
-      isType || is(Stable) || !(is(UnstableValue) || info.isInstanceOf[ExprType])
+      isType || is(Stable) || !is(UnstableValue) && !info.isInstanceOf[ExprType]
 
     /** Is this a denotation of a class that does not have - either direct or inherited -
      *  initaliazion code?
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
@@ -182,6 +182,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   LAZY
                   OVERRIDE
                   TRANSPARENT
+                  TYPELEVEL                           // transparent method containing toplevel matches (TODO: merge with MACRO)
                   MACRO                               // transparent method containing toplevel splices
                   STATIC                              // mapped to static Java member
                   OBJECT                              // an object or its class
@@ -295,8 +296,8 @@ object TastyFormat {
   final val IMPLICIT = 13
   final val LAZY = 14
   final val OVERRIDE = 15
-
-  final val TRANSPARENT = 17
+  final val TRANSPARENT = 16
+  final val TYPELEVEL = 17
   final val STATIC = 18
   final val OBJECT = 19
   final val TRAIT = 20
@@ -473,6 +474,7 @@ object TastyFormat {
        | LAZY
        | OVERRIDE
        | TRANSPARENT
+       | TYPELEVEL
        | MACRO
        | STATIC
        | OBJECT
@@ -529,6 +531,7 @@ object TastyFormat {
     case LAZY => "LAZY"
     case OVERRIDE => "OVERRIDE"
     case TRANSPARENT => "TRANSPARENT"
+    case TYPELEVEL => "TYPELEVEL"
     case MACRO => "MACRO"
     case STATIC => "STATIC"
     case OBJECT => "OBJECT"
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -601,6 +601,7 @@ class TreePickler(pickler: TastyPickler) {
     if (flags is Case) writeByte(CASE)
     if (flags is Override) writeByte(OVERRIDE)
     if (flags is Transparent) writeByte(TRANSPARENT)
+    if (flags is TypeLevel) writeByte(TYPELEVEL)
     if (flags is Macro) writeByte(MACRO)
     if (flags is JavaStatic) writeByte(STATIC)
     if (flags is Module) writeByte(OBJECT)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -585,6 +585,7 @@ class TreeUnpickler(reader: TastyReader,
           case LAZY => addFlag(Lazy)
           case OVERRIDE => addFlag(Override)
           case TRANSPARENT => addFlag(Transparent)
+          case TYPELEVEL => addFlag(TypeLevel)
           case MACRO => addFlag(Macro)
           case STATIC => addFlag(JavaStatic)
           case OBJECT => addFlag(Module)
diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/PickleBuffer.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/PickleBuffer.scala
@@ -232,7 +232,7 @@ object PickleBuffer {
       EXPANDEDNAME -> Scala2ExpandedName,
       IMPLCLASS -> (Scala2PreSuper, ImplClass),
       SPECIALIZED -> Specialized,
-      VBRIDGE -> VBridge,
+      VBRIDGE -> EmptyFlags,
       VARARGS -> JavaVarargs,
       ENUM -> Enum)
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Inliner.scala b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
@@ -19,6 +19,7 @@ import NameKinds.{ClassifiedNameKind, InlineAccessorName, UniqueInlineName, Tran
 import ProtoTypes.selectionProto
 import SymDenotations.SymDenotation
 import Annotations._
+import PrepareTransparent.foreachTopLevelMatch
 import transform.{ExplicitOuter, AccessProxies}
 import Inferencing.fullyDefinedType
 import config.Printers.inlining
@@ -641,14 +642,8 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     import reducer._
 
     /** Mark all toplevel matches with the `TopLevelMatch` attachment */
-    def prepare(tree: untpd.Tree): Unit = tree match {
-      case tree: untpd.Match =>
-        tree.pushAttachment(TopLevelMatch, ())
-        tree.cases.foreach(prepare)
-      case tree: untpd.Block =>
-        prepare(tree.expr)
-      case _ =>
-    }
+    def prepare(tree: untpd.Tree): Unit =
+      foreachTopLevelMatch(tree, _.pushAttachment(TopLevelMatch, ()))
 
     override def ensureAccessible(tpe: Type, superAccess: Boolean, pos: Position)(implicit ctx: Context): Type = {
       tpe match {
diff --git a/compiler/src/dotty/tools/dotc/typer/PrepareTransparent.scala b/compiler/src/dotty/tools/dotc/typer/PrepareTransparent.scala
@@ -43,6 +43,18 @@ object PrepareTransparent {
     if (!defn.ScalaPredefModule.moduleClass.derivesFrom(tree.symbol.maybeOwner))
       methPart(tree).putAttachment(ContextualImplicit, ())
 
+  def foreachTopLevelMatch(tree: untpd.Tree, op: untpd.Tree => Unit) = {
+    def recur(tree: untpd.Tree): Unit = tree match {
+      case tree: untpd.Match =>
+        op(tree)
+        tree.cases.foreach(recur)
+      case tree: untpd.Block =>
+        recur(tree.expr)
+      case _ =>
+    }
+    recur(tree)
+  }
+
   class InlineAccessors extends AccessProxies {
 
     /** If an inline accessor name wraps a unique inline name, this is taken as indication
@@ -241,6 +253,7 @@ object PrepareTransparent {
             val typedBody =
               if (ctx.reporter.hasErrors) rawBody
               else ctx.compilationUnit.inlineAccessors.makeInlineable(rawBody)
+            foreachTopLevelMatch(originalBody, _ => inlined.setFlag(TypeLevel))
             val inlineableBody = addReferences(inlined, originalBody, typedBody)
             inlining.println(i"Body to inline for $inlined: $inlineableBody")
             inlineableBody
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -143,7 +143,7 @@ object RefChecks {
    *    1.8.1  M's type is a subtype of O's type, or
    *    1.8.2  M is of type []S, O is of type ()T and S <: T, or
    *    1.8.3  M is of type ()S, O is of type []T and S <: T, or
-   *    1.9    M must not be a Dotty macro def
+   *    1.9    M must not be a typelevel def or a Dotty macro def
    *    1.10.  If M is a 2.x macro def, O cannot be deferred unless there's a concrete method overriding O.
    *    1.11.  If M is not a macro def, O cannot be a macro def.
    *  2. Check that only abstract classes have deferred members
@@ -376,6 +376,8 @@ object RefChecks {
         overrideError("may not override a non-lazy value")
       } else if (other.is(Lazy) && !other.isRealMethod && !member.is(Lazy)) {
         overrideError("must be declared lazy to override a lazy value")
+      } else if (member.is(TypeLevel)) { // (1.9)
+        overrideError("is a type-level method, may not override anything")
       } else if (member.is(Macro, butNot = Scala2x)) { // (1.9)
         overrideError("is a macro, may not override anything")
       } else if (other.is(Deferred) && member.is(Scala2Macro) && member.extendedOverriddenSymbols.forall(_.is(Deferred))) { // (1.10)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2128,7 +2128,9 @@ class Typer extends Namer
     def readaptSimplified(tree: Tree)(implicit ctx: Context) = readapt(simplify(tree, pt, locked))
 
     def missingArgs(mt: MethodType) = {
-      ctx.error(MissingEmptyArgumentList(methPart(tree).symbol), tree.pos)
+      val meth = methPart(tree).symbol
+      if (mt.paramNames.length == 0) ctx.error(MissingEmptyArgumentList(meth), tree.pos)
+      else ctx.error(em"missing arguments for $meth", tree.pos)
       tree.withType(mt.resultType)
     }
 
@@ -2338,10 +2340,12 @@ class Typer extends Namer
 
       // Reasons NOT to eta expand:
       //  - we reference a constructor
+      //  - we reference a typelevel method
       //  - we are in a pattern
       //  - the current tree is a synthetic apply which is not expandable (eta-expasion would simply undo that)
       if (arity >= 0 &&
           !tree.symbol.isConstructor &&
+          !tree.symbol.is(TypeLevel) &&
           !ctx.mode.is(Mode.Pattern) &&
           !(isSyntheticApply(tree) && !isExpandableApply))
         simplify(typed(etaExpand(tree, wtp, arity), pt), pt, locked)
diff --git a/tests/neg/typelevel-noeta.scala b/tests/neg/typelevel-noeta.scala
@@ -0,0 +1,22 @@
+
+object Test {
+  def anyValue[T]: T = ???
+
+  transparent def test(x: Int) = x match {
+    case _: Byte =>
+    case _: Char =>
+  }
+
+  transparent def test2() = 1 match {
+    case _: Byte =>
+    case _: Char =>
+  }
+
+  val x: Any = test // error
+
+  test // error
+
+  val x2: Any = test2 // error
+
+  test2 // error
+}
diff --git a/tests/neg/typelevel-nomatch.scala b/tests/neg/typelevel-nomatch.scala
@@ -8,4 +8,6 @@ object Test {
   }
 
   test[String]
+
+  test
 }
diff --git a/tests/neg/typelevel.scala b/tests/neg/typelevel.scala
@@ -55,13 +55,4 @@ object Test {
   class Deco2(val as: HList) extends java.lang.Cloneable with java.lang.Comparable[Deco2] {
     transparent def ++ (bs: HList) = concat(as, bs)
   }
-
-  def anyValue[T]: T = ???
-
-  transparent def test[T] = anyValue[T] match {
-    case _: Byte =>
-    case _: Char =>
-  }
-
-  test[String]
 }
