Revert "Allow reflectiveCalls language import for structural types"

This reverts commit b1bf69c.

Author: odersky

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

@@ -792,11 +792,10 @@ trait Checking {
           sym.owner
         }
       val conversionOK =
-        conv.is(Synthetic)
-        || sym.info.finalResultType.classSymbols.exists(_.isLinkedWith(conv.owner))
-        || defn.isPredefClass(conv.owner)
-        || conv.name == nme.reflectiveSelectable && conv.maybeOwner.maybeOwner.maybeOwner == defn.ScalaPackageClass
-        || conv.maybeOwner == defn.LanguageModule.moduleClass
+        conv.is(Synthetic) ||
+        sym.info.finalResultType.classSymbols.exists(_.isLinkedWith(conv.owner)) ||
+        defn.isPredefClass(conv.owner) ||
+        conv.name == nme.reflectiveSelectable && conv.maybeOwner.maybeOwner.maybeOwner == defn.ScalaPackageClass
       if (!conversionOK)
         checkFeature(nme.implicitConversions,
           i"Use of implicit conversion ${conv.showLocated}", NoSymbol, posd.sourcePos)

docs/docs/reference/changed-features/structural-types.md

@@ -114,8 +114,6 @@ Structural calls like this tend to be much slower than normal method calls. The
 **Note:** In Scala 2, Java reflection is the only mechanism available for structural types and it is automatically enabled without needing the
 `reflectiveSelectable` conversion. However, to warn against inefficient
 dispatch, Scala 2 requires a language import `import scala.language.reflectiveCalls`.
-For a limited time, Scala 3 will honor the same language import (but not the
-associated command-line option) to import `reflectiveSelectable` instead.
 
 Before resorting to structural calls with Java reflection one should consider alternatives. For instance, sometimes a more a modular _and_ efficient architecture can be obtained using typeclasses.
 

library/src/scalaShadowing/language.scala

@@ -75,13 +75,23 @@ object language {
    */
   implicit lazy val postfixOps: postfixOps = languageFeature.postfixOps
 
-  /** A forwarder to `scala.reflect.Selectable.reflectiveSelectable`.
-   *  Enables cross compilation between Scala 2 and Scala 3.
+  /** Only where enabled, accesses to members of structural types that need
+   *  reflection are supported. Reminder: A structural type is a type of the form
+   *  `Parents { Decls }` where `Decls` contains declarations of new members that do
+   *  not override any member in `Parents`. To access one of these members, a
+   *  reflective call is needed.
+   *
+   *  '''Why keep the feature?''' Structural types provide great flexibility because
+   *  they avoid the need to define inheritance hierarchies a priori. Besides,
+   *  their definition falls out quite naturally from Scala’s concept of type refinement.
+   *
+   *  '''Why control it?''' Reflection is not available on all platforms. Popular tools
+   *  such as ProGuard have problems dealing with it. Even where reflection is available,
+   *  reflective dispatch can lead to surprising performance degradations.
    *
    *  @group production
    */
-  implicit def reflectiveCalls(receiver: Any): reflect.Selectable =
-    reflect.Selectable.reflectiveSelectable(receiver)
+  implicit lazy val reflectiveCalls: reflectiveCalls = languageFeature.reflectiveCalls
 
   /** Only where enabled, definitions of legacy implicit conversions and certain uses
    *  of implicit conversions are allowed.

tests/run/i4496a.scala

@@ -1,5 +1,4 @@
-//import scala.reflect.Selectable.reflectiveSelectable
-import scala.language.reflectiveCalls
+import scala.reflect.Selectable.reflectiveSelectable
 class Foo1 { val a: Int = 10 }
 class Foo2 { def a: Int = 10 }
 class Foo3 { var a: Int = 10 }

tests/run/i4496b.scala

@@ -1,5 +1,4 @@
-//import scala.reflect.Selectable.reflectiveSelectable
-import scala.language.reflectiveCalls
+import scala.reflect.Selectable.reflectiveSelectable
 
 trait Foo1 { val a: Int }
 trait Foo2 { def a: Int }