Merge pull request #5761 from poechsel/master

SemanticDB generator

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/FlagsOpsImpl.scala

@@ -43,6 +43,11 @@ trait FlagsOpsImpl extends scala.tasty.reflect.FlagsOps with CoreImpl {
     def StableRealizable: Flags = core.Flags.StableRealizable
     def Param: Flags = core.Flags.Param
     def ParamAccessor: Flags = core.Flags.ParamAccessor
+    def Enum: Flags = core.Flags.Enum
+    def ModuleClass: Flags = core.Flags.ModuleClass
+    def PrivateLocal: Flags = core.Flags.PrivateLocal
+    def Package: Flags = core.Flags.Package
+    def ImplClass: Flags = core.Flags.ImplClass
   }
 
 }

compiler/src/dotty/tools/dotc/tastyreflect/ImportSelectorOpsImpl.scala

@@ -2,6 +2,7 @@ package dotty.tools.dotc.tastyreflect
 
 import dotty.tools.dotc.ast.{Trees, untpd}
 import dotty.tools.dotc.core.StdNames.nme
+import dotty.tools.dotc.core.Decorators._
 
 trait ImportSelectorOpsImpl extends scala.tasty.reflect.ImportSelectorOps with CoreImpl {
 

compiler/src/dotty/tools/dotc/tastyreflect/PatternOpsImpl.scala

@@ -36,6 +36,7 @@ trait PatternOpsImpl extends scala.tasty.reflect.PatternOps with CoreImpl {
   def PatternDeco(pattern: Pattern): PatternAPI = new PatternAPI {
     def pos(implicit ctx: Context): Position = pattern.sourcePos
     def tpe(implicit ctx: Context): Type = pattern.tpe.stripTypeVar
+    def symbol(implicit ctx: Context): Symbol = pattern.symbol
   }
 
   object Pattern extends PatternModule {

compiler/src/dotty/tools/dotc/tastyreflect/SymbolOpsImpl.scala

@@ -30,6 +30,14 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with CoreImpl {
 
     def owner(implicit ctx: Context): Symbol = symbol.owner
 
+    def isLocalDummy(implicit ctx: Context): Boolean = symbol.isLocalDummy
+    def isRefinementClass(implicit ctx: Context): Boolean = symbol.isRefinementClass
+    def isAliasType(implicit ctx: Context): Boolean = symbol.isAliasType
+    def isAnonymousClass(implicit ctx: Context): Boolean = symbol.isAnonymousClass
+    def isAnonymousFunction(implicit ctx: Context): Boolean = symbol.isAnonymousFunction
+    def isAbstractType(implicit ctx: Context): Boolean = symbol.isAbstractType
+    def isClassConstructor(implicit ctx: Context): Boolean = symbol.isClassConstructor
+
     def localContext(implicit ctx: Context): Context = {
       if (symbol.exists) ctx.withOwner(symbol)
       else ctx
@@ -167,6 +175,11 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with CoreImpl {
       if (sym.exists) Some(sym.asTerm) else None
     }
 
+    def moduleClass(implicit ctx: Context): Option[Symbol] = {
+      val sym = symbol.moduleClass
+      if (sym.exists) Some(sym.asTerm) else None
+    }
+
     private def isField(sym: Symbol)(implicit ctx: Context): Boolean = sym.isTerm && !sym.is(Flags.Method)
   }
 

compiler/src/dotty/tools/dotc/tastyreflect/TypeOrBoundsOpsImpl.scala

@@ -21,6 +21,8 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with CoreI
 
     def classSymbol(implicit ctx: Context): Option[ClassSymbol] =
       if (tpe.classSymbol.exists) Some(tpe.classSymbol.asClass) else None
+
+    def typeSymbol(implicit ctx: Context): Symbol = tpe.typeSymbol
   }
 
   def ConstantTypeDeco(x: ConstantType): Type.ConstantTypeAPI = new Type.ConstantTypeAPI {

library/src/scala/tasty/reflect/FlagsOps.scala

@@ -101,6 +101,21 @@ trait FlagsOps extends Core {
 
     /** Is this symbol a parameter accessor */
     def ParamAccessor: Flags
+
+    /** Is this symbol an enum */
+    def Enum: Flags
+
+    /** Is this symbol a module class */
+    def ModuleClass: Flags
+
+    /** Is this symbol labeled private[this] */
+    def PrivateLocal: Flags
+
+    /** Is this symbol a package */
+    def Package: Flags
+
+    /** Is this symbol an implementation class of a Scala2 trait */
+    def ImplClass: Flags
   }
 
 }

library/src/scala/tasty/reflect/PatternOps.scala

@@ -14,6 +14,8 @@ trait PatternOps extends Core {
     def pos(implicit ctx: Context): Position
 
     def tpe(implicit ctx: Context): Type
+
+    def symbol(implicit ctx: Context): Symbol
   }
   implicit def PatternDeco(pattern: Pattern): PatternAPI
 

library/src/scala/tasty/reflect/Printers.scala

@@ -129,6 +129,11 @@ trait Printers
       if (flags.is(Flags.StableRealizable)) flagList += "Flags.StableRealizable"
       if (flags.is(Flags.Param)) flagList += "Flags.Param"
       if (flags.is(Flags.ParamAccessor)) flagList += "Flags.ParamAccessor"
+      if (flags.is(Flags.Enum)) flagList += "Flags.Enum"
+      if (flags.is(Flags.ModuleClass)) flagList += "Flags.ModuleClass"
+      if (flags.is(Flags.PrivateLocal)) flagList += "Flags.PrivateLocal"
+      if (flags.is(Flags.Package)) flagList += "Flags.Package"
+      if (flags.is(Flags.ImplClass)) flagList += "Flags.ImplClass"
       flagList.result().mkString(" | ")
     }
 
@@ -504,6 +509,11 @@ trait Printers
       if (flags.is(Flags.StableRealizable)) flagList += "stableRealizable"
       if (flags.is(Flags.Param)) flagList += "param"
       if (flags.is(Flags.ParamAccessor)) flagList += "paramAccessor"
+      if (flags.is(Flags.Enum)) flagList += "enum"
+      if (flags.is(Flags.ModuleClass)) flagList += "moduleClass"
+      if (flags.is(Flags.PrivateLocal)) flagList += "private[this]"
+      if (flags.is(Flags.Package)) flagList += "package"
+      if (flags.is(Flags.ImplClass)) flagList += "implClass"
       flagList.result().mkString("/*", " ", "*/")
     }
 

library/src/scala/tasty/reflect/SymbolOps.scala

@@ -14,6 +14,14 @@ trait SymbolOps extends Core {
     /** Flags of this symbol */
     def flags(implicit ctx: Context): Flags
 
+    def isLocalDummy(implicit ctx: Context): Boolean
+    def isRefinementClass(implicit ctx: Context): Boolean
+    def isAliasType(implicit ctx: Context): Boolean
+    def isAnonymousClass(implicit ctx: Context): Boolean
+    def isAnonymousFunction(implicit ctx: Context): Boolean
+    def isAbstractType(implicit ctx: Context): Boolean
+    def isClassConstructor(implicit ctx: Context): Boolean
+
     /** This symbol is private within the resulting type. */
     def privateWithin(implicit ctx: Context): Option[Type]
 
@@ -26,6 +34,7 @@ trait SymbolOps extends Core {
     /** The full name of this symbol up to the root package. */
     def fullName(implicit ctx: Context): String
 
+    /** The position of this symbol */
     def pos(implicit ctx: Context): Position
 
     def localContext(implicit ctx: Context): Context
@@ -111,6 +120,7 @@ trait SymbolOps extends Core {
     /** The symbol of the companion module */
     def companionModule(implicit ctx: Context): Option[ValSymbol]
 
+    def moduleClass(implicit ctx: Context): Option[Symbol]
   }
   implicit def ClassSymbolDeco(symbol: ClassSymbol): ClassSymbolAPI
 
@@ -170,7 +180,7 @@ trait SymbolOps extends Core {
   }
 
   trait BindSymbolAPI {
-    /** Bind pattern of this defintion. */
+    /** Bind pattern of this definition. */
     def tree(implicit ctx: Context): Bind
   }
   implicit def BindSymbolDeco(symbol: BindSymbol): BindSymbolAPI

library/src/scala/tasty/reflect/TypeOrBoundsOps.scala

@@ -54,6 +54,7 @@ trait TypeOrBoundsOps extends Core {
     def <:<(other: Type)(implicit ctx: Context): Boolean
     def widen(implicit ctx: Context): Type
     def classSymbol(implicit ctx: Context): Option[ClassSymbol]
+    def typeSymbol(implicit ctx: Context): Symbol
   }
 
   val IsType: IsTypeModule

project/Build.scala

@@ -378,6 +378,7 @@ object Build {
     baseDirectory in (Compile, run) := baseDirectory.value / "..",
     baseDirectory in Test := baseDirectory.value / "..",
     unmanagedSourceDirectories in Test += baseDirectory.value / "input" / "src" / "main" / "scala",
+    scalacOptions in Test ++= Seq("-Yno-inline"),
     libraryDependencies ++= List(
       ("org.scalameta" %% "semanticdb" % "4.0.0").withDottyCompat(scalaVersion.value),
       "com.novocode" % "junit-interface" % "0.11",

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

@@ -8,4 +8,20 @@ class Access {
   protected[this] def m5 = ???
   protected[example] def m6 = ???
   def m7 = ???
+
+  private val mv1 = ???
+  private[this] val mv2 = ???
+  private[Access] val mv3 = ???
+  protected val mv4 = ???
+  protected[this] val mv5 = ???
+  protected[example] val mv6 = ???
+  val mv7 = ???
+
+  private var mr1 = ???
+  private[this] var mr2 = ???
+  private[Access] var mr3 = ???
+  protected var mr4 = ???
+  protected[this] var mr5 = ???
+  protected[example] var mr6 = ???
+  var mr7 = ???
 }

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

@@ -1,7 +1,6 @@
 package example
 
-import scala.language.existentials
-import scala.language.higherKinds
+import scala.language.{existentials, higherKinds=>h}
 import scala.language.reflectiveCalls
 
 class AdvC[T] {

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

@@ -15,4 +15,4 @@ class Anonymous {
 
   trait Foo
   var x = new Foo {}
-}
+}

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

@@ -0,0 +1,9 @@
+package example
+
+class TestApply {
+  object Foo {
+    def apply(x: Int) : Int = x
+  }
+  val z = Foo(1)
+  val y = Foo.apply(1)
+}

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

@@ -0,0 +1,7 @@
+package example
+
+class BinaryOp {
+  val y = 1 #:: 2 #:: Stream.empty[Int]
+  val x = 1 :: 2 :: 3 :: Nil
+  val z = 1 + 2
+}

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

@@ -0,0 +1,12 @@
+package example
+
+class CaseTest {
+  def foo (x: Option[Int]) : Int =
+  x match {
+    case y @ Some(x) => x
+    case None => 0
+  }
+}
+
+case class CaseClass(x: Int)
+case object CaseObject

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

@@ -1,14 +1,26 @@
 package example
 
+class CDep[X]
+class CDependenat[X /* This is a comment /* and a nested comment
+*/*/](var x1: CDep[X])
+class CVarArg(var x1 : Int)
+
+
+class CDefaultWrapper {
+  val glob = 3
+  class Cdefault(val x1: Int = glob)
+}
 class C1(val x1: Int) extends AnyVal
 
 class C2(val x2: Int) extends AnyVal
 object C2
 
-case class C3(x: Int)
+case class C3[Y     ](x: Int)
 
 case class C4(x: Int)
-object C4
+object C4 {
+  val foo: Int = 4
+}
 
 object M {
   implicit class C5(x: Int)
@@ -30,4 +42,15 @@ object N {
     val local = 2
     local + 2
   }
-}
+
+  val otheranon = {
+    var a = 1
+    a
+  }
+
+  val lastanon = {
+    val a = new CVarArg(4)
+    a.x1 = 8
+    a.x1
+  }
+}

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

@@ -0,0 +1,9 @@
+package example
+
+class DepTemp {
+
+}
+
+abstract class DepAdvD[CC[X[C] <: B], X[Z], C] extends DepTemp {
+val foo: List[Option[Option[X[C]]]]
+}

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

@@ -0,0 +1,9 @@
+package example
+
+class PredefsDotty {
+  locally {
+    val x: Int => Int = _ => ???
+  }
+  assert(true)
+  assert(false, "bonjour")
+}

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

@@ -14,8 +14,9 @@ class Example {
       x +
       y
     )
+  var b = 4
 }
 
-class ExampleInit() {
+class ExampleInit {
 
 }

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

@@ -1,11 +1,10 @@
-package example
 
-package object p {
+package object example {
   private lazy val x = 1
-  protected implicit var y: Int = 2
+  /*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) {
+  abstract class Cex[+T, -U, V](x: T, y: U, z: V) {
     def this() = this(???, ???, ???)
     def w: Int
   }
@@ -20,5 +19,5 @@ package object p {
   class S[@specialized T]
   val List(xs1) = ???
   ??? match { case List(xs2) => ??? }
-  ??? match { case _: List[t] => ??? }
+  ??? match { case _: List[t] => ??? }*/
 }

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

@@ -0,0 +1,8 @@
+package example
+
+class IgnoredTest {
+  val _ = 2
+  def foo(x: Int): Unit = {
+    val _ = x
+  }
+}

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

@@ -1,5 +1,20 @@
+/*
+// This text is deactivated for now as macro annotations require to enable
+// macro paradise
+
 package example
 
-//@MacroAnnotation
+
+import scala.annotation.StaticAnnotation
+import scala.annotation.compileTimeOnly
+import scala.language.experimental.macros
+
+@compileTimeOnly("enable macro paradise to expand macro annotations")
+class MacroAnnotation extends StaticAnnotation {
+  def macroTransform(annottees: Any*): Any = ???
+}
+
+@MacroAnnotation
 class MacroAnnotations
 object MacroAnnotations
+*/

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

@@ -0,0 +1,5 @@
+package example
+
+class Multiple {
+  def m19(x: Int)(z: Int = 3) = ???
+}