add tests extracted from scalameta

Author: poechsel

semanticdb/input/src/main/scala/example/Access.scala

@@ -0,0 +1,11 @@
+package example
+
+class Access {
+  private def m1 = ???
+  private[this] def m2 = ???
+  private[Access] def m3 = ???
+  protected def m4 = ???
+  protected[this] def m5 = ???
+  protected[example] def m6 = ???
+  def m7 = ???
+}

semanticdb/input/src/main/scala/example/Advanced.scala

@@ -0,0 +1,39 @@
+package example
+
+import scala.language.existentials
+import scala.language.higherKinds
+import scala.language.reflectiveCalls
+
+class AdvC[T] {
+  def t: T = ???
+}
+
+class Structural {
+  def s1: { val x: Int } = ???
+  def s2 = new { val x: Int = ??? }
+  def s3 = new { def m(x: Int): Int = ??? }
+}
+
+class Existential {
+  def e1: List[_] = ???
+}
+
+class AdvD[CC[B]] extends AdvC[CC[B]]
+
+object AdvTest {
+  val s = new Structural
+  val s1 = s.s1
+  val s2 = s.s2
+  val s3 = s.s3
+
+  val e = new Existential
+  val e1 = e.e1
+  val e1x = e.e1.head
+  locally {
+    (??? : Any) match {
+      case e3: List[_] =>
+        val e3x = e3.head
+        ()
+    }
+  }
+}

semanticdb/input/src/main/scala/example/Anonymous.scala

@@ -0,0 +1,18 @@
+package example
+import scala.language.higherKinds
+
+class Anonymous {
+  this: Anonymous =>
+
+  def m1[T[_], B] = ???
+  def m2: Map[_, List[_]] = ???
+  locally {
+    ??? match { case _: List[_] => }
+  }
+  locally {
+    val x: Int => Int = _ => ???
+  }
+
+  trait Foo
+  var x = new Foo {}
+}

semanticdb/input/src/main/scala/example/Classes.scala

@@ -0,0 +1,33 @@
+package example
+
+class C1(val x1: Int) extends AnyVal
+
+class C2(val x2: Int) extends AnyVal
+object C2
+
+case class C3(x: Int)
+
+case class C4(x: Int)
+object C4
+
+object M {
+  implicit class C5(x: Int)
+}
+
+case class C6(private val x: Int)
+
+class C7(x: Int)
+
+class C8(private[this] val x: Int)
+
+class C9(private[this] var x: Int)
+
+object N {
+  val anonClass = new C7(42) {
+    val local = ???
+  }
+  val anonFun = List(1).map { i =>
+    val local = 2
+    local + 2
+  }
+}

semanticdb/input/src/main/scala/example/Empty.scala

@@ -0,0 +1,9 @@
+package example
+
+class AdvA {
+  def b: AdvB = ???
+}
+
+class AdvB {
+  def a: AdvA = ???
+}

semanticdb/input/src/main/scala/example/EmptyObject.scala

@@ -0,0 +1,3 @@
+package example
+
+object EmptyObject {}

semanticdb/input/src/main/scala/example/Example2.scala

@@ -0,0 +1,11 @@
+package example
+
+import scala.concurrent.Future
+
+object OExample { self =>
+  new scala.collection.mutable.Stack[Int]()
+  def main(args: Array[String]): Unit = {
+    println(1)
+  }
+  val x = scala.reflect.classTag[Int]
+}

semanticdb/input/src/main/scala/example/Exclude.scala

@@ -0,0 +1,4 @@
+package example
+
+// This class should be excluded by semanticdb.
+class Exclude

semanticdb/input/src/main/scala/example/Flags.scala

@@ -0,0 +1,24 @@
+package example
+
+package object p {
+  private lazy val x = 1
+  protected implicit var y: Int = 2
+  def z(pp: Int) = 3
+  def m[TT] = ???
+  abstract class C[+T, -U, V](x: T, y: U, z: V) {
+    def this() = this(???, ???, ???)
+    def w: Int
+  }
+  type T1 = Int
+  type T2[T] = S[T]
+  type U <: Int
+  type V >: Int
+  case object X
+  final class Y
+  sealed trait Z
+  class AA(x: Int, val y: Int, var z: Int)
+  class S[@specialized T]
+  val List(xs1) = ???
+  ??? match { case List(xs2) => ??? }
+  ??? match { case _: List[t] => ??? }
+}

semanticdb/input/src/main/scala/example/Imports.scala

@@ -0,0 +1 @@
+import scala.util.control.NonFatal

semanticdb/input/src/main/scala/example/Issue1749.scala

@@ -0,0 +1,11 @@
+// See https://github.com/scalameta/scalameta/issues/1749
+package example
+
+import scala.math.Ordered.orderingToOrdered
+
+class Issue1749 {
+  val x1 = 42
+  val x2 = 42
+  (x1, x1)
+    .compare((x2, x2))
+}

semanticdb/input/src/main/scala/example/Locals.scala

@@ -0,0 +1,8 @@
+package example
+
+object Test {
+  val xs = {
+    val x = 42
+    List(x)
+  }
+}

semanticdb/input/src/main/scala/example/MacroAnnotations.scala

@@ -0,0 +1,5 @@
+package example
+
+//@MacroAnnotation
+class MacroAnnotations
+object MacroAnnotations

semanticdb/input/src/main/scala/example/MethodUsages.scala

@@ -0,0 +1,33 @@
+package example
+
+class MethodUsages {
+  val m = new Methods[Int]
+  m.m1
+  m.m2()
+  m.m3(0)
+  m.m4(0)(0)
+  m.m5("")
+  m.m5(0)
+  m.m6(0)
+  m.m6(new m.List[Int])
+  m.m6(Nil)
+  m.m7a(m, new m.List[Int])
+  m.m7b(new m.List[Int])
+  m.`m8().`()
+  m.m9(null)
+  m.m10(null)
+  m.m11(Predef)
+  m.m11(OExample)
+  m.m12a(null)
+  m.m12b(null)
+  m.m13(0)
+  m.m15(0)
+  m.m16(0)
+  m.m16(0)
+  m.m17.m()
+  m.m17(1)
+  m.m17("")
+  m.m18.m()
+  m.m18(1)
+  m.m18("")
+}

semanticdb/input/src/main/scala/example/Methods.scala

@@ -0,0 +1,38 @@
+package example
+
+import scala.math.Ordering
+import scala.language.existentials
+
+class Methods[T] {
+  class List[T]
+  type AList[T] = List[T]
+  def m1 = ???
+  def m2() = ???
+  def m3(x: Int) = ???
+  def m4(x: Int)(y: Int) = ???
+  def m5(x: String) = ???
+  def m5(x: Int) = ???
+  def m6(x: Int) = ???
+  def m6(x: List[T]) = ???
+  def m6(x: scala.List[T]) = ???
+  def m7a[U: Ordering](c: Methods[T], l: List[U]) = ???
+  def m7b[U <: T](l: List[U]) = ???
+  def `m8().`() = ???
+  class `m9().`
+  def m9(x: `m9().`) = ???
+  def m10(x: AList[T]) = ???
+  def m11(x: Predef.type) = ???
+  def m11(x: OExample.type) = ???
+  def m12a(x: {}) = ???
+  def m12b(x: { val x: Int }) = ???
+  def m13(x: Int @unchecked) = ???
+  def m15(x: => Int) = ???
+  def m16(x: Int*) = ???
+  object m17 { def m() = ??? }
+  def m17(a: Int) = ???
+  def m17(b: String) = ???
+  val m18 = m17
+  def m18(a: Int) = ???
+  def m18(b: String) = ???
+  def m19(x: Int, y: Int = 2)(z: Int = 3) = ???
+}

semanticdb/input/src/main/scala/example/Objects.scala

@@ -0,0 +1,5 @@
+package example
+
+object X {
+  object Y
+}

semanticdb/input/src/main/scala/example/Overrides.scala

@@ -0,0 +1,4 @@
+package example
+
+trait OveA { def foo: Int }
+class OveB() extends OveA { def foo: Int = 2 }

semanticdb/input/src/main/scala/example/Prefixes.scala

@@ -0,0 +1,33 @@
+package example
+
+class PrefC {
+  type T
+  def m1: T = ???
+
+  object N {
+    type U
+  }
+  def k1: N.U = ???
+}
+
+object PrefM {
+  type T
+  def n1: T = ???
+}
+
+object PrefO extends PrefC {
+  def o1: T = ???
+}
+
+object PrefTest {
+  val c: PrefC = ???
+  def m2: c.T = ???
+  def k2: c.N.U = ???
+  import c.N._
+  def k3: U = ???
+
+  def n2: PrefM.T = ???
+
+  import PrefM._
+  def n3: T = ???
+}

semanticdb/input/src/main/scala/example/Selfs.scala

@@ -0,0 +1,24 @@
+package example
+
+class B
+
+class AC1 extends B { self =>
+}
+
+class AC2 extends B { self: B =>
+}
+
+abstract class AC3 extends B { self: B with Int =>
+}
+
+class AC4 extends B { a =>
+}
+
+class AC5 extends B { a : B =>
+}
+
+class AC6 extends B { this: B =>
+}
+
+abstract class AC7 { a: B =>
+}

semanticdb/input/src/main/scala/example/Synthetic.scala

@@ -0,0 +1,47 @@
+package example
+
+class Synthetic {
+  List(1).map(_ + 2)
+  Array.empty[Int].headOption
+  "fooo".stripPrefix("o")
+
+  // See https://github.com/scalameta/scalameta/issues/977
+  val Name = "name:(.*)".r
+  val x #:: xs = Stream(1, 2)
+  val Name(name) = "name:foo"
+  1 #:: 2 #:: Stream.empty
+
+  val lst = 1 #:: 2 #:: Stream.empty
+  lst + "foo"
+
+  for (x <- 1 to 10; y <- 0 until 10) println(x -> x)
+  for (i <- 1 to 10; j <- 0 until 10) yield (i, j)
+  for (i <- 1 to 10; j <- 0 until 10 if i % 2 == 0) yield (i, j)
+
+  object s {
+    def apply() = 2
+    s()
+    s.apply()
+    case class Bar()
+    Bar()
+    null.asInstanceOf[Int => Int](2)
+  }
+
+  class J[T: Manifest] { val arr = Array.empty[T] }
+
+  class F
+  implicit val ordering: Ordering[F] = ???
+  val f: Ordered[F] = new F
+
+  import scala.concurrent.ExecutionContext.Implicits.global
+  for {
+    a <- scala.concurrent.Future.successful(1)
+    b <- scala.concurrent.Future.successful(2)
+  } println(a)
+  for {
+    a <- scala.concurrent.Future.successful(1)
+    b <- scala.concurrent.Future.successful(2)
+    if a < b
+  } yield a
+
+}

semanticdb/input/src/main/scala/example/Traits.scala

@@ -0,0 +1,14 @@
+package example
+
+trait T {
+  def x = 2
+}
+
+sealed trait U
+object U {
+  def u: U = new U {}
+}
+
+class C
+trait V { self: C =>
+}