New syntax for alias instances

Replaces "instance as a modifier scheme". Advantage: Simpler, fewer
possible feture interactions. Disadvantage: Less straightforward to
convert existsing implicits to new scheme.

Author: odersky

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

@@ -197,7 +197,8 @@ object desugar {
    *      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
+    val DefDef(_, tparams, vparamss, tpt, rhs) = meth
+    val methName = normalizeName(meth, tpt).asTermName
     val mods = meth.mods
     val epbuf = new ListBuffer[ValDef]
     def desugarContextBounds(rhs: Tree): Tree = rhs match {
@@ -213,7 +214,8 @@ object desugar {
       cpy.TypeDef(tparam)(rhs = desugarContextBounds(tparam.rhs))
     }
 
-    var meth1 = addEvidenceParams(cpy.DefDef(meth)(tparams = tparams1), epbuf.toList)
+    var meth1 = addEvidenceParams(
+      cpy.DefDef(meth)(name = methName, tparams = tparams1), epbuf.toList)
 
     if (meth1.mods.is(Inline))
       meth1.tpt match {
@@ -245,7 +247,7 @@ object desugar {
       case (vparam :: vparams) :: vparamss1 =>
         def defaultGetter: DefDef =
           DefDef(
-            name = DefaultGetterName(meth.name, n),
+            name = DefaultGetterName(methName, n),
             tparams = meth.tparams.map(tparam => dropContextBound(toDefParam(tparam))),
             vparamss = takeUpTo(normalizedVparamss.nestedMap(toDefParam), n),
             tpt = TypeTree(),
@@ -303,7 +305,7 @@ object desugar {
   /** The expansion of a class definition. See inline comments for what is involved */
   def classDef(cdef: TypeDef)(implicit ctx: Context): Tree = {
     val impl @ Template(constr0, _, self, _) = cdef.rhs
-    val className = normalizeClassName(cdef, impl)
+    val className = normalizeName(cdef, impl).asTypeName
     val parents = impl.parents
     val mods = cdef.mods
     val companionMods = mods
@@ -731,7 +733,7 @@ object desugar {
   def moduleDef(mdef: ModuleDef)(implicit ctx: Context): Tree = {
     val impl = mdef.impl
     val mods = mdef.mods
-    val moduleName = normalizeClassName(mdef, impl).toTermName
+    val moduleName = normalizeName(mdef, impl).asTermName
     def isEnumCase = mods.isEnumCase
 
     def flagSourcePos(flag: FlagSet) = mods.mods.find(_.flags == flag).fold(mdef.sourcePos)(_.sourcePos)
@@ -814,10 +816,10 @@ object desugar {
    *      If it does redefine, issue an error and return a mangled name instead of the original one.
    *   2. If the name is missing (this can be the case for instance definitions), invent one instead.
    */
-  def normalizeClassName(mdef: MemberDef, impl: Template)(implicit ctx: Context): TypeName = {
-    var name = mdef.name.toTypeName
-    if (name.isEmpty) name = s"${inventName(impl)}_instance".toTypeName
-    if (ctx.owner == defn.ScalaPackageClass && defn.reservedScalaClassNames.contains(name)) {
+  def normalizeName(mdef: MemberDef, impl: Tree)(implicit ctx: Context): Name = {
+    var name = mdef.name
+    if (name.isEmpty) name = name.likeSpaced(s"${inventName(impl)}_instance".toTermName)
+    if (ctx.owner == defn.ScalaPackageClass && defn.reservedScalaClassNames.contains(name.toTypeName)) {
       def kind = if (name.isTypeName) "class" else "object"
       ctx.error(em"illegal redefinition of standard $kind $name", mdef.sourcePos)
       name = name.errorName
@@ -827,20 +829,24 @@ object desugar {
 
   /** Invent a name for an anonymous instance with template `impl`.
    */
-  private def inventName(impl: Template)(implicit ctx: Context): String =
-    if (impl.parents.isEmpty)
-      impl.body.find {
-        case dd: DefDef if dd.mods.is(Extension) => true
-        case _ => false
-      } match {
-        case Some(DefDef(name, _, (vparam :: _) :: _, _, _)) =>
-          s"${name}_of_${inventTypeName(vparam.tpt)}"
-        case _ =>
-          ctx.error(i"anonymous instance must have `for` part or must define at least one extension method", impl.sourcePos)
-          nme.ERROR.toString
-      }
-    else
-      impl.parents.map(inventTypeName(_)).mkString("_")
+  private def inventName(impl: Tree)(implicit ctx: Context): String = impl match {
+    case impl: Template =>
+      if (impl.parents.isEmpty)
+        impl.body.find {
+          case dd: DefDef if dd.mods.is(Extension) => true
+          case _ => false
+        } match {
+          case Some(DefDef(name, _, (vparam :: _) :: _, _, _)) =>
+            s"${name}_of_${inventTypeName(vparam.tpt)}"
+          case _ =>
+            ctx.error(i"anonymous instance must have `for` part or must define at least one extension method", impl.sourcePos)
+            nme.ERROR.toString
+        }
+      else
+        impl.parents.map(inventTypeName(_)).mkString("_")
+    case impl: Tree =>
+      inventTypeName(impl)
+  }
 
   private class NameExtractor(followArgs: Boolean) extends UntypedTreeAccumulator[String] {
     private def extractArgs(args: List[Tree])(implicit ctx: Context): String =

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

@@ -2305,9 +2305,8 @@ object Parsers {
       }
     }
 
-    /** DefDef         ::= MethodDef | ConstructorDef
-     *  MethodDef      ::= DefSig [(‘:’ | ‘<:’) Type] ‘=’ Expr
-     *  ConstructorDef ::= this ParamClause ParamClauses `=' ConstrExpr
+    /** DefDef ::= DefSig [(‘:’ | ‘<:’) Type] ‘=’ Expr
+     *           | this ParamClause ParamClauses `=' ConstrExpr
      *  DefDcl ::= DefSig `:' Type
      *  DefSig ::= ‘(’ DefParam ‘)’ [nl] id [DefTypeParamClause] ParamClauses
      */
@@ -2321,8 +2320,7 @@ object Parsers {
           true
         }
       }
-      val isInstance = mods.hasMod(Predef.classOf[Mod.Instance])
-      if (!isInstance && in.token == THIS) {
+      if (in.token == THIS) {
         in.nextToken()
         val vparamss = paramClauses()
         if (vparamss.isEmpty || vparamss.head.take(1).exists(_.mods.is(Implicit)))
@@ -2346,7 +2344,7 @@ object Parsers {
         val mods1 = addFlag(mods, flags)
         val name = ident()
         val tparams = typeParamClauseOpt(ParamOwner.Def)
-        val vparamss = paramClauses(ofInstance = isInstance) match {
+        val vparamss = paramClauses() match {
           case rparams :: rparamss if leadingParamss.nonEmpty && !isLeftAssoc(name) =>
             rparams :: leadingParamss ::: rparamss
           case rparamss =>
@@ -2555,38 +2553,36 @@ object Parsers {
       Template(constr, parents, Nil, EmptyValDef, Nil)
     }
 
-    /** InstanceDef    ::=  [id] InstanceParams [‘of’ ConstrApp {‘,’ ConstrApp}] [TemplateBody]
-     *                   |  ‘val’ PatDef
-     *                   |  ‘def’ MethodDef
+    /** InstanceDef    ::=  [id] InstanceParams InstanceBody
      *  InstanceParams ::=  [DefTypeParamClause] {InstParamClause}
+     *  InstanceBody   ::=  [‘of’ ConstrApp {‘,’ ConstrApp }] [TemplateBody]
+     *                   |  ‘of’ Type ‘=’ Expr
      */
-    def instanceDef(start: Offset, mods: Modifiers, instanceMod: Mod) = {
-      val mods1 = addMod(mods, instanceMod)
-      if (in.token == VAL) {
-        in.nextToken()
-        patDefOrDcl(start, mods1)
-      }
-      else if (in.token == DEF) {
-        in.nextToken()
-        defDefOrDcl(start, mods1)
-      }
-      else atSpan(start, nameStart) {
-        val name = if (isIdent && !isIdent(nme.of)) ident() else EmptyTermName
-        val tparams = typeParamClauseOpt(ParamOwner.Class)
-        val vparamss = paramClauses(ofClass = true, ofInstance = true)
-        val parents =
-          if (isIdent(nme.of)) {
-            in.nextToken()
-            tokenSeparated(COMMA, constrApp)
-          }
-          else Nil
-        newLineOptWhenFollowedBy(LBRACE)
-        val templ = templateBodyOpt(makeConstructor(tparams, vparamss), parents, Nil, isEnum = false)
-        val instDef =
+    def instanceDef(start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
+      val name = if (isIdent && !isIdent(nme.of)) ident() else EmptyTermName
+      val tparams = typeParamClauseOpt(ParamOwner.Def)
+      val vparamss = paramClauses(ofInstance = true)
+      val parents =
+        if (isIdent(nme.of)) {
+          in.nextToken()
+          tokenSeparated(COMMA, constrApp)
+        }
+        else Nil
+      val instDef =
+        if (in.token == EQUALS && parents.length == 1 && parents.head.isType) {
+          in.nextToken()
+          DefDef(name, tparams, vparamss, parents.head, expr())
+        }
+        else {
+          newLineOptWhenFollowedBy(LBRACE)
+          val tparams1 = tparams.map(tparam => tparam.withMods(tparam.mods | PrivateLocal))
+          val vparamss1 = vparamss.map(_.map(vparam =>
+            vparam.withMods(vparam.mods &~ Param | ParamAccessor | PrivateLocal)))
+          val templ = templateBodyOpt(makeConstructor(tparams1, vparamss1), parents, Nil, isEnum = false)
           if (tparams.isEmpty && vparamss.isEmpty) ModuleDef(name, templ)
           else TypeDef(name.toTypeName, templ)
-        finalizeDef(instDef, mods1, start)
-      }
+        }
+      finalizeDef(instDef, addMod(mods, instanceMod), start)
     }
 
 /* -------- TEMPLATES ------------------------------------------- */

docs/docs/internals/syntax.md

@@ -358,10 +358,9 @@ Def               ::=  ‘val’ PatDef
 PatDef            ::=  Pattern2 {‘,’ Pattern2} [‘:’ Type] ‘=’ Expr              PatDef(_, pats, tpe?, expr)
 VarDef            ::=  PatDef
                     |  ids ‘:’ Type ‘=’ ‘_’
-DefDef            ::=  MethodDef | ConstructorDef
-MethodDef         ::=  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)
-ConstructorDef    ::= ‘this’ DefParamClause DefParamClauses                    DefDef(_, <init>, Nil, vparamss, EmptyTree, expr | Block)
+                    |  ‘this’ DefParamClause DefParamClauses                    DefDef(_, <init>, Nil, vparamss, EmptyTree, expr | Block)
                        (‘=’ ConstrExpr | [nl] ConstrBlock)
 
 TmplDef           ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
@@ -373,11 +372,10 @@ ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses
 ConstrMods        ::=  {Annotation} [AccessModifier]
 ObjectDef         ::=  id [Template]                                            ModuleDef(mods, name, template)  // no constructor
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody                   EnumDef(mods, name, tparams, template)
-InstanceDef       ::=  [id] InstanceParams [‘of’ ConstrApp {‘,’ ConstrApp}]
-                       [TemplateBody]
-                    |  ‘val’ PatDef
-                    |  ‘def’ MethodDef
+InstanceDef       ::=  [id] InstanceParams InstanceBody
 InstanceParams    ::=  [DefTypeParamClause] {InstParamClause}
+InstanceBody      ::=  [‘of’ ConstrApp {‘,’ ConstrApp }] [TemplateBody]
+                    |  ‘of’ Type ‘=’ Expr
 Template          ::=  InheritClauses [TemplateBody]                            Template(constr, parents, self, stats)
 InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
 ConstrApps        ::=  ConstrApp {‘with’ ConstrApp}

docs/docs/reference/instances/context-params.md

@@ -68,6 +68,14 @@ f("abc") with ctx
 Context parameters may be given either as a normal parameter list `(...)`
 or as a sequence of types. To distinguish the two, a leading `(` always indicates a parameter list.
 
+## Summoning an Instance
+
+A method `summon` in `Predef` creates an implicit instance value for a given type, analogously to what `implicitly[T]` did. The only difference between the two is that
+`summon` takes a context parameter, where `implicitly` took an old-style implicit parameter:
+```scala
+def summon[T] with (x: T) = x
+```
+
 ## Syntax
 
 Here is the new syntax of parameters and arguments seen as a delta from the [standard context free syntax of Scala 3](http://dotty.epfl.ch/docs/internals/syntax.html).

docs/docs/reference/instances/instance-defs.md

@@ -161,16 +161,35 @@ instance ReaderMonad[Ctx] of Monad[[X] => Ctx => X] {
     ctx => x
 }
 ```
+## Alias Instances
+
+An alias instance creates an instance that is equal to some expression. E.g.,
+```
+instance ctx of ExecutionContext = currentThreadPool().context
+```
+Here, we create an instance `ctx` of type `ExecutionContext` that resolves to the
+right hand side `currentThreadPool().context`. Each time an instance of `ExecutionContext`
+is demanded, the result of evaluating the right-hand side expression is returned. The instance definition is equivalent to the following implicit definition:
+```
+final implicit def ctx: ExecutionContext = currentThreadPool().context
+```
+Alias instances may be anonymous, e.g.
+```
+instance of Position = enclosingTree.position
+```
+An alias instance can have type and context parameters just like any other instance definition, but it can only implement a single type.
 
 ## Syntax
 
 Here is the new syntax of instance definitions, seen as a delta from the [standard context free syntax of Scala 3](http://dotty.epfl.ch/docs/internals/syntax.html).
 ```
 TmplDef          ::=  ...
                   |  ‘instance’ InstanceDef
-InstanceDef      ::=  [id] InstanceParams [‘of’ ConstrApp {‘,’ ConstrApp}] [TemplateBody]
+InstanceDef      ::=  [id] InstanceParams InstanceBody
 InstanceParams   ::=  [DefTypeParamClause] {InstParamClause}
 InstParamClause  ::=  ‘with’ (‘(’ [DefParams] ‘)’ | ContextTypes)
+InstanceBody     ::=  [‘of’ ConstrApp {‘,’ ConstrApp }] [TemplateBody]
+                   |  ‘of’ Type ‘=’ Expr
 ContextTypes     ::=  RefinedType {‘,’ RefinedType}
 ```
-The identifier `id` can be omitted only if either the `of` part or the template body is present. If the `of` part is missing, the template body must define at least one extension method.
+The identifier `id` can be omitted only if either the `of` part or the template body is present. If the `of` part is missing, the template body must define at least one extension method.

docs/docs/reference/instances/replacing-implicits.md

@@ -9,25 +9,26 @@ These idioms can by-and-large be mapped to existing implicits. The only exceptio
 
 The contents of this page are more tentative than the ones of the previous pages. The concepts described in the previous pages are useful independently whether the changes on this page are adopted.
 
-The current Dotty implementation implements the new concepts described on this page (implicit as a modifier and the summon method), but it does not remove any of the old-style implicit constructs. It cannot do this since support
+The current Dotty implementation implements the new concepts described on this page (alias instances and the summon method), but it does not remove any of the old-style implicit constructs. It cannot do this since support
 for old-style implicits is an essential part of the common language subset of Scala 2 and Scala 3.0. Any deprecation and subsequent removal of these constructs would have to come later, in a version following 3.0. The `implicit` modifier can be removed from the language at the end of this development, if it happens.
 
-## `instance` As A Modifier.
+## Alias Instances
 
-`instance` can be used as a modifier for `val` and `def` definitions. Examples:
-```scala
-instance val symDeco: SymDeco
-instance val symDeco: SymDeco = compilerSymOps
-instance val ctx = localCtx
-instance def f[T]: C[T] = new C[T]
-instance def g with (ctx: Context): D = new D(ctx)
+An alias instance creates an instance that is equal to some expression.
 ```
-The `instance` modifier must be followed directly by `val` or `def`; no other intervening modifiers are permitted.
-When used as a modifier, `instance` generally has the same meaning as the current `implicit` modifier, with the following exceptions:
-
- 1. `instance def` definitions can only have context parameters in `with` clauses. Old style `implicit` parameters are not supported.
- 2. `instance` cannot be used to define an implicit conversion or an implicit class.
-
+instance ctx of ExecutionContext = currentThreadPool().context
+```
+Here, we create an instance `ctx` of type `ExecutionContext` that resolves to the
+right hand side `currentThreadPool().context`. Each time an instance of `ExecutionContext`
+is demanded, the result of evaluating the right-hand side expression is returned. The instance definition is equivalent to the following implicit definition:
+```
+final implicit def ctx: ExecutionContext = currentThreadPool().context
+```
+Alias instances may be anonymous, e.g.
+```
+instance of Position = enclosingTree.position
+```
+An alias instance can have type and context parameters just like any other instance definition, but it can only implement a single type.
 
 ## Replaced: Implicit Conversions
 
@@ -59,9 +60,8 @@ def summon[T] with (x: T) = x
 
 The syntax changes for this page are summarized as follows:
 ```
-InstanceDef     ::=  ...
-                  |  ‘val’ PatDef
-                  |  ‘def’ MethodDef
+InstanceBody     ::=  ...
+                   |  ‘of’ Type ‘=’ Expr
 ```
 In addition, the `implicit` modifier is removed together with all [productions]((http://dotty.epfl.ch/docs/internals/syntax.html) that reference it.
 

docs/sidebar.yml

@@ -73,7 +73,9 @@ sidebar:
             - title: Context Parameters
               url: docs/reference/instances/context-params.html
             - title: Implicit Function Types
-              url: docs/reference/new-types/implicit-function-types.html
+              url: docs/reference/instances/implicit-function-types.html
+            - title: Implicit Conversions
+              url: docs/reference/instances/implicit-conversions.html
             - title: Replacing Implicits
               url: docs/reference/instances/replacing-implicits.html
             - title: Discussion

tests/new/test.scala

@@ -2,11 +2,17 @@ trait T {
   object O
 }
 
+object Test0 {
+  trait A[T]
+  instance a[T] of A[T]
+
+  class B[T]
+  instance b[T] of B[T]
+}
+
 class C extends T
 
 object Test {
-
   val c = new C
   c.O
-
 }

tests/pos/assumeIn.scala

@@ -3,7 +3,7 @@ object Test {
 
   class Context {
     inline def assumeIn[T](op: => Context |=> T) = {
-      instance def ctx: Context = this
+      instance of Context = this
       op
     }
   }