Drop colon in extension methods

odersky · odersky · commit ba38536d49ef · 2020-12-09T17:01:35.000+01:00
diff --git a/community-build/src/scala/dotty/communitybuild/Fields.scala b/community-build/src/scala/dotty/communitybuild/Fields.scala
@@ -5,5 +5,5 @@ import scala.quoted.Type
 class FieldsDsl[V](v: V):
   inline def of[T]: Seq[T] = FieldsImpl.fieldsOfType[V, T](v)
 
-extension [V](on: V):
+extension [V](on: V)
   def reflectedFields = FieldsDsl(on)
diff --git a/compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala b/compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala
@@ -275,7 +275,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
    *   object T { def f { object U } }
    * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here.
    */
-  extension (sym: Symbol):
+  extension (sym: Symbol)
     private def isOriginallyStaticOwner: Boolean =
       sym.is(PackageClass) || sym.is(ModuleClass) && sym.originalOwner.originalLexicallyEnclosingClass.isOriginallyStaticOwner
 
diff --git a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -125,7 +125,7 @@ object DottyBackendInterface {
   }
 
   given symExtensions: AnyRef with
-    extension (sym: Symbol):
+    extension (sym: Symbol)
 
       def isInterface(using Context): Boolean = (sym.is(PureInterface)) || sym.is(Trait)
 
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -1148,7 +1148,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       !(sym.is(Method) && sym.info.isInstanceOf[MethodOrPoly]) // if is a method it is parameterless
   }
 
-  extension (xs: List[tpd.Tree]):
+  extension (xs: List[tpd.Tree])
     def tpes: List[Type] = xs match {
       case x :: xs1 => x.tpe :: xs1.tpes
       case nil => Nil
diff --git a/compiler/src/dotty/tools/dotc/core/ContextOps.scala b/compiler/src/dotty/tools/dotc/core/ContextOps.scala
@@ -9,7 +9,7 @@ import ast.untpd
 /** Extension methods for contexts where we want to keep the ctx.<methodName> syntax */
 object ContextOps:
 
-  extension (ctx: Context):
+  extension (ctx: Context)
 
     /** Enter symbol into current class, if current class is owner of current context,
     *  or into current scope, if not. Should always be called instead of scope.enter
diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -650,7 +650,7 @@ object Contexts {
   }
 
   given ops: AnyRef with
-    extension (c: Context):
+    extension (c: Context)
       def addNotNullInfo(info: NotNullInfo) =
         c.withNotNullInfos(c.notNullInfos.extendWith(info))
 
diff --git a/compiler/src/dotty/tools/dotc/core/Decorators.scala b/compiler/src/dotty/tools/dotc/core/Decorators.scala
@@ -28,7 +28,7 @@ object Decorators {
       case s: String => typeName(s)
       case n: Name => n.toTypeName
 
-  extension (s: String):
+  extension (s: String)
     def splitWhere(f: Char => Boolean, doDropIndex: Boolean): Option[(String, String)] =
       def splitAt(idx: Int, doDropIndex: Boolean): Option[(String, String)] =
         if (idx == -1) None
@@ -61,7 +61,7 @@ object Decorators {
   /** Implements a findSymbol method on iterators of Symbols that
    *  works like find but avoids Option, replacing None with NoSymbol.
    */
-  extension (it: Iterator[Symbol]):
+  extension (it: Iterator[Symbol])
     final def findSymbol(p: Symbol => Boolean): Symbol = {
       while (it.hasNext) {
         val sym = it.next()
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -2571,7 +2571,7 @@ object TypeComparer {
      */
     val Fresh: Repr = 4
 
-    extension (approx: Repr):
+    extension (approx: Repr)
       def low: Boolean = (approx & LoApprox) != 0
       def high: Boolean = (approx & HiApprox) != 0
       def addLow: Repr = approx | LoApprox
diff --git a/compiler/src/dotty/tools/dotc/interactive/Completion.scala b/compiler/src/dotty/tools/dotc/interactive/Completion.scala
@@ -241,7 +241,7 @@ object Completion {
             }
           }
 
-      // There are four possible ways for an extension method to be applicable:
+      // There are four possible ways for an extension method to be applicable
 
       // 1. The extension method is visible under a simple name, by being defined or inherited or imported in a scope enclosing the reference.
       val extMethodsInScope =
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -64,7 +64,7 @@ object Parsers {
     val Spliced = 2
   }
 
-  extension (buf: ListBuffer[Tree]):
+  extension (buf: ListBuffer[Tree])
     def +++=(x: Tree) = x match {
       case x: Thicket => buf ++= x.trees
       case x => buf += x
@@ -3565,8 +3565,6 @@ object Parsers {
       val tparams = typeParamClauseOpt(ParamOwner.Def)
       val extParams = paramClause(0, prefix = true)
       val givenParamss = paramClauses(givenOnly = true)
-      in.observeColonEOL()
-      if (in.token == COLONEOL) in.nextToken()
       val methods =
         if isDefIntro(modifierTokens) then
           extMethod() :: Nil
diff --git a/compiler/src/dotty/tools/dotc/printing/Texts.scala b/compiler/src/dotty/tools/dotc/printing/Texts.scala
@@ -168,7 +168,7 @@ object Texts {
     /** The given texts `xs`, each on a separate line */
     def lines(xs: Traversable[Text]): Vertical = Vertical(xs.toList.reverse)
 
-    extension (text: => Text):
+    extension (text: => Text)
       def provided(cond: Boolean): Text = if (cond) text else Str("")
 
   }
diff --git a/compiler/src/dotty/tools/dotc/printing/package.scala b/compiler/src/dotty/tools/dotc/printing/package.scala
@@ -22,7 +22,7 @@ package object printing {
   val XprintMode: Key[Unit] = new Key
 
   /** @pre `nel` is non-empty list */
-  extension [A](nel: List[A]):
+  extension [A](nel: List[A])
     private[printing] def intersperse(a: A): List[A] =
       nel.flatMap(a :: _ :: Nil).tail
 
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala
@@ -259,7 +259,7 @@ class ExtractSemanticDB extends Phase:
 
         case _ => None
 
-      extension (tpe: Types.Type):
+      extension (tpe: Types.Type)
         private inline def isAnnotatedByUnchecked(using Context) = tpe match
           case Types.AnnotatedType(_, annot) => annot.symbol == defn.UncheckedAnnot
           case _                             => false
@@ -490,12 +490,12 @@ class ExtractSemanticDB extends Phase:
       val start = if idx >= 0 then idx else span.start
       Span(start, start + sym.name.show.length, start)
 
-    extension (list: List[List[ValDef]]):
+    extension (list: List[List[ValDef]])
       private  inline def isSingleArg = list match
         case (_::Nil)::Nil => true
         case _             => false
 
-    extension (tree: DefDef):
+    extension (tree: DefDef)
       private def isSetterDef(using Context): Boolean =
         tree.name.isSetterName && tree.mods.is(Accessor) && tree.vparamss.isSingleArg
 
@@ -521,21 +521,21 @@ class ExtractSemanticDB extends Phase:
         else limit
       Span(start max limit, end)
 
-    extension (span: Span):
+    extension (span: Span)
       private def hasLength: Boolean = span.exists && !span.isZeroExtent
 
     /**Consume head while not an import statement.
      * Returns the rest of the list after the first import, or else the empty list
      */
-    extension (body: List[Tree]):
+    extension (body: List[Tree])
       @tailrec private def foreachUntilImport(op: Tree => Unit): List[Tree] = body match
         case ((_: Import) :: rest) => rest
         case stat :: rest =>
           op(stat)
           rest.foreachUntilImport(op)
         case Nil => Nil
 
-    extension (sym: Symbol):
+    extension (sym: Symbol)
       private def adjustIfCtorTyparam(using Context) =
         if sym.isType && sym.owner.exists && sym.owner.isConstructor then
           matchingMemberType(sym, sym.owner.owner)
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala
@@ -69,7 +69,7 @@ object Scala3:
 
 
   given NameOps: AnyRef with
-    extension (name: Name):
+    extension (name: Name)
       def isWildcard = name match
         case nme.WILDCARD | WILDCARDTypeName => true
         case _                               => name.is(NameKinds.WildcardParamName)
@@ -90,7 +90,7 @@ object Scala3:
   end NameOps
 
   given SymbolOps: AnyRef with
-    extension (sym: Symbol):
+    extension (sym: Symbol)
 
       def ifExists(using Context): Option[Symbol] = if sym.exists then Some(sym) else None
 
@@ -140,13 +140,13 @@ object Scala3:
 
   end LocalSymbol
 
-  extension (char: Char):
+  extension (char: Char)
     private inline def isGlobalTerminal = (char: @switch) match
       case '/' | '.' | '#' | ']' | ')' => true
       case _                           => false
 
   given StringOps: AnyRef with
-    extension (symbol: String):
+    extension (symbol: String)
       def isSymbol: Boolean = !symbol.isEmpty
       def isRootPackage: Boolean = RootPackage == symbol
       def isEmptyPackage: Boolean = EmptyPackage == symbol
@@ -170,7 +170,7 @@ object Scala3:
   end StringOps
 
   given InfoOps: AnyRef with
-    extension (info: SymbolInformation):
+    extension (info: SymbolInformation)
       def isAbstract: Boolean = (info.properties & SymbolInformation.Property.ABSTRACT.value) != 0
       def isFinal: Boolean = (info.properties & SymbolInformation.Property.FINAL.value) != 0
       def isSealed: Boolean = (info.properties & SymbolInformation.Property.SEALED.value) != 0
@@ -205,7 +205,7 @@ object Scala3:
   end InfoOps
 
   given RangeOps: AnyRef with
-    extension (range: Range):
+    extension (range: Range)
       def hasLength = range.endLine > range.startLine || range.endCharacter > range.startCharacter
   end RangeOps
 
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala b/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala
@@ -144,5 +144,5 @@ object Tools:
     sb.append(if occ.role.isReference then " -> " else " <- ").append(occ.symbol).nl
   end processOccurrence
 
-  extension (sb: StringBuilder):
+  extension (sb: StringBuilder)
     private inline def nl = sb.append(System.lineSeparator)
diff --git a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala
@@ -190,7 +190,7 @@ object ExtensionMethods {
         // See the documentation of `memberSignature` to understand why `.stripPoly.ensureMethodic` is needed here.
         candidates filter (c => FullParameterization.memberSignature(c.info) == imeth.info.stripPoly.ensureMethodic.signature)
       assert(matching.nonEmpty,
-       i"""no extension method found for:
+       i"""no extension method found for
           |
           |  $imeth:${imeth.info.show} with signature ${imeth.info.signature} in ${companion.moduleClass}
           |
diff --git a/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala b/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala
@@ -35,7 +35,7 @@ object ImportInfo {
 
     ImportInfo(sym, selectors, None, isRootImport = true)
 
-  extension (c: Context):
+  extension (c: Context)
     def withRootImports(rootRefs: List[RootRef])(using Context): Context =
       rootRefs.foldLeft(c)((ctx, ref) => ctx.fresh.setImportInfo(rootImport(ref)))
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Nullables.scala b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
@@ -339,7 +339,7 @@ object Nullables:
       }.traverse(tree)
   end extension
 
-  extension (tree: Assign):
+  extension (tree: Assign)
     def computeAssignNullable()(using Context): tree.type = tree.lhs match
       case TrackedRef(ref) =>
         val rhstp = tree.rhs.typeOpt
diff --git a/compiler/src/dotty/tools/dotc/util/LinearMap.scala b/compiler/src/dotty/tools/dotc/util/LinearMap.scala
@@ -15,7 +15,7 @@ object LinearMap:
   def empty[K <: AnyRef, V >: Null <: AnyRef]: LinearMap[K, V] =
     immutable.Map.empty[K, V]
 
-  extension [K <: AnyRef, V >: Null <: AnyRef](m: LinearMap[K, V]):
+  extension [K <: AnyRef, V >: Null <: AnyRef](m: LinearMap[K, V])
 
     def lookup(key: K): V /*| Null*/ = (m: @unchecked) match
       case m: immutable.AbstractMap[K, V] @unchecked =>
diff --git a/compiler/src/dotty/tools/dotc/util/LinearSet.scala b/compiler/src/dotty/tools/dotc/util/LinearSet.scala
@@ -12,7 +12,7 @@ object LinearSet:
 
   def empty[Elem >: Null <: AnyRef]: LinearSet[Elem] = immutable.Set.empty[Elem]
 
-  extension [Elem >: Null <: AnyRef](s: LinearSet[Elem]):
+  extension [Elem >: Null <: AnyRef](s: LinearSet[Elem])
 
     def contains(elem: Elem): Boolean = (s: @unchecked) match
       case s: immutable.AbstractSet[Elem] @unchecked => s.contains(elem)
diff --git a/compiler/src/dotty/tools/package.scala b/compiler/src/dotty/tools/package.scala
@@ -25,7 +25,7 @@ package object tools {
     throw new UnsupportedOperationException(methodName)
 
   /** Forward-ported from the explicit-nulls branch. */
-  extension [T](x: T | Null):
+  extension [T](x: T | Null)
 
     /** Assert `x` is non null and strip `Null` from type */
     inline def nn: T =
diff --git a/compiler/src/dotty/tools/repl/Rendering.scala b/compiler/src/dotty/tools/repl/Rendering.scala
@@ -142,7 +142,7 @@ private[repl] class Rendering(parentClassLoader: Option[ClassLoader] = None) {
 
 object Rendering {
 
-  extension (s: Symbol):
+  extension (s: Symbol)
     def showUser(using Context): String = {
       val printer = new ReplPrinter(ctx)
       val text = printer.dclText(s)
diff --git a/compiler/src/dotty/tools/repl/results.scala b/compiler/src/dotty/tools/repl/results.scala
@@ -14,10 +14,10 @@ object results {
   /** Result is a type alias for an Either with left value `Errors` */
   type Result[+A] = scala.util.Either[Errors, A]
 
-  extension [A](a: A):
+  extension [A](a: A)
     def result: Result[A] = scala.util.Right(a)
 
-  extension [A](xs: Errors):
+  extension [A](xs: Errors)
     def errors: Result[A] = scala.util.Left(xs)
 
 }
diff --git a/compiler/src/scala/quoted/runtime/impl/Matcher.scala b/compiler/src/scala/quoted/runtime/impl/Matcher.scala
@@ -135,12 +135,12 @@ object Matcher {
       case _ => notMatched
     }
 
-    extension (scrutinees: List[Tree]):
+    extension (scrutinees: List[Tree])
       /** Check that all trees match with =?= and concatenate the results with &&& */
       private def =?= (patterns: List[Tree])(using Env): Matching =
         matchLists(scrutinees, patterns)(_ =?= _)
 
-    extension (scrutinee0: Tree):
+    extension (scrutinee0: Tree)
       /** Check that the trees match and return the contents from the pattern holes.
        *  Return None if the trees do not match otherwise return Some of a tuple containing all the contents in the holes.
        *
@@ -408,7 +408,7 @@ object Matcher {
     val matched: Matching = Some(Tuple())
     def matched(x: Any): Matching = Some(Tuple1(x))
 
-    extension (self: Matching):
+    extension (self: Matching)
       def asOptionOfTuple: Option[Tuple] = self
 
       /** Concatenates the contents of two successful matchings or return a `notMatched` */
diff --git a/compiler/test/dotty/tools/repl/ReplTest.scala b/compiler/test/dotty/tools/repl/ReplTest.scala
@@ -47,7 +47,7 @@ class ReplTest(withStaging: Boolean = false, out: ByteArrayOutputStream = new By
   def fromInitialState[A](op: State => A): A =
     op(initialState)
 
-  extension [A](state: State):
+  extension [A](state: State)
     def andThen(op: State => A): A = op(state)
 
   def scripts(path: String): Array[JFile] = {
diff --git a/docs/docs/internals/syntax.md b/docs/docs/internals/syntax.md
@@ -1,6 +1,6 @@
 ---
 layout: doc-page
-title: "Scala Syntax Summary"
+title: "Scala3 Syntax Summary"
 ---
 
 The following descriptions of Scala tokens uses literal characters `‘c’` when
@@ -261,8 +261,6 @@ Guard             ::=  ‘if’ PostfixExpr
 CaseClauses       ::=  CaseClause { CaseClause }                                Match(EmptyTree, cases)
 CaseClause        ::=  ‘case’ Pattern [Guard] ‘=>’ Block                        CaseDef(pat, guard?, block)   // block starts at =>
 ExprCaseClause    ::=  ‘case’ Pattern [Guard] ‘=>’ Expr
-ImplicitCaseClauses ::=  ImplicitCaseClause { ImplicitCaseClause }
-ImplicitCaseClause  ::=  ‘case’ PatVar [‘:’ RefinedType] [Guard] ‘=>’ Block
 TypeCaseClauses   ::=  TypeCaseClause { TypeCaseClause }
 TypeCaseClause    ::=  ‘case’ InfixType ‘=>’ Type [nl]
 
@@ -350,7 +348,7 @@ ImportSelectors   ::=  id [‘=>’ id | ‘=>’ ‘_’] [‘,’ ImportSelect
                     |  WildCardSelector {‘,’ WildCardSelector}
 WildCardSelector  ::=  ‘given’ [InfixType]
                     |  ‘_'
-Export            ::=  ‘export’ [‘given’] ImportExpr {‘,’ ImportExpr}
+Export            ::=  [‘given’] ImportExpr {‘,’ ImportExpr}
 
 EndMarker         ::=  ‘end’ EndMarkerTag    -- when followed by EOL
 EndMarkerTag      ::=  id | ‘if’ | ‘while’ | ‘for’ | ‘match’ | ‘try’
diff --git a/docs/sidebar.yml b/docs/sidebar.yml
@@ -187,6 +187,8 @@ sidebar:
               url: docs/reference/dropped-features/nonlocal-returns.html
             - title: "[this] Qualifier"
               url: docs/reference/dropped-features/this-qualifier.html
+        - title: Syntax Summary
+          url: doc/reference/syntax.html
     - title: Contributing
       subsection:
         - title: Contribute Knowledge
diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
diff --git a/scala3doc-testcases/src/tests/FilterTest.scala b/scala3doc-testcases/src/tests/FilterTest.scala
diff --git a/scala3doc-testcases/src/tests/extensionMethodSignatures.scala b/scala3doc-testcases/src/tests/extensionMethodSignatures.scala
diff --git a/scala3doc-testcases/src/tests/implicitMembers.scala b/scala3doc-testcases/src/tests/implicitMembers.scala
diff --git a/tests/bench/string-interpolation-macro/Macro.scala b/tests/bench/string-interpolation-macro/Macro.scala
diff --git a/tests/neg/gadt-approximation-interaction.scala b/tests/neg/gadt-approximation-interaction.scala
diff --git a/tests/neg/i5773.scala b/tests/neg/i5773.scala
diff --git a/tests/neg/i6900.scala b/tests/neg/i6900.scala
diff --git a/tests/pos/i6900.scala b/tests/pos/i6900.scala
diff --git a/tests/pos/typeclass-encoding3.scala b/tests/pos/typeclass-encoding3.scala

Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ object DottyBackendInterface {`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`given symExtensions: AnyRef with`
`128`		`- extension (sym: Symbol):`
	`128`	`+ extension (sym: Symbol)`
`129`	`129`
`130`	`130`	`def isInterface(using Context): Boolean = (sym.is(PureInterface)) \|\| sym.is(Trait)`
`131`	`131`
Original file line number	Diff line number	Diff line change
`@@ -1148,7 +1148,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {`
`1148`	`1148`	`!(sym.is(Method) && sym.info.isInstanceOf[MethodOrPoly]) // if is a method it is parameterless`
`1149`	`1149`	`}`
`1150`	`1150`
`1151`		`- extension (xs: List[tpd.Tree]):`
	`1151`	`+ extension (xs: List[tpd.Tree])`
`1152`	`1152`	`def tpes: List[Type] = xs match {`
`1153`	`1153`	`case x :: xs1 => x.tpe :: xs1.tpes`
`1154`	`1154`	`case nil => Nil`
Original file line number	Diff line number	Diff line change
`@@ -650,7 +650,7 @@ object Contexts {`
`650`	`650`	`}`
`651`	`651`
`652`	`652`	`given ops: AnyRef with`
`653`		`- extension (c: Context):`
	`653`	`+ extension (c: Context)`
`654`	`654`	`def addNotNullInfo(info: NotNullInfo) =`
`655`	`655`	`c.withNotNullInfos(c.notNullInfos.extendWith(info))`
`656`	`656`
Original file line number	Diff line number	Diff line change
`@@ -241,7 +241,7 @@ object Completion {`
`241`	`241`	`}`
`242`	`242`	`}`
`243`	`243`
`244`		`- // There are four possible ways for an extension method to be applicable:`
	`244`	`+ // There are four possible ways for an extension method to be applicable`
`245`	`245`
`246`	`246`	`// 1. The extension method is visible under a simple name, by being defined or inherited or imported in a scope enclosing the reference.`
`247`	`247`	`val extMethodsInScope =`