Support <: T syntax for inlined methods.

 - add new syntax
 - an inline method with an explicit `: T` result type section has its
   rhs upcasted to its return type. It was an oversight that this was not
   done before.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -157,19 +157,31 @@ object desugar {
        ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | Implicit)
     }
 
-  /** Expand context bounds to evidence params. E.g.,
+  /** 1. Expand context bounds to evidence params. E.g.,
    *
    *      def f[T >: L <: H : B](params)
    *  ==>
    *      def f[T >: L <: H](params)(implicit evidence$0: B[T])
    *
-   *  Expand default arguments to default getters. E.g,
+   *  2. Expand default arguments to default getters. E.g,
    *
    *      def f[T: B](x: Int = 1)(y: String = x + "m") = ...
    *  ==>
    *      def f[T](x: Int)(y: String)(implicit evidence$0: B[T]) = ...
    *      def f$default$1[T] = 1
    *      def f$default$2[T](x: Int) = x + "m"
+   *
+   *  3. Convert <: T to : T in specializing inline methods. E.g.
+   *
+   *      inline def f(x: Boolean) <: Any = if (x) 1 else ""
+   *  ==>
+   *      inline def f(x: Boolean): Any = if (x) 1 else ""
+   *
+   *  4. Upcast non-specializing inline methods. E.g.
+   *
+   *      inline def f(x: Boolean): Any = if (x) 1 else ""
+   *  ==>
+   *      inline def f(x: Boolean): Any = (if (x) 1 else ""): Any
    */
   private def defDef(meth: DefDef, isPrimaryConstructor: Boolean = false)(implicit ctx: Context): Tree = {
     val DefDef(name, tparams, vparamss, tpt, rhs) = meth
@@ -188,7 +200,16 @@ object desugar {
       cpy.TypeDef(tparam)(rhs = desugarContextBounds(tparam.rhs))
     }
 
-    val meth1 = addEvidenceParams(cpy.DefDef(meth)(tparams = tparams1), epbuf.toList)
+    var meth1 = addEvidenceParams(cpy.DefDef(meth)(tparams = tparams1), epbuf.toList)
+
+    if (meth1.mods.is(Inline))
+      meth1.tpt match {
+        case TypeBoundsTree(_, tpt1) =>
+          meth1 = cpy.DefDef(meth1)(tpt = tpt1)
+        case tpt if !tpt.isEmpty && !meth1.rhs.isEmpty =>
+          meth1 = cpy.DefDef(meth1)(rhs = Typed(meth1.rhs, tpt))
+        case _ =>
+      }
 
     /** The longest prefix of parameter lists in vparamss whose total length does not exceed `n` */
     def takeUpTo(vparamss: List[List[ValDef]], n: Int): List[List[ValDef]] = vparamss match {

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2166,7 +2166,7 @@ object Parsers {
       }
     }
 
-    /** DefDef ::= DefSig (`:' Type [`=' Expr] | "=" Expr)
+    /** DefDef ::= DefSig [(‘:’ | ‘<:’) Type] ‘=’ Expr
      *           | this ParamClause ParamClauses `=' ConstrExpr
      *  DefDcl ::= DefSig `:' Type
      *  DefSig ::= id [DefTypeParamClause] ParamClauses
@@ -2195,7 +2195,13 @@ object Parsers {
         val name = ident()
         val tparams = typeParamClauseOpt(ParamOwner.Def)
         val vparamss = paramClauses(name)
-        var tpt = fromWithinReturnType(typedOpt())
+        var tpt = fromWithinReturnType {
+          if (in.token == SUBTYPE && mods.is(Inline)) {
+            in.nextToken()
+            TypeBoundsTree(EmptyTree, toplevelTyp())
+          }
+          else typedOpt()
+        }
         if (in.isScala2Mode) newLineOptWhenFollowedBy(LBRACE)
         val rhs =
           if (in.token == EQUALS) {

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

@@ -628,6 +628,7 @@ class Staging extends MacroTransformWithImplicits {
         case Select(qual, _) if tree.symbol.isSplice && Splicer.canBeSpliced(qual) => Some(qual)
         case Block(List(stat), Literal(Constant(()))) => unapply(stat)
         case Block(Nil, expr) => unapply(expr)
+        case Typed(expr, _) => unapply(expr)
         case _ => None
       }
     }

docs/docs/internals/syntax.md

@@ -329,7 +329,7 @@ Def               ::=  ‘val’ PatDef
 PatDef            ::=  Pattern2 {‘,’ Pattern2} [‘:’ Type] ‘=’ Expr              PatDef(_, pats, tpe?, expr)
 VarDef            ::=  PatDef
                     |  ids ‘:’ Type ‘=’ ‘_’
-DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr                               DefDef(_, name, tparams, vparamss, tpe, expr)
+DefDef            ::=  DefSig [(‘:’ | ‘<:’) Type] ‘=’ Expr                               DefDef(_, name, tparams, vparamss, tpe, expr)
                     |  DefSig [nl] ‘{’ Block ‘}’                                DefDef(_, name, tparams, vparamss, tpe, Block)
                     |  ‘this’ DefParamClause DefParamClauses                    DefDef(_, <init>, Nil, vparamss, EmptyTree, expr | Block)
                        (‘=’ ConstrExpr | [nl] ConstrBlock)

tests/neg/specializing-inline.scala

@@ -0,0 +1,14 @@
+object Test {
+
+  inline def h(x: Boolean) = if (x) 1 else ""
+  val z = h(true)
+  val zc: Int = z
+
+  inline def g <: Any = 1
+  val y = g
+  val yc: Int = y // OK
+
+  inline def f: Any = 1
+  val x = f
+  val xc: Int = x // error
+}