Fixed abstract overrides of specialized methods.

4 files changed, 74 insertions, 0 deletions

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
+}