Require language import for ad hoc extensions

Author: odersky

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -367,8 +367,8 @@ object StdNames {
     val TypeApply: N            = "TypeApply"
     val TypeRef: N              = "TypeRef"
     val UNIT : N                = "UNIT"
-    val add_ : N                = "add"
     val acc: N                  = "acc"
+    val adhocExtensions: N      = "adhocExtensions"
     val annotation: N           = "annotation"
     val any2stringadd: N        = "any2stringadd"
     val anyHash: N              = "anyHash"

compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -108,13 +108,13 @@ trait Reporting { this: Context =>
       else {
         reporter.reportNewFeatureUseSite(featureUseSite)
         s"""
-           |This can be achieved by adding the import clause 'import $fqname'
-           |or by setting the compiler option -language:$feature.
            |See the Scala docs for value $fqname for a discussion
            |why the feature $req be explicitly enabled.""".stripMargin
       }
 
-    val msg = s"$featureDescription $req be enabled\nby making the implicit value $fqname visible.$explain"
+    val msg = s"""$featureDescription $req be enabled
+                 |by adding the import clause 'import $fqname'
+                 |or by setting the compiler option -language:$feature.$explain""".stripMargin
     if (required) error(msg, pos)
     else reportWarning(new FeatureWarning(msg, pos))
   }

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -1544,6 +1544,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def Flags_Private: Flags = core.Flags.Private
   def Flags_Protected: Flags = core.Flags.Protected
   def Flags_Abstract: Flags = core.Flags.Abstract
+  def Flags_Open: Flags = core.Flags.Open
   def Flags_Final: Flags = core.Flags.Final
   def Flags_Sealed: Flags = core.Flags.Sealed
   def Flags_Case: Flags = core.Flags.Case

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

@@ -884,7 +884,7 @@ class Namer { typer: Typer =>
           else if !cls.is(ChildrenQueried) then
             addChild(cls, child)
           else
-            ctx.error(em"""children of $cls were already queried before $sym / ${sym.ownersIterator.toList} was discovered.
+            ctx.error(em"""children of $cls were already queried before $sym was discovered.
                           |As a remedy, you could move $sym on the same nesting level as $cls.""",
                       child.sourcePos)
 
@@ -1163,10 +1163,16 @@ class Namer { typer: Typer =>
           }
           else {
             val pclazz = pt.typeSymbol
-            if (pclazz.is(Final))
+            if pclazz.is(Final) then
               ctx.error(ExtendFinalClass(cls, pclazz), cls.sourcePos)
-            if (pclazz.is(Sealed) && pclazz.associatedFile != cls.associatedFile)
-              ctx.error(UnableToExtendSealedClass(pclazz), cls.sourcePos)
+            else if pclazz.isEffectivelySealed && pclazz.associatedFile != cls.associatedFile then
+              if pclazz.is(Sealed) then
+                ctx.error(UnableToExtendSealedClass(pclazz), cls.sourcePos)
+              else if ctx.settings.strict.value then
+                checkFeature(nme.adhocExtensions,
+                  i"Unless $pclazz with flags ${pclazz.flagsString} is declared 'open', its extension in a separate file",
+                  cls.topLevelClass,
+                  parent.sourcePos)
             pt
           }
         }

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -58,7 +58,8 @@ class CompilationTests extends ParallelTesting {
       ),
       compileFile("tests/pos-special/typeclass-scaling.scala", defaultOptions.and("-Xmax-inlines", "40")),
       compileFile("tests/pos-special/indent-colons.scala", defaultOptions.and("-Yindent-colons")),
-      compileFile("tests/pos-special/i7296.scala", defaultOptions.and("-strict", "-deprecation", "-Xfatal-warnings"))
+      compileFile("tests/pos-special/i7296.scala", defaultOptions.and("-strict", "-deprecation", "-Xfatal-warnings")),
+      compileDir("tests/pos-special/adhoc-extension", defaultOptions.and("-strict", "-feature", "-Xfatal-warnings"))
     ).checkCompile()
   }
 
@@ -142,7 +143,8 @@ class CompilationTests extends ParallelTesting {
       compileFile("tests/neg-custom-args/missing-alpha.scala", defaultOptions.and("-strict", "-deprecation", "-Xfatal-warnings")),
       compileFile("tests/neg-custom-args/wildcards.scala", defaultOptions.and("-strict", "-deprecation", "-Xfatal-warnings")),
       compileFile("tests/neg-custom-args/indentRight.scala", defaultOptions.and("-noindent", "-Xfatal-warnings")),
-      compileFile("tests/neg-custom-args/extmethods-tparams.scala", defaultOptions.and("-deprecation", "-Xfatal-warnings"))
+      compileFile("tests/neg-custom-args/extmethods-tparams.scala", defaultOptions.and("-deprecation", "-Xfatal-warnings")),
+      compileDir("tests/neg-custom-args/adhoc-extension", defaultOptions.and("-strict", "-feature", "-Xfatal-warnings"))
     ).checkExpectedErrors()
   }
 

library/src/scalaShadowing/language.scala

@@ -62,7 +62,7 @@ object language {
    *
    *  @group production
    */
-  @volatile implicit lazy val dynamics: dynamics = languageFeature.dynamics
+  implicit lazy val dynamics: dynamics = languageFeature.dynamics
 
   /** Only where enabled, postfix operator notation `(expr op)` will be allowed.
    *
@@ -73,7 +73,7 @@ object language {
    *
    *  @group production
    */
-  @volatile implicit lazy val postfixOps: postfixOps = languageFeature.postfixOps
+  implicit lazy val postfixOps: postfixOps = languageFeature.postfixOps
 
   /** Only where enabled, accesses to members of structural types that need
    *  reflection are supported. Reminder: A structural type is a type of the form
@@ -91,7 +91,7 @@ object language {
    *
    *  @group production
    */
-  @volatile implicit lazy val reflectiveCalls: reflectiveCalls = languageFeature.reflectiveCalls
+  implicit lazy val reflectiveCalls: reflectiveCalls = languageFeature.reflectiveCalls
 
   /** Only where enabled, definitions of legacy implicit conversions and certain uses
    *  of implicit conversions are allowed.
@@ -139,7 +139,7 @@ object language {
    *
    *  @group production
    */
-  @volatile implicit lazy val implicitConversions: implicitConversions = languageFeature.implicitConversions
+  implicit lazy val implicitConversions: implicitConversions = languageFeature.implicitConversions
 
   /** Only where this flag is enabled, higher-kinded types can be written.
    *
@@ -162,7 +162,7 @@ object language {
    *
    *  @group production
    */
-  @volatile implicit lazy val higherKinds: higherKinds = languageFeature.higherKinds
+  implicit lazy val higherKinds: higherKinds = languageFeature.higherKinds
 
   /** Only where enabled, existential types that cannot be expressed as wildcard
    *  types can be written and are allowed in inferred types of values or return
@@ -180,7 +180,7 @@ object language {
    *
    *  @group production
    */
-  @volatile implicit lazy val existentials: existentials = languageFeature.existentials
+  implicit lazy val existentials: existentials = languageFeature.existentials
 
   /** The experimental object contains features that have been recently added but have not
    *  been thoroughly tested in production yet.
@@ -209,7 +209,7 @@ object language {
      *  '''Why control it?''' For their very power, macros can lead to code that is hard
      *  to debug and understand.
      */
-    @volatile implicit lazy val macros: macros = languageFeature.experimental.macros
+    implicit lazy val macros: macros = languageFeature.experimental.macros
   }
 
   /** Where imported, a backwards compatibility mode for Scala2 is enabled */
@@ -218,6 +218,24 @@ object language {
   /** Where imported, auto-tupling is disabled */
   object noAutoTupling
 
-  /** Where imported loose equality using eqAny is disabled */
+  /** Where imported, loose equality using eqAny is disabled */
   object strictEquality
+
+  /** Where imported, ad hoc extensions of non-open classes in other
+   *  compilation units are allowed.
+   *
+   *  '''Why control the feature?''' Ad-hoc extensions should usually be avoided
+   *  since they typically cannot reply on an "internal" contract between a class
+   *  and its extensions. Only open classes need to specify such a contract.
+   *  Ad-hoc extensions might break for future versions of the extended class,
+   *  since the extended class is free to change its implementation without
+   *  being constrained by an internal contract.
+   *
+   *  '''Why allow it?''' An ad-hoc extension can sometimes be necessary,
+   *  for instance when mocking a class in a testing framework, or to work
+   *  around a bug or missing feature in the original class. Nevertheless,
+   *  such extensions should be limited in scope and clearly documented.
+   *  That's why the language import is required for them.
+   */
+  object adhocExtensions
 }

tests/neg-custom-args/adhoc-extension/A.scala

@@ -0,0 +1,2 @@
+package adhoc
+class A

tests/neg-custom-args/adhoc-extension/B.scala

@@ -0,0 +1,8 @@
+package adhoc
+class B extends A  // error: adhoc-extension (under -strict -feature -Xfatal-warnings)
+class C extends A  // error
+
+object O {
+  val a = new A {}  // error
+  object E extends A  // error
+}

tests/neg/i5455.scala

@@ -11,10 +11,9 @@ object Library {
     def toInt(n: Nat): Int = n
 
   }
-  given {
-    def (x: Nat) * (y: Nat): Nat = x * y
-    def (x: Nat) toInt: Int = x
-  }
+  given (x: Nat)
+    def * (y: Nat): Nat = x * y
+    def toInt: Int = x
 }
 
 object User extends App {

tests/pos-special/adhoc-extension/A.scala

@@ -0,0 +1,3 @@
+package adhoc
+class A
+abstract class Abs