Factor out NamedDefTrees from DefTrees

Author: odersky

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -40,7 +40,7 @@ class Compiler {
     List(new YCheckPositions) ::    // YCheck positions
     List(new Staging) ::            // Check PCP, heal quoted types and expand macros
     List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks
-    List(new semanticdb.ExtractSemanticDB) ::
+    List(new semanticdb.ExtractSemanticDB) :: // Extract info into .semanticdb files
     List(new PostTyper) ::          // Additional checks and cleanups after type checking
     List(new sbt.ExtractAPI) ::     // Sends a representation of the API of classes to sbt via callbacks
     List(new SetRootTree) ::        // Set the `rootTreeOrProvider` on class symbols

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -332,28 +332,17 @@ object Trees {
     def namedType: NamedType = tpe.asInstanceOf[NamedType]
   }
 
-  /** Tree defines a new symbol and carries modifiers.
-   *  The position of a MemberDef contains only the defined identifier or pattern.
-   *  The envelope of a MemberDef contains the whole definition and has its point
-   *  on the opening keyword (or the next token after that if keyword is missing).
-   */
-  abstract class MemberDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NameTree[T] with DefTree[T] {
-    type ThisTree[-T >: Untyped] <: MemberDef[T]
-
-    def rawComment: Option[Comment] = getAttachment(DocComment)
-
-    def setComment(comment: Option[Comment]): this.type = {
-      comment.map(putAttachment(DocComment, _))
-      this
-    }
+  abstract class NamedDefTree[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NameTree[T] with DefTree[T] {
+    type ThisTree[-T >: Untyped] <: NamedDefTree[T]
 
     /** The position of the name defined by this definition.
      *  This is a point position if the definition is synthetic, or a range position
      *  if the definition comes from source.
      *  It might also be that the definition does not have a position (for instance when synthesized by
      *  a calling chain from `viewExists`), in that case the return position is NoSpan.
+     *  Overridden in Bind
      */
-    def nameSpan: Span =
+     def nameSpan: Span =
       if (span.exists) {
         val point = span.point
         if (rawMods.is(Synthetic) || name.toTermName == nme.ERROR) Span(point)
@@ -378,6 +367,22 @@ object Trees {
       else span
   }
 
+  /** Tree defines a new symbol and carries modifiers.
+   *  The position of a MemberDef contains only the defined identifier or pattern.
+   *  The envelope of a MemberDef contains the whole definition and has its point
+   *  on the opening keyword (or the next token after that if keyword is missing).
+   */
+  abstract class MemberDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NamedDefTree[T] {
+    type ThisTree[-T >: Untyped] <: MemberDef[T]
+
+    def rawComment: Option[Comment] = getAttachment(DocComment)
+
+    def setComment(comment: Option[Comment]): this.type = {
+      comment.map(putAttachment(DocComment, _))
+      this
+    }
+  }
+
   /** A ValDef or DefDef tree */
   abstract class ValOrDefDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends MemberDef[T] with WithLazyField[Tree[T]] {
     type ThisTree[-T >: Untyped] <: ValOrDefDef[T]
@@ -704,10 +709,13 @@ object Trees {
 
   /** name @ body */
   case class Bind[-T >: Untyped] private[ast] (name: Name, body: Tree[T])(implicit @constructorOnly src: SourceFile)
-    extends NameTree[T] with DefTree[T] with PatternTree[T] {
+    extends NamedDefTree[T] with PatternTree[T] {
     type ThisTree[-T >: Untyped] = Bind[T]
     override def isType: Boolean = name.isTypeName
     override def isTerm: Boolean = name.isTermName
+
+    override def nameSpan: Span =
+      if span.exists then Span(span.start, span.start + name.toString.length) else span
   }
 
   /** tree_1 | ... | tree_n */
@@ -940,6 +948,7 @@ object Trees {
     type NameTree = Trees.NameTree[T]
     type RefTree = Trees.RefTree[T]
     type DefTree = Trees.DefTree[T]
+    type NamedDefTree = Trees.NamedDefTree[T]
     type MemberDef = Trees.MemberDef[T]
     type ValOrDefDef = Trees.ValOrDefDef[T]
     type LazyTree = Trees.LazyTree[T]

compiler/src/dotty/tools/dotc/interactive/Interactive.scala

@@ -67,7 +67,7 @@ object Interactive {
 
   /** Does this tree define a symbol ? */
   def isDefinition(tree: Tree): Boolean =
-    tree.isInstanceOf[DefTree with NameTree]
+    tree.isInstanceOf[NamedDefTree]
 
   /** The type of the closest enclosing tree with a type containing position `pos`. */
   def enclosingType(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): Type = {

compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala

@@ -160,7 +160,7 @@ class ExtractSemanticDB extends Phase {
 
     override def traverse(tree: Tree)(given ctx: Context): Unit =
       tree match
-        case tree: DefTree
+        case tree: NamedDefTree
         if !excludeDef(tree.symbol) && tree.span.start != tree.span.end =>
           registerOccurrence(tree.symbol, tree.span, SymbolOccurrence.Role.DEFINITION)
           traverseChildren(tree)