test throw and inlined defs

Author: bishabosha

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

@@ -72,36 +72,40 @@ class ExtractSemanticDB extends Phase:
     /** The symbol occurrences generated so far, as a set */
     private val generated = new mutable.HashSet[SymbolOccurrence]
 
-    /** Definitions of this symbol should be excluded from semanticdb */
+    /** Definitions of this symbol should be excluded from semanticdb, assumes sym exists */
     private def excludeDef(sym: Symbol)(using Context): Boolean =
-      !sym.exists
-      || sym.isLocalDummy
+      sym.isLocalDummy
       || sym.is(Synthetic)
       || sym.isSetter
       || excludeDefOrUse(sym)
 
+    /** assumes sym exists */
     private def excludeDefOrUse(sym: Symbol)(using Context): Boolean =
       sym.name.is(NameKinds.DefaultGetterName)
       || sym.isConstructor && (sym.owner.is(ModuleClass) || !sym.isGlobal)
       || excludeSymbol(sym)
 
+    /** assumes sym exists */
     private def excludeSymbol(sym: Symbol)(using Context): Boolean =
       sym.name.isWildcard
       || excludeQual(sym)
 
+    /** assumes sym exists */
     private def excludeQual(sym: Symbol)(using Context): Boolean =
       sym.isAnonymousFunction
       || sym.isAnonymousModuleVal
       || sym.name.isEmptyNumbered
 
+    /** assumes sym exists */
     private def excludeChildren(sym: Symbol)(using Context): Boolean =
       sym.isAllOf(HigherKinded | Param)
 
-    /** Uses of this symbol where the reference has given span should be excluded from semanticdb */
+    /** Uses of this symbol where the reference has given span should be excluded from semanticdb, assumes sym and qualifier exist */
     private def excludeUse(qualifier: Option[Symbol], sym: Symbol)(using Context): Boolean =
       excludeDefOrUse(sym)
       || sym.isConstructor && sym.owner.isAnnotation
       || sym == defn.Any_typeCast
+      || sym.owner == defn.OpsPackageClass
       || qualifier.exists(excludeQual)
 
     private def traverseAnnotsOfDefinition(sym: Symbol)(using Context): Unit =
@@ -112,6 +116,15 @@ class ExtractSemanticDB extends Phase:
             case tree: Typed => () // hack for inline code
             case tree        => traverse(tree)
 
+
+    // guarded entrypoints
+    private inline def excludeSymbol0(sym: Symbol)(using Context) = !sym.exists || excludeSymbol(sym)
+    private inline def excludeChildren0(sym: Symbol)(using Context) = !sym.exists || excludeChildren(sym)
+    private inline def excludeDef0(sym: Symbol)(using Context) = !sym.exists || excludeDef(sym)
+
+    /** assumes qualSym has been checked to exist already */
+    private inline def excludeUse0(qualSym: Option[Symbol], sym: Symbol)(using Context) = !sym.exists || excludeUse(qualSym, sym)
+
     override def traverse(tree: Tree)(using Context): Unit =
 
       tree match
@@ -122,7 +135,7 @@ class ExtractSemanticDB extends Phase:
 
       tree match
         case tree: PackageDef =>
-          if !excludeDef(tree.pid.symbol)
+          if !excludeDef0(tree.pid.symbol)
           && tree.pid.span.hasLength
             tree.pid match
             case tree: Select =>
@@ -133,13 +146,13 @@ class ExtractSemanticDB extends Phase:
         case tree: NamedDefTree =>
           if tree.symbol.isAllOf(ModuleValCreationFlags)
             return
-          if !excludeDef(tree.symbol)
+          if !excludeDef0(tree.symbol)
           && tree.span.hasLength
             registerDefinition(tree.symbol, tree.adjustedNameSpan, symbolKinds(tree), tree.source)
             val privateWithin = tree.symbol.privateWithin
             if privateWithin.exists
               registerUseGuarded(None, privateWithin, spanOfSymbol(privateWithin, tree.span, tree.source), tree.source)
-          else if !excludeSymbol(tree.symbol)
+          else if !excludeSymbol0(tree.symbol)
             registerSymbol(tree.symbol, symbolName(tree.symbol), symbolKinds(tree))
           tree match
           case tree: ValDef
@@ -170,11 +183,11 @@ class ExtractSemanticDB extends Phase:
             traverse(rhs)
             PatternValDef.collectPats(pat).foreach(traverse)
           case tree =>
-            if !excludeChildren(tree.symbol)
+            if !excludeChildren0(tree.symbol)
               traverseChildren(tree)
         case tree: Template =>
           val ctorSym = tree.constr.symbol
-          if !excludeDef(ctorSym)
+          if !excludeDef0(ctorSym)
             traverseAnnotsOfDefinition(ctorSym)
             registerDefinition(ctorSym, tree.constr.span, Set.empty, tree.source)
             ctorParams(tree.constr.vparamss, tree.body)
@@ -198,7 +211,7 @@ class ExtractSemanticDB extends Phase:
               case _ => traverse(arg)
         case tree: Assign =>
           val qualSym = condOpt(tree.lhs) { case Select(qual, _) if qual.symbol.exists => qual.symbol }
-          if !excludeUse(qualSym, tree.lhs.symbol)
+          if !excludeUse0(qualSym, tree.lhs.symbol)
             val lhs = tree.lhs.symbol
             val setter = lhs.matchingSetter.orElse(lhs)
             tree.lhs match
@@ -467,7 +480,7 @@ class ExtractSemanticDB extends Phase:
         generated += occ
 
     private def registerUseGuarded(qualSym: Option[Symbol], sym: Symbol, span: Span, treeSource: SourceFile)(using Context) =
-      if !excludeUse(qualSym, sym) then
+      if !excludeUse0(qualSym, sym) then
         registerUse(sym, span, treeSource)
 
     private def registerUse(sym: Symbol, span: Span, treeSource: SourceFile)(using Context): Unit =
@@ -571,7 +584,7 @@ class ExtractSemanticDB extends Phase:
         vparams <- vparamss
         vparam  <- vparams
       do
-        if !excludeSymbol(vparam.symbol)
+        if !excludeSymbol0(vparam.symbol)
           traverseAnnotsOfDefinition(vparam.symbol)
           val symkinds =
             getters.get(vparam.name).fold(SymbolKind.emptySet)(getter =>

tests/semanticdb/expect/inlineconsume.expect.scala

@@ -0,0 +1,6 @@
+package inlineconsume
+
+import inlinedefs.FakePredef/*->inlinedefs::FakePredef.*/.assert/*->inlinedefs::FakePredef.assert().*/
+
+class Foo/*<-inlineconsume::Foo#*/:
+  def test/*<-inlineconsume::Foo#test().*/ = assert/*->inlinedefs::FakePredef.assert().*/(3 >/*->scala::Int#`>`(+3).*/ 2)

tests/semanticdb/expect/inlineconsume.scala

@@ -0,0 +1,6 @@
+package inlineconsume
+
+import inlinedefs.FakePredef.assert
+
+class Foo:
+  def test = assert(3 > 2)

tests/semanticdb/expect/inlinedefs.expect.scala

@@ -0,0 +1,19 @@
+package inlinedefs
+
+object FakePredef/*<-inlinedefs::FakePredef.*/:
+
+  def assertFail/*<-inlinedefs::FakePredef.assertFail().*/(): Nothing/*->scala::Nothing#*/ = throw new java.lang.AssertionError/*->java::lang::AssertionError#*//*->java::lang::AssertionError#`<init>`(+2).*/("assertion failed")
+
+  /** Super long padded documentation
+   *  Lorem ipsum dolor sit amet, consectetur adipiscing elit,
+   *  sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+   *  Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris
+   *  nisi ut aliquip ex ea commodo consequat.
+   *  Duis aute irure dolor in reprehenderit in voluptate velit esse cillum
+   *  dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident,
+   *  sunt in culpa qui officia deserunt mollit anim id est laborum.
+   */
+  transparent inline final def assert/*<-inlinedefs::FakePredef.assert().*/(inline assertion/*<-inlinedefs::FakePredef.assert().(assertion)*/: Boolean/*->scala::Boolean#*/): Unit/*->scala::Unit#*/ = {
+    if (!assertion/*->inlinedefs::FakePredef.assert().(assertion)*//*->scala::Boolean#`unary_!`().*/)
+      assertFail/*->inlinedefs::FakePredef.assertFail().*/()
+  }

tests/semanticdb/expect/inlinedefs.scala

@@ -0,0 +1,19 @@
+package inlinedefs
+
+object FakePredef:
+
+  def assertFail(): Nothing = throw new java.lang.AssertionError("assertion failed")
+
+  /** Super long padded documentation
+   *  Lorem ipsum dolor sit amet, consectetur adipiscing elit,
+   *  sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+   *  Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris
+   *  nisi ut aliquip ex ea commodo consequat.
+   *  Duis aute irure dolor in reprehenderit in voluptate velit esse cillum
+   *  dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident,
+   *  sunt in culpa qui officia deserunt mollit anim id est laborum.
+   */
+  transparent inline final def assert(inline assertion: Boolean): Unit = {
+    if (!assertion)
+      assertFail()
+  }

tests/semanticdb/metac.expect

@@ -2999,6 +2999,67 @@ Occurrences:
 [2:0..2:0): <- example/FilenameWithSpaces#`<init>`().
 [2:6..2:24): FilenameWithSpaces <- example/FilenameWithSpaces#
 
+expect/inlineconsume.scala
+--------------------------
+
+Summary:
+Schema => SemanticDB v4
+Uri => inlineconsume.scala
+Text => empty
+Language => Scala
+Symbols => 3 entries
+Occurrences => 9 entries
+
+Symbols:
+inlineconsume/Foo# => class Foo
+inlineconsume/Foo#`<init>`(). => primary ctor <init>
+inlineconsume/Foo#test(). => method test
+
+Occurrences:
+[0:8..0:21): inlineconsume <- inlineconsume/
+[2:7..2:17): inlinedefs -> inlinedefs/
+[2:18..2:28): FakePredef -> inlinedefs/FakePredef.
+[2:29..2:35): assert -> inlinedefs/FakePredef.assert().
+[4:6..4:9): Foo <- inlineconsume/Foo#
+[5:2..5:2): <- inlineconsume/Foo#`<init>`().
+[5:6..5:10): test <- inlineconsume/Foo#test().
+[5:13..5:19): assert -> inlinedefs/FakePredef.assert().
+[5:22..5:23): > -> scala/Int#`>`(+3).
+
+expect/inlinedefs.scala
+-----------------------
+
+Summary:
+Schema => SemanticDB v4
+Uri => inlinedefs.scala
+Text => empty
+Language => Scala
+Symbols => 4 entries
+Occurrences => 15 entries
+
+Symbols:
+inlinedefs/FakePredef. => final object FakePredef
+inlinedefs/FakePredef.assert(). => final macro assert
+inlinedefs/FakePredef.assert().(assertion) => param assertion
+inlinedefs/FakePredef.assertFail(). => method assertFail
+
+Occurrences:
+[0:8..0:18): inlinedefs <- inlinedefs/
+[2:7..2:17): FakePredef <- inlinedefs/FakePredef.
+[4:6..4:16): assertFail <- inlinedefs/FakePredef.assertFail().
+[4:20..4:27): Nothing -> scala/Nothing#
+[4:40..4:44): java -> java/
+[4:45..4:49): lang -> java/lang/
+[4:50..4:64): AssertionError -> java/lang/AssertionError#
+[4:64..4:64): -> java/lang/AssertionError#`<init>`(+2).
+[15:31..15:37): assert <- inlinedefs/FakePredef.assert().
+[15:45..15:54): assertion <- inlinedefs/FakePredef.assert().(assertion)
+[15:56..15:63): Boolean -> scala/Boolean#
+[15:66..15:70): Unit -> scala/Unit#
+[16:9..16:18): assertion -> inlinedefs/FakePredef.assert().(assertion)
+[16:18..16:18): -> scala/Boolean#`unary_!`().
+[17:6..17:16): assertFail -> inlinedefs/FakePredef.assertFail().
+
 expect/local-file.scala
 -----------------------