witness -> instance

# Conflicts:
#	compiler/src/dotty/tools/dotc/parsing/Parsers.scala

Author: odersky

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

@@ -341,7 +341,7 @@ object desugar {
     val isCaseClass  = mods.is(Case) && !mods.is(Module)
     val isCaseObject = mods.is(Case) && mods.is(Module)
     val isImplicit = mods.is(Implicit)
-    val isWitness = isImplicit && mods.mods.exists(_.isInstanceOf[Mod.Witness])
+    val isInstance = isImplicit && mods.mods.exists(_.isInstanceOf[Mod.Instance])
     val isEnum = mods.isEnumClass && !mods.is(Module)
     def isEnumCase = mods.isEnumCase
     val isValueClass = parents.nonEmpty && isAnyVal(parents.head)
@@ -669,7 +669,7 @@ object desugar {
         ctx.error(ImplicitCaseClass(cdef), cdef.sourcePos)
         Nil
       }
-      else if (arity != 1 && !isWitness) {
+      else if (arity != 1 && !isInstance) {
         ctx.error(ImplicitClassPrimaryConstructorArity(), cdef.sourcePos)
         Nil
       }
@@ -805,11 +805,11 @@ object desugar {
   /** The normalized name of `mdef`. This means
    *   1. Check that the name does not redefine a Scala core class.
    *      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 witnesses), invent one instead.
+   *   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)}_witness".toTypeName
+    if (name.isEmpty) name = s"${inventName(impl)}_instance".toTypeName
     if (ctx.owner == defn.ScalaPackageClass && defn.reservedScalaClassNames.contains(name)) {
       def kind = if (name.isTypeName) "class" else "object"
       ctx.error(em"illegal redefinition of standard $kind $name", mdef.sourcePos)
@@ -818,7 +818,7 @@ object desugar {
     name
   }
 
-  /** Invent a name for an anonymous witness with template `impl`.
+  /** Invent a name for an anonymous instance with template `impl`.
    */
   private def inventName(impl: Template)(implicit ctx: Context): String =
     if (impl.parents.isEmpty)
@@ -829,7 +829,7 @@ object desugar {
         case Some(DefDef(name, _, (vparam :: _) :: _, _, _)) =>
           s"${name}_of_${inventTypeName(vparam.tpt)}"
         case _ =>
-          ctx.error(i"anonymous witness must have `for` part or must define at least one extension method", impl.pos)
+          ctx.error(i"anonymous instance must have `for` part or must define at least one extension method", impl.pos)
           nme.ERROR.toString
       }
     else

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

@@ -150,7 +150,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Enum()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Enum)
 
-    case class Witness()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implicit)
+    case class Instance()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implicit)
   }
 
   /** Modifiers and annotations for definitions

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

@@ -2133,7 +2133,7 @@ object Parsers {
      */
     def paramClauses(ofClass: Boolean = false,
                      ofCaseClass: Boolean = false,
-                     ofWitness: Boolean = false): List[List[ValDef]] = {
+                     ofInstance: Boolean = false): List[List[ValDef]] = {
       def recur(firstClause: Boolean): List[List[ValDef]] = {
         val initialMods =
           if (in.token == WITH) {
@@ -2142,7 +2142,7 @@ object Parsers {
           }
           else EmptyModifiers
         newLineOptWhenFollowedBy(LPAREN)
-        if (initialMods.is(Contextual) || in.token == LPAREN && !ofWitness) {
+        if (initialMods.is(Contextual) || in.token == LPAREN && !ofInstance) {
           val params = paramClause(
               ofClass = ofClass,
               ofCaseClass = ofCaseClass,
@@ -2427,7 +2427,7 @@ object Parsers {
     /** TmplDef ::=  ([`case'] ‘class’ | trait’) ClassDef
      *            |  [`case'] `object' ObjectDef
      *            |  ‘enum’ EnumDef
-     *            |  ‘witness’ WitnessDef
+     *            |  ‘instance’ InstanceDef
      */
     def tmplDef(start: Int, mods: Modifiers): Tree = {
       in.token match {
@@ -2443,8 +2443,8 @@ object Parsers {
           objectDef(start, posMods(start, mods | Case | Module))
         case ENUM =>
           enumDef(start, mods, atSpan(in.skipToken()) { Mod.Enum() })
-        case WITNESS =>
-          witnessDef(start, mods, atSpan(in.skipToken()) { Mod.Witness() })
+        case INSTANCE =>
+          instanceDef(start, mods, atSpan(in.skipToken()) { Mod.Instance() })
         case _ =>
           syntaxErrorOrIncomplete(ExpectedStartOfTopLevelDefinition())
           EmptyTree
@@ -2540,16 +2540,16 @@ object Parsers {
       Template(constr, parents, Nil, EmptyValDef, Nil)
     }
 
-    /** WitnessDef    ::=  [id] WitnessParams [‘for’ ConstrApps] [TemplateBody]
-     *                  |  id WitnessParams ‘:’ Type ‘=’ Expr
-     *                  |  id ‘:’ ‘=>’ Type ‘=’ Expr
-     *                  |  id ‘=’ Expr
-     *  WitnessParams ::=  [DefTypeParamClause] {‘with’ ‘(’ [DefParams] ‘)}
+    /** InstanceDef    ::=  [id] InstanceParams [‘for’ ConstrApps] [TemplateBody]
+     *                   |  id InstanceParams ‘:’ Type ‘=’ Expr
+     *                   |  id ‘:’ ‘=>’ Type ‘=’ Expr
+     *                   |  id ‘=’ Expr
+     *  InstanceParams ::=  [DefTypeParamClause] {‘with’ ‘(’ [DefParams] ‘)}
      */
-    def witnessDef(start: Offset, mods: Modifiers, witnessMod: Mod) = atPos(start, nameStart) {
+    def instanceDef(start: Offset, mods: Modifiers, instanceMod: Mod) = atPos(start, nameStart) {
       val name = if (isIdent && !isIdent(nme.of)) ident() else EmptyTermName
       val tparams = typeParamClauseOpt(ParamOwner.Def)
-      val vparamss = paramClauses(ofWitness = true)
+      val vparamss = paramClauses(ofInstance = true)
       val parents =
         if (isIdent(nme.of)) {
           in.nextToken()
@@ -2559,7 +2559,7 @@ object Parsers {
       newLineOptWhenFollowedBy(LBRACE)
       if (name.isEmpty && in.token != LBRACE)
         syntaxErrorOrIncomplete(ExpectedTokenButFound(LBRACE, in.token))
-      var mods1 = addMod(mods, witnessMod)
+      var mods1 = addMod(mods, instanceMod)
       val wdef =
         if (in.token == LBRACE) {
           val templ = templateBodyOpt(makeConstructor(tparams, vparamss), parents, isEnum = false)

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

@@ -180,7 +180,6 @@ object Tokens extends TokensCommon {
   final val ENUM = 62;             enter(ENUM, "enum")
   final val ERASED = 63;           enter(ERASED, "erased")
   final val INSTANCE = 64;         enter(INSTANCE, "instance")
-  final val WITNESS = 65;          enter(WITNESS, "witness")
 
   /** special symbols */
   final val NEWLINE = 78;          enter(NEWLINE, "end of statement", "new line")
@@ -202,7 +201,7 @@ object Tokens extends TokensCommon {
   /** XML mode */
   final val XMLSTART = 96;         enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate
 
-  final val alphaKeywords: TokenSet = tokenRange(IF, WITNESS)
+  final val alphaKeywords: TokenSet = tokenRange(IF, INSTANCE)
   final val symbolicKeywords: TokenSet = tokenRange(USCORE, VIEWBOUND)
   final val symbolicTokens: TokenSet = tokenRange(COMMA, VIEWBOUND)
   final val keywords: TokenSet = alphaKeywords | symbolicKeywords
@@ -225,7 +224,7 @@ object Tokens extends TokensCommon {
 
   final val templateIntroTokens: TokenSet = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
 
-  final val dclIntroTokens: TokenSet = BitSet(DEF, VAL, VAR, TYPE, WITNESS)
+  final val dclIntroTokens: TokenSet = BitSet(DEF, VAL, VAR, TYPE, INSTANCE)
 
   final val defIntroTokens: TokenSet = templateIntroTokens | dclIntroTokens
 

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

@@ -132,11 +132,11 @@ trait NamerContextOps { this: Context =>
 
   /** The method type corresponding to given parameters and result type */
   def methodType(typeParams: List[Symbol], valueParamss: List[List[Symbol]], resultType: Type,
-                 isJava: Boolean = false, isWitness: Boolean = false)(implicit ctx: Context): Type = {
+                 isJava: Boolean = false, isInstance: Boolean = false)(implicit ctx: Context): Type = {
     val monotpe =
       (valueParamss :\ resultType) { (params, resultType) =>
         val (isImplicit, isErased, isContextual) =
-          if (params.isEmpty) (isWitness, false, false)
+          if (params.isEmpty) (isInstance, false, false)
           else (params.head is Implicit, params.head is Erased, params.head.is(Contextual))
         val make = MethodType.maker(isJava = isJava, isImplicit = isImplicit, isErased = isErased, isContextual = isContextual)
         if (isJava)
@@ -1302,7 +1302,7 @@ class Namer { typer: Typer =>
     def wrapMethType(restpe: Type): Type = {
       instantiateDependent(restpe, typeParams, termParamss)
       ctx.methodType(tparams map symbolOfTree, termParamss, restpe,
-        isJava = ddef.mods is JavaDefined, isWitness = ddef.mods.hasMod(classOf[Mod.Witness]))
+        isJava = ddef.mods is JavaDefined, isInstance = ddef.mods.hasMod(classOf[Mod.Instance]))
     }
     if (isConstructor) {
       // set result type tree to unit, but take the current class as result type of the symbol

compiler/test/dotc/run-test-pickling.blacklist

@@ -10,5 +10,5 @@ typeclass-derivation2a.scala
 typeclass-derivation3.scala
 derive-generic.scala
 deriving-interesting-prefixes.scala
-witnesses.scala
-witnesses-anonymous.scala
+instances.scala
+instances-anonymous.scala

docs/docs/internals/syntax.md

@@ -368,11 +368,11 @@ 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)
-WitnessDef        ::=  [id] WitnessParams [‘for’ ConstrApps] [TemplateBody]
-                    |  id WitnessParams ‘:’ Type ‘=’ Expr
+InstanceDef       ::=  [id] InstanceParams [‘of’ ConstrApps] [TemplateBody]
+                    |  id InstanceParams ‘:’ Type ‘=’ Expr
                     |  id ‘:’ ‘=>’ Type ‘=’ Expr
                     |  id ‘=’ Expr
-WitnessParams     ::=  [DefTypeParamClause] {‘with’ ‘(’ [DefParams] ‘)'}
+InstanceParams    ::=  [DefTypeParamClause] {‘with’ ‘(’ [DefParams] ‘)'}
 Template          ::=  InheritClauses [TemplateBody]                            Template(constr, parents, self, stats)
 InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
 ConstrApps        ::=  ConstrApp {‘with’ ConstrApp}

docs/docs/reference/witnesses/witness-params.md renamed to docs/docs/reference/instances/context-params.md

@@ -84,14 +84,14 @@ Implementing postconditions via `ensuring`:
 object PostConditions {
   opaque type WrappedResult[T] = T
 
-  private witness WrappedResult {
+  private instance WrappedResult {
     def apply[T](x: T): WrappedResult[T] = x
     def (x: WrappedResult[T]) unwrap[T]: T = x
   }
 
   def result[T] with (wrapped: WrappedResult[T]): T = wrapped.unwrap
 
-  witness {
+  instance {
     def (x: T) ensuring[T] (condition: WrappedResult[T] |=> Boolean): T = {
       assert(condition with WrappedResult(x))
       x

docs/docs/reference/witnesses/discussion.md renamed to docs/docs/reference/instances/discussion.md

@@ -5,16 +5,16 @@ title: "Discussion"
 
 ## Summary
 
-The witness proposal consists of two main parts:
+The instance proposal consists of two main parts:
 
- - Define a new [high-level syntax for witnesses](./witnesses.html) that works out better the intent underlying implicit definitions.
- - Define a [new syntax for implicit parameters](./witness-params.html) that aligns formal parameters and arguments.
- - Define [abstract and alias witnesses](./replacing-implicits.html) and replace all existing usages of `implicit` in the language.
+ - Define a new [high-level syntax for instance definitions](./instance-defs.html) that works out better the intent underlying implicit definitions.
+ - Define a [new syntax for implicit parameters](./context-params.html) that aligns formal parameters and arguments.
+ - Define [abstract and alias instances](./replacing-implicits.html) and replace all existing usages of `implicit` in the language.
 
 
 ## Migration
 
-New and old syntax would co-exist initially. Rewrite rules could rewrite old syntax to new automatically. This is trivial in the case of implicit parameters and implicit function types. It is a bit more involved in the case of implicit definitions, since more extensive pattern matching is required to recognize a definition that can be rewritten to a witness.
+New and old syntax would co-exist initially. Rewrite rules could rewrite old syntax to new automatically. This is trivial in the case of implicit parameters and implicit function types. It is a bit more involved in the case of implicit definitions, since more extensive pattern matching is required to recognize a definition that can be rewritten to a instance.
 
 To make gradual change possible, we allow the new `with` application syntax also for
 old style implicit parameters.
@@ -28,17 +28,17 @@ treated the same in Scala 2 and 3. We therefore opt to map context bounds to old
  - Step 2: Remove ability to pass context bound arguments directly.
  - Step 3: Map context bounds to context parameters.
 
-The third part (replacing existing implicits) should be adopted well after the first two parts are implemented. Alias and abstract witnesses could be introduced together with the other witness definitions, but could also come later.
+The third part (replacing existing implicits) should be adopted well after the first two parts are implemented. Alias and abstract instances could be introduced together with the other instance definitions, but could also come later.
 
 ## Discussion
 
 This is a rather sweeping proposal, which will affect most Scala code. Here are some supporting arguments and a summary of alternatives that were considered.
 
-The witness definition syntax makes the definition of implicit instances clearer and more concise. People have repeatedly asked for specific "typeclass syntax" in Scala. I believe that witnesses together with extension methods address this ask quite well.
+The instance definition syntax makes the definition of implicit instances clearer and more concise. People have repeatedly asked for specific "typeclass syntax" in Scala. I believe that instance definitions together with extension methods address this ask quite well.
 
 Probably the most far reaching and contentious changes affect implicit parameters. There might be resistance to change, because the existing scheme seems to work "well enough". However, I believe there is a price to pay for the status quo. The need to write `.apply` occasionally to force implicit arguments is already bad. Worse is the fact that implicits always have to come last, which makes useful program patterns much more cumbersome than before and makes the language less regular.
 
-Several alternatives to the proposed syntax changes for implicit parameters were considered:
+Two alternatives to the proposed syntax changes for implicit parameters were considered:
 
  1. Leave `implicit` parameters as they are. This suffers from the problems stated
    in the [motivation section](./motivation.md).
@@ -47,11 +47,6 @@ Several alternatives to the proposed syntax changes for implicit parameters were
    construct an extensive explicit argument tree to figure out what went wrong with a missing
    implicit. Another issue is that migration from old to new scheme would be tricky and
    would likely take multiple language versions.
- 3. Split the meanings of implicitly passed parameters and witness parameters. Use prefix ‘.’     as a syntax to indicate that an argument for a parameter can be passed explicitly. Use
-   `witness` as a parameter modifier to indicate that the parameter is available as a witness.
-   This scheme admits some new patterns, such as an explicit parameter that can be
-   used as a witness, or an implicitly passed parameter that is not a witness itself.
-   But the syntax looks unfamiliar and suffers from the choice paradox.
 
-A contentious point is whether we want abstract and alias witnesses. As an alternative, one would could also keep the current syntax for implicit vals and defs, which can express the same concepts. The main advantage to introduce abstract and alias witnesses is that it would
+A contentious point is whether we want abstract and alias instances. As an alternative, one would could also keep the current syntax for implicit vals and defs, which can express the same concepts. The main advantage to introduce abstract and alias instances is that it would
 allow us to drop implicit definitions altogether.