Allow reflectiveCalls language import for structural types

The reflectiveCalls member of `scala.language` is now a forwarder to
`scala.reflect.Selectable.reflectiveSelectable`.

Author: odersky

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

@@ -792,10 +792,11 @@ 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.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
       if (!conversionOK)
         checkFeature(nme.implicitConversions,
           i"Use of implicit conversion ${conv.showLocated}", NoSymbol, posd.sourcePos)

library/src/scalaShadowing/language.scala

@@ -75,23 +75,13 @@ object language {
    */
   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
-   *  `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.
+  /** A forwarder to `scala.reflect.Selectable.reflectiveSelectable`.
+   *  Enables cross compilation between Scala 2 and Scala 3.
    *
    *  @group production
    */
-  implicit lazy val reflectiveCalls: reflectiveCalls = languageFeature.reflectiveCalls
+  implicit def reflectiveCalls(receiver: Any): reflect.Selectable =
+    reflect.Selectable.reflectiveSelectable(receiver)
 
   /** Only where enabled, definitions of legacy implicit conversions and certain uses
    *  of implicit conversions are allowed.

tests/run/i4496a.scala

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

tests/run/i4496b.scala

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