Stabilise SIP-47

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -99,10 +99,10 @@ object Feature:
    *       import owner.{ feature => _ }
    */
   def enabledByImport(feature: TermName)(using Context): Boolean =
-    //atPhase(typerPhase) {
+    atPhase(ctx.base.typerPhase) {
       val info = ctx.importInfo
       info != null && info.featureImported(feature)
-    //}
+    }
 
   /** Is `feature` enabled by either a command line setting or an import?
    *  @param  feature   The name of the feature
@@ -121,7 +121,8 @@ object Feature:
 
   def namedTypeArgsEnabled(using Context) = enabled(namedTypeArguments)
 
-  def clauseInterleavingEnabled(using Context) = enabled(clauseInterleaving)
+  def clauseInterleavingEnabled(using Context) =
+    sourceVersion.isAtLeast(`3.6`) || enabled(clauseInterleaving)
 
   def genericNumberLiteralsEnabled(using Context) = enabled(genericNumberLiterals)
 

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

@@ -3878,13 +3878,11 @@ object Parsers {
         val ident = termIdent()
         var name = ident.name.asTermName
         val paramss =
-          if in.featureEnabled(Feature.clauseInterleaving) then
-            // If you are making interleaving stable manually, please refer to the PR introducing it instead, section "How to make non-experimental"
+          if Feature.clauseInterleavingEnabled(using in.languageImportContext) then
             typeOrTermParamClauses(ParamOwner.Def, numLeadParams)
           else
             val tparams = typeParamClauseOpt(ParamOwner.Def)
             val vparamss = termParamClauses(ParamOwner.Def, numLeadParams)
-
             joinParams(tparams, vparamss)
 
         var tpt = fromWithinReturnType { typedOpt() }

docs/_docs/reference/experimental/generalized-method-syntax.md → docs/_docs/reference/other-new-features/generalized-method-syntax.md

@@ -1,15 +1,9 @@
 ---
 layout: doc-page
 title: "Generalized Method Syntax"
-nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/generalized-method-syntax.html
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/generalized-method-syntax.html
 ---
 
-This feature is not yet part of the Scala 3 language definition. It can be made available by a language import:
-
-```scala
-import scala.language.experimental.clauseInterleaving
-```
-
 The inclusion of using clauses is not the only way in which methods have been updated, type parameter clauses are now allowed in any number and at any position.
 
 ## Syntax Changes
@@ -51,7 +45,7 @@ trait DB {
 }
 ```
 
-Note that simply replacing `V` by `k.Value` would not be equivalent. For example, if `k.Value` is `Some[Int]`, only the above allows: 
+Note that simply replacing `V` by `k.Value` would not be equivalent. For example, if `k.Value` is `Some[Int]`, only the above allows:
 `getOrElse(k)[Option[Int]](None)`, which returns a `Number`.
 
 ## Details

library/src/scala/runtime/stdLibPatches/language.scala

@@ -67,6 +67,7 @@ object language:
       * @see [[https://github.com/scala/improvement-proposals/blob/main/content/clause-interleaving.md]]
       */
     @compileTimeOnly("`clauseInterleaving` can only be used at compile time in import statements")
+    @deprecated("`clauseInterleaving` is now standard, no language import is needed", since = "3.6")
     object clauseInterleaving
 
     /** Experimental support for pure function type syntax

presentation-compiler/test/dotty/tools/pc/tests/signaturehelp/SignatureHelpInterleavingSuite.scala

@@ -8,9 +8,6 @@ import java.nio.file.Path
 
 class SignatureHelpInterleavingSuite extends BaseSignatureHelpSuite:
 
-  override protected def scalacOptions(classpath: Seq[Path]): Seq[String] =
-    List("-language:experimental.clauseInterleaving")
-
   @Test def `proper-position-1` =
     check(
       """

scaladoc-testcases/src/tests/extensionParams.scala

@@ -61,8 +61,6 @@ extension (using Unit)(a: Int)
   def f14(): Any
   = ???
 
-import scala.language.experimental.clauseInterleaving
-
 extension (using String)(using Int)(a: Animal)(using Unit)(using Number)
   def f16(b: Any)[T](c: T): T
   = ???

scaladoc-testcases/src/tests/methodsAndConstructors.scala

@@ -1,7 +1,5 @@
 package tests.methodsAndConstructors
 
-import scala.language.experimental.clauseInterleaving
-
 class A
 class B extends A
 class C

tests/neg/interleaving-ab.scala

@@ -1,11 +1,10 @@
-import scala.language.experimental.clauseInterleaving
 
 object Ab:
   given String = ""
   given Double = 0
 
   def illegal[A][B](x: A)(using B): B = summon[B] // error: Type parameter lists must be separated by a term or using parameter list
-  
+
   def ab[A](x: A)[B](using B): B = summon[B]
   def test =
     ab[Int](0: Int) // error

tests/neg/interleaving-params.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 
 class Params{
     def bar[T](x: T)[T]: String = ??? // error

tests/neg/interleaving-signatureCollision.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 
 object signatureCollision:
     def f[T](x: T)[U](y: U) = (x,y)

tests/neg/interleaving-typeApply.check

@@ -1,29 +1,29 @@
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:10:11 --------------------------------------------
-10 |        f3[String]() // error
-   |           ^
-   |           Type argument String does not conform to upper bound Int
-   |
-   | longer explanation available when compiling with `-explain`
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:11:16 --------------------------------------------
-11 |        f5[Int][Unit] // error
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:9:11 ---------------------------------------------
+9 |        f3[String]() // error
+  |           ^
+  |           Type argument String does not conform to upper bound Int
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:10:16 --------------------------------------------
+10 |        f5[Int][Unit] // error
    |                ^
    |                Type argument Unit does not conform to upper bound String
    |
    | longer explanation available when compiling with `-explain`
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:12:19 --------------------------------------------
-12 |        f5[String][Unit] // error // error
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:11:19 --------------------------------------------
+11 |        f5[String][Unit] // error // error
    |                   ^
    |                   Type argument Unit does not conform to upper bound String
    |
    | longer explanation available when compiling with `-explain`
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:12:11 --------------------------------------------
-12 |        f5[String][Unit] // error // error
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:11:11 --------------------------------------------
+11 |        f5[String][Unit] // error // error
    |           ^
    |           Type argument String does not conform to upper bound Int
    |
    | longer explanation available when compiling with `-explain`
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:13:11 --------------------------------------------
-13 |        f7[String]()[Unit] // error
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:12:11 --------------------------------------------
+12 |        f7[String]()[Unit] // error
    |           ^
    |           Type argument String does not conform to upper bound Int
    |

tests/neg/interleaving-typeApply.scala

@@ -1,7 +1,6 @@
-import scala.language.experimental.clauseInterleaving
 
 object typeApply:
-    
+
     def f3[T <: Int](using DummyImplicit)[U <: String](): T => T = ???
     def f5[T <: Int](using DummyImplicit)[U <: String]: [X <: Unit] => X => X = ???
     def f7[T <: Int](using DummyImplicit)[U <: String]()[X <: Unit]: X => X = ???

tests/neg/interleaving-unmatched.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 
 object unmatched:
     def f1[T (x: T)] = ??? // error

tests/neg/interleavingExperimental.check

@@ -0,0 +1,4 @@
+-- [E040] Syntax Error: tests/neg/interleavingExperimental.scala:3:15 --------------------------------------------------
+3 |def ba[A](x: A)[B](using B): B = summon[B] // error: clauseInterleaving was experimental until 3.6
+  |               ^
+  |               '=' expected, but '[' found

tests/neg/interleavingExperimental.scala

@@ -0,0 +1,3 @@
+//> using options --source 3.5
+
+def ba[A](x: A)[B](using B): B = summon[B] // error: clauseInterleaving was experimental until 3.6

tests/neg/namedTypeParams.check

@@ -92,11 +92,11 @@
    |  illegal repeated type application
    |  You might have meant something like:
    |  Test.f[Y = String, Int]
--- [E102] Syntax Error: tests/neg/namedTypeParams.scala:33:9 -----------------------------------------------------------
-33 |  f2[Y = String][X = Int](1, "") // error: Y is undefined
+-- [E102] Syntax Error: tests/neg/namedTypeParams.scala:32:9 -----------------------------------------------------------
+32 |  f2[Y = String][X = Int](1, "") // error: Y is undefined
    |         ^^^^^^
    |         Type parameter Y is undefined. Expected one of X.
--- [E102] Syntax Error: tests/neg/namedTypeParams.scala:34:9 -----------------------------------------------------------
-34 |  f2[Y = String](1, "") // error: Y is undefined
+-- [E102] Syntax Error: tests/neg/namedTypeParams.scala:33:9 -----------------------------------------------------------
+33 |  f2[Y = String](1, "") // error: Y is undefined
    |         ^^^^^^
    |         Type parameter Y is undefined. Expected one of X.

tests/neg/namedTypeParams.scala

@@ -27,7 +27,6 @@ object Test:
 
 object TestInterleaving:
   import language.experimental.namedTypeArguments
-  import language.experimental.clauseInterleaving
   def f2[X](using DummyImplicit)[Y](x: X, y: Y): Int = ???
 
   f2[Y = String][X = Int](1, "") // error: Y is undefined

tests/neg/overrides.scala

@@ -44,8 +44,6 @@ class A[T] {
 
   def next: T = ???
 
-  import scala.language.experimental.clauseInterleaving
-
   def b[U <: T](x: Int)[V >: T](y: String) = false
 }
 
@@ -57,8 +55,6 @@ class B extends A[Int] {
 
   override def next(): Int = ???    // error: incompatible type
 
-  import scala.language.experimental.clauseInterleaving
-
   override def b[T <: Int](x: Int)(y: String) = true // error
 }
 
@@ -68,8 +64,6 @@ class C extends A[String] {
 
   override def next: Int = ???    // error: incompatible type
 
-  import scala.language.experimental.clauseInterleaving
-
   override def b[T <: String](x: Int)[U >: Int](y: String) = true // error: incompatible type
 }
 

tests/pos/interleaving-ba.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 
 object BA {
     given String = ""

tests/pos/interleaving-chainedParams.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 
 object chainedParams{
 

tests/pos/interleaving-classless.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 
 def f1[T]()[U](x: T, y: U): (T, U) = (x, y)
 def f2[T](x: T)[U](y: U): (T, U) = (x, y)

tests/pos/interleaving-functor.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 
 object functorInterleaving:
   //taken from https://dotty.epfl.ch/docs/reference/contextual/type-classes.html

tests/pos/interleaving-newline.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 
 object newline {
   def multipleLines

tests/pos/interleaving-overload.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 
 class A{
 

tests/pos/interleaving-params.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 
 class Params{
     type U

tests/pos/interleaving-signatureCollision.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 import scala.annotation.targetName
 
 object signatureCollision:

tests/pos/interleaving-typeApply.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 
 object typeApply:
 
@@ -12,7 +11,6 @@ object typeApply:
     def f7[T <: Int](using DummyImplicit)[U <: String]()[X <: Unit]: X => X = ???
 
     @main def test = {
-        import scala.language.experimental.namedTypeArguments
         f0[Int][String]
         f1[Int][String]
         f2[Int][String]()

tests/pos/interleavingExperimental.scala

@@ -0,0 +1,5 @@
+//> using options --source 3.5
+
+import scala.language.experimental.clauseInterleaving
+
+def ba[A](x: A)[B](using B): B = summon[B]

tests/pos/namedTypeParams.scala

@@ -11,7 +11,6 @@ object Test {
 }
 
 object TestInterleaving{
-  import language.experimental.clauseInterleaving
   def f2[X](using DummyImplicit)[Y](x: X, y: Y): Int = ???
 
   f2[X = Int][Y = String](1, "")

tests/pos/overrides.scala

@@ -4,8 +4,6 @@ class A[T] {
 
   def f(x: T)(y: T = x) = y
 
-  import scala.language.experimental.clauseInterleaving
-
   def b[U <: T](x: Int)[V >: T](y: String) = false
 
 }
@@ -15,9 +13,6 @@ class B extends A[Int] {
 
   f(2)()
 
-
-  import scala.language.experimental.clauseInterleaving
-
   override def b[T <: Int](x: Int)[U >: Int](y: String) = true
 
 }

tests/run/interleaving.scala

@@ -1,4 +1,3 @@
-import scala.language.experimental.clauseInterleaving
 
 object Test extends App {
   trait Key { type Value }