Disallow inline methods and opaque types in same scope

Author: odersky

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

@@ -803,6 +803,8 @@ class Namer { typer: Typer =>
 
     private def addInlineInfo(sym: Symbol) = original match {
       case original: untpd.DefDef if sym.isInlineMethod =>
+        if (sym.owner.isClass && sym.owner.seesOpaques)
+          ctx.error(em"Implementation restriction: No inline methods allowed where opaque type aliases are in scope", sym.sourcePos)
         PrepareInlineable.registerInlineInfo(
             sym,
             implicit ctx => typedAheadExpr(original).asInstanceOf[tpd.DefDef].rhs

library/src-bootstrapped/scala/IArray.scala

@@ -15,12 +15,28 @@ implicit object arrayOps {
     *  @param n   the index of the element to select
     *  @return    the element of the array at the given index
     */
-  inline def (arr: IArray[T]) apply[T] (n: Int): T = arr.asInstanceOf[Array[T]].apply(n)
+  def (arr: IArray[Byte]) apply (n: Int): Byte = arr.asInstanceOf[Array[Byte]].apply(n)
+  def (arr: IArray[Short]) apply (n: Int): Short = arr.asInstanceOf[Array[Short]].apply(n)
+  def (arr: IArray[Char]) apply (n: Int): Char = arr.asInstanceOf[Array[Char]].apply(n)
+  def (arr: IArray[Int]) apply (n: Int): Int = arr.asInstanceOf[Array[Int]].apply(n)
+  def (arr: IArray[Long]) apply (n: Int): Long = arr.asInstanceOf[Array[Long]].apply(n)
+  def (arr: IArray[Float]) apply (n: Int): Float = arr.asInstanceOf[Array[Float]].apply(n)
+  def (arr: IArray[Double]) apply (n: Int): Double = arr.asInstanceOf[Array[Double]].apply(n)
+  def (arr: IArray[T]) apply[T <: Object] (n: Int): T = arr.asInstanceOf[Array[T]].apply(n)
+  def (arr: IArray[T]) apply[T] (n: Int): T = arr.asInstanceOf[Array[T]].apply(n)
 
   /** The number of elements in an immutable array
     *  @param arr  the immutable array
     */
-  inline def (arr: IArray[T]) length[T] : Int = arr.asInstanceOf[Array[T]].length
+  def (arr: IArray[Byte]) length: Int = arr.asInstanceOf[Array[Byte]].length
+  def (arr: IArray[Short]) length: Int = arr.asInstanceOf[Array[Short]].length
+  def (arr: IArray[Char]) length: Int = arr.asInstanceOf[Array[Char]].length
+  def (arr: IArray[Int]) length: Int = arr.asInstanceOf[Array[Int]].length
+  def (arr: IArray[Long]) length: Int = arr.asInstanceOf[Array[Long]].length
+  def (arr: IArray[Float]) length: Int = arr.asInstanceOf[Array[Float]].length
+  def (arr: IArray[Double]) length: Int = arr.asInstanceOf[Array[Double]].length
+  def (arr: IArray[Object]) length: Int = arr.asInstanceOf[Array[Object]].length
+  def (arr: IArray[T]) length[T] : Int = arr.asInstanceOf[Array[T]].length
 }
 
 object IArray {

tests/neg/inline3.scala

@@ -0,0 +1,28 @@
+object K0 {
+
+  type T = String
+
+  opaque type ProductInstances[F[_], T] = ErasedProductInstances[F[T]]
+
+  inline def summonAsArray[F[_], T]: Array[Any] = ??? // error: Implementation restriction: No inline methods allowed
+
+  inline def mkProductInstances[F[_], T]: ProductInstances[F, T] = // error: Implementation restriction: No inline methods allowed
+    new ErasedProductInstances(summonAsArray[F, T]).asInstanceOf[ProductInstances[F, T]]
+
+  val x: T = ""
+
+  inline def foo(x: T): T = "foo".asInstanceOf[T] // error: Implementation restriction: No inline methods allowed
+
+}
+
+final class ErasedProductInstances[FT](is0: => Array[Any])
+
+trait Monoid[A]
+case class ISB(i: Int)
+
+object Test {
+  //val K0 = new K0
+  K0.foo(K0.x)
+  K0.mkProductInstances[Monoid, ISB]
+
+}

tests/run/opaque-immutable-array-xm.scala

@@ -6,7 +6,7 @@ object Test extends App {
   opaque type IArray[A1] = Array[A1]
 
   implicit object IArray {
-    inline def initialize[A](body: => Array[A]): IArray[A] = body
+    def initialize[A](body: => Array[A]): IArray[A] = body
     def apply[A: ClassTag](xs: A*): IArray[A] = initialize(Array(xs: _*))
 
     // These should be inline but that does not work currently. Try again