Fixed abstract overrides of specialized methods.

5 files changed, 79 insertions, 1 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index de10a777b0..d27aaba44b 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -697,8 +697,8 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
           log("Added specialized overload for " + overriding.fullName + " in env: " + env)
           val om = specializedOverload(clazz, overridden, env)
           typeEnv(om) = env
+          concreteSpecMethods += overriding
           if (!overriding.isDeferred) {
-            concreteSpecMethods += overriding
             // if the override is a normalized member, 'om' gets the implementation from
             // its original target, and adds the environment of the normalized member (that is,
             // any specialized /method/ type parameter bindings)
@@ -711,6 +711,10 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
             info(overriding)  = Forward(om)
             log("typeEnv(om) = " + typeEnv(om))
             om setPos overriding.pos // set the position of the concrete, overriding member
+          } else {
+            // abstract override
+            log("abstract override " + overriding.fullName + " with specialized " + om.fullName)
+            info(om) = Forward(overriding)
           }
           overloads(overriding) = Overload(om, env) :: overloads(overriding)
           oms += om
diff --git a/test/files/pos/spec-asseenfrom.scala b/test/files/pos/spec-asseenfrom.scala
new file mode 100644
index 0000000000..edd801071a
--- /dev/null
+++ b/test/files/pos/spec-asseenfrom.scala
@@ -0,0 +1,29 @@
+class Automaton[@specialized(Double) W,State] {
+
+  def finalWeight(s: State): W = error("todo");
+
+  def allStates: Set[State] = error("toodo");
+
+  /**
+   * Returns a map from states to its final weight. may expand all nodes.
+   */
+  def finalStateWeights = Map.empty ++ allStates.map { s => (s,finalWeight(s)) }
+
+  // This works fine:
+  /*
+  def finalStateWeights() = {
+    val it = allStates.iterator;
+    while(it.hasNext) {
+      finalWeight(it.next);
+    }
+  }
+  */
+
+}
+
+abstract class Automaton2[@specialized T1, T2] {
+  def finalWeight(s: T2): T1
+  def allStates: Set[T2]
+
+  def f = allStates map finalWeight
+}
diff --git a/test/files/pos/spec-partialmap.scala b/test/files/pos/spec-partialmap.scala
new file mode 100644
index 0000000000..09684e0242
--- /dev/null
+++ b/test/files/pos/spec-partialmap.scala
@@ -0,0 +1,17 @@
+
+// ticket #3378, overloaded specialized variants
+import scala.collection.{Traversable,TraversableLike};
+import scala.collection.generic.CanBuildFrom;
+
+trait PartialMap[@specialized A,@specialized B]
+extends PartialFunction[A,B] with Iterable[(A,B)] {
+
+   // commenting out this declaration gives a different exception.
+  /** Getter for all values for which the given key function returns true. */
+   def apply(f : (A => Boolean)) : Iterator[B] =
+     for ((k,v) <- iterator; if f(k)) yield v;
+
+  // if this is commented, it compiles fine:
+  def apply[This <: Traversable[A], That](keys : TraversableLike[A,This])
+  (implicit bf: CanBuildFrom[This, B, That]) : That = keys.map(apply);
+}
diff --git a/test/files/pos/spec-sparsearray.scala b/test/files/pos/spec-sparsearray.scala
new file mode 100644
index 0000000000..ea7710a785
--- /dev/null
+++ b/test/files/pos/spec-sparsearray.scala
@@ -0,0 +1,24 @@
+import scala.collection.mutable.MapLike
+
+class SparseArray[@specialized(Int) T:ClassManifest] extends collection.mutable.Map[Int,T] with collection.mutable.MapLike[Int,T,SparseArray[T]] {
+  override def get(x: Int) = {
+    val ind = findOffset(x)
+    if(ind < 0) None else Some(error("ignore"))
+  }
+
+  /**
+   * Returns the offset into index and data for the requested vector
+   * index.  If the requested index is not found, the return value is
+   * negative and can be converted into an insertion point with -(rv+1).
+   */
+  private def findOffset(i : Int) : Int = {
+    error("impl doesn't matter")
+  }
+
+  override def apply(i : Int) : T = { error("ignore") }
+  override def update(i : Int, value : T) = error("ignore")
+  override def empty = new SparseArray[T]
+  def -=(ind: Int) = error("ignore")
+  def +=(kv: (Int,T)) = error("ignore")
+  override final def iterator = error("ignore")
+}
diff --git a/test/files/pos/spec-vector.scala b/test/files/pos/spec-vector.scala
new file mode 100644
index 0000000000..392949c669
--- /dev/null
+++ b/test/files/pos/spec-vector.scala
@@ -0,0 +1,4 @@
+// ticket #3379, abstract overrides
+trait Vector extends (Int=>Double) {
+  override def apply(i: Int): Double
+}