better support paths and pattern defs

Author: bishabosha

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

@@ -15,6 +15,8 @@ import util.{SourceFile, SourcePosition}
 import collection.mutable
 import java.nio.file.Paths
 
+import PartialFunction.condOpt
+
 import ast.untpd.given
 import NameOps.given
 
@@ -72,36 +74,40 @@ class ExtractSemanticDB extends Phase with
       !sym.exists
       || sym.isLocalDummy
       || sym.is(Synthetic)
-      || sym.isConstructor && (sym.owner.is(ModuleClass) || !sym.isGlobal)
       || sym.isSetter
-      || excludeDefStrict(sym)
+      || excludeDefOrUse(sym)
 
-    private def excludeDefStrict(sym: Symbol)(given Context): Boolean =
+    private def excludeDefOrUse(sym: Symbol)(given Context): Boolean =
       sym.name.is(NameKinds.DefaultGetterName)
-      || excludeSymbolStrict(sym)
+      || sym.isConstructor && (sym.owner.is(ModuleClass) || !sym.isGlobal)
+      || excludeSymbol(sym)
 
-    private def excludeSymbolStrict(sym: Symbol)(given Context): Boolean =
+    private def excludeSymbol(sym: Symbol)(given Context): Boolean =
       sym.name.isWildcard
-      || sym.isAnonymousFunction
+      || excludeQual(sym)
+
+    private def excludeQual(sym: Symbol)(given Context): Boolean =
+      sym.isAnonymousFunction
       || sym.isAnonymousModuleVal
       || sym.name.isEmptyNumbered
 
     private def excludeChildren(sym: Symbol)(given Context): Boolean =
       sym.isAllOf(HigherKinded | Param)
 
     /** Uses of this symbol where the reference has given span should be excluded from semanticdb */
-    private def excludeUseStrict(sym: Symbol, span: Span)(given Context): Boolean =
-      excludeDefStrict(sym)
-      || excludeDef(sym) && span.zeroLength
+    private def excludeUse(qualifier: Option[Symbol], sym: Symbol)(given Context): Boolean =
+      excludeDefOrUse(sym)
+      || sym == defn.Any_typeCast
+      || qualifier.exists(excludeQual)
 
     override def traverse(tree: Tree)(given Context): Unit =
 
       inline def traverseCtorParamTpt(ctorSym: Symbol, tpt: Tree): Unit =
         val tptSym = tpt.symbol
         if tptSym.owner == ctorSym
           val found = matchingMemberType(tptSym, ctorSym.owner)
-          if !excludeUseStrict(found, tpt.span) && tpt.span.hasLength
-            registerUse(found, tpt.span)
+          if tpt.span.hasLength
+            registerUseGuarded(None, found, tpt.span)
         else
           traverse(tpt)
 
@@ -129,8 +135,8 @@ class ExtractSemanticDB extends Phase with
             registerDefinition(tree.symbol, tree.adjustedNameSpan, symbolKinds(tree))
             val privateWithin = tree.symbol.privateWithin
             if privateWithin.exists
-              registerUse(privateWithin, spanOfSymbol(privateWithin, tree.span))
-          else if !excludeSymbolStrict(tree.symbol)
+              registerUseGuarded(None, privateWithin, spanOfSymbol(privateWithin, tree.span))
+          else if !excludeSymbol(tree.symbol)
             registerSymbol(tree.symbol, symbolName(tree.symbol), symbolKinds(tree))
           tree match
           case tree: ValDef
@@ -178,7 +184,8 @@ class ExtractSemanticDB extends Phase with
           else
             tree.body.foreach(traverse)
         case tree: Assign =>
-          if !excludeUseStrict(tree.lhs.symbol, tree.lhs.span)
+          val qualSym = condOpt(tree.lhs) { case Select(qual, _) if qual.symbol.exists => qual.symbol }
+          if !excludeUse(qualSym, tree.lhs.symbol)
             val lhs = tree.lhs.symbol
             val setter = lhs.matchingSetter.orElse(lhs)
             tree.lhs match
@@ -189,24 +196,22 @@ class ExtractSemanticDB extends Phase with
         case tree: Ident =>
           if tree.name != nme.WILDCARD then
             val sym = tree.symbol.adjustIfCtorTyparam
-            if !excludeUseStrict(sym, tree.span) then
-              registerUse(sym, tree.span)
+            registerUseGuarded(None, sym, tree.span)
         case tree: Select =>
           val qualSpan = tree.qualifier.span
           val sym = tree.symbol.adjustIfCtorTyparam
-          if !excludeUseStrict(sym, tree.span) then
-            registerUse(sym, adjustSpanToName(tree.span, qualSpan, tree.name))
+          registerUseGuarded(tree.qualifier.symbol.ifExists, sym, adjustSpanToName(tree.span, qualSpan, tree.name))
           if qualSpan.exists && qualSpan.hasLength then
-            traverseChildren(tree)
+            traverse(tree.qualifier)
         case tree: Import =>
           if tree.span.exists && tree.span.hasLength then
             for sel <- tree.selectors do
               val imported = sel.imported.name
               if imported != nme.WILDCARD then
                 for alt <- tree.expr.tpe.member(imported).alternatives do
-                  registerUse(alt.symbol, sel.imported.span)
+                  registerUseGuarded(None, alt.symbol, sel.imported.span)
                   if (alt.symbol.companionClass.exists)
-                    registerUse(alt.symbol.companionClass, sel.imported.span)
+                    registerUseGuarded(None, alt.symbol.companionClass, sel.imported.span)
             traverseChildren(tree)
         case tree: Inlined =>
           traverse(tree.call)
@@ -397,9 +402,12 @@ class ExtractSemanticDB extends Phase with
         occurrences += occ
         generated += occ
 
+    private def registerUseGuarded(qualSym: Option[Symbol], sym: Symbol, span: Span)(given Context) =
+      if !excludeUse(qualSym, sym) then
+        registerUse(sym, span)
+
     private def registerUse(sym: Symbol, span: Span)(given Context) =
-      if !excludeUseStrict(sym, span) then
-        registerOccurrence(symbolName(sym), span, SymbolOccurrence.Role.REFERENCE)
+      registerOccurrence(symbolName(sym), span, SymbolOccurrence.Role.REFERENCE)
 
     private def registerDefinition(sym: Symbol, span: Span, symkinds: Set[SymbolKind])(given Context) =
       val symbol = symbolName(sym)
@@ -496,7 +504,7 @@ class ExtractSemanticDB extends Phase with
         vparams <- vparamss
         vparam  <- vparams
       do
-        if !excludeSymbolStrict(vparam.symbol)
+        if !excludeSymbol(vparam.symbol)
           val symkinds =
             getters.get(vparam.name).fold(SymbolKind.emptySet)(getter =>
               if getter.mods.is(Mutable) then SymbolKind.VarSet else SymbolKind.ValSet)

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

@@ -91,6 +91,8 @@ object Scala3 with
 
   given SymbolOps: (sym: Symbol) with
 
+    def ifExists(given Context): Option[Symbol] = if sym.exists then Some(sym) else None
+
     def isScala2PackageObject(given Context): Boolean =
       sym.name.isScala2PackageObjectName && sym.owner.is(Package) && sym.is(Module)
 

tests/semanticdb/expect/Annotations.expect.scala

@@ -4,33 +4,33 @@ import com.javacp.annot._
 import scala.annotation.meta._
 import scala.language/*->scalaShadowing::language.*/.experimental/*->scalaShadowing::language.experimental.*/.macros/*->scalaShadowing::language.experimental.macros.*/
 
-@ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*/
-class Annotations/*<-annot::Annotations#*/[@TypeParameterAnnotation/*->com::javacp::annot::TypeParameterAnnotation#*/ T/*<-annot::Annotations#[T]*/](@ParameterAnnotation/*->com::javacp::annot::ParameterAnnotation#*/ x/*<-annot::Annotations#x.*/: T/*->annot::Annotations#[T]*/) { self/*<-local0*/: AnyRef/*->scala::AnyRef#*/ =>
-  @FieldAnnotation/*->com::javacp::annot::FieldAnnotation#*/
+@ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*//*->com::javacp::annot::ClassAnnotation#`<init>`().*/
+class Annotations/*<-annot::Annotations#*/[@TypeParameterAnnotation/*->com::javacp::annot::TypeParameterAnnotation#*//*->com::javacp::annot::TypeParameterAnnotation#`<init>`().*/ T/*<-annot::Annotations#[T]*/](@ParameterAnnotation/*->com::javacp::annot::ParameterAnnotation#*//*->com::javacp::annot::ParameterAnnotation#`<init>`().*/ x/*<-annot::Annotations#x.*/: T/*->annot::Annotations#[T]*/) { self/*<-local0*/: AnyRef/*->scala::AnyRef#*/ =>
+  @FieldAnnotation/*->com::javacp::annot::FieldAnnotation#*//*->com::javacp::annot::FieldAnnotation#`<init>`().*/
   val field/*<-annot::Annotations#field.*/ = 42
 
-  @MethodAnnotation/*->com::javacp::annot::MethodAnnotation#*/
+  @MethodAnnotation/*->com::javacp::annot::MethodAnnotation#*//*->com::javacp::annot::MethodAnnotation#`<init>`().*/
   def method/*<-annot::Annotations#method().*/ = {
-    @LocalAnnotation/*->com::javacp::annot::LocalAnnotation#*/
+    @LocalAnnotation/*->com::javacp::annot::LocalAnnotation#*//*->com::javacp::annot::LocalAnnotation#`<init>`().*/
     val local/*<-local1*/ = 42
     local/*->local1*/
   }
-  @TypeAnnotation/*->com::javacp::annot::TypeAnnotation#*/
+  @TypeAnnotation/*->com::javacp::annot::TypeAnnotation#*//*->com::javacp::annot::TypeAnnotation#`<init>`().*/
   type S/*<-annot::Annotations#S#*/
 }
 
-class B/*<-annot::B#*/ @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*/()(x/*<-annot::B#x.*/: Int/*->scala::Int#*/) {
-  @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*/
+class B/*<-annot::B#*/ @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*//*->com::javacp::annot::ConstructorAnnotation#`<init>`().*/()(x/*<-annot::B#x.*/: Int/*->scala::Int#*/) {
+  @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*//*->com::javacp::annot::ConstructorAnnotation#`<init>`().*/
   def this()/*<-annot::B#`<init>`(+1).*/ = this(42)
 }
 
-@ObjectAnnotation/*->com::javacp::annot::ObjectAnnotation#*/
+@ObjectAnnotation/*->com::javacp::annot::ObjectAnnotation#*//*->com::javacp::annot::ObjectAnnotation#`<init>`().*/
 object M/*<-annot::M.*/ {
-  @MacroAnnotation/*->com::javacp::annot::MacroAnnotation#*/
+  @MacroAnnotation/*->com::javacp::annot::MacroAnnotation#*//*->com::javacp::annot::MacroAnnotation#`<init>`().*/
   def m/*<-annot::M.m().*/[TT/*<-annot::M.m().[TT]*/]: Int/*->scala::Int#*//*->scala::Predef.`???`().*/ = macro ???
 }
 
-@TraitAnnotation/*->com::javacp::annot::TraitAnnotation#*/
+@TraitAnnotation/*->com::javacp::annot::TraitAnnotation#*//*->com::javacp::annot::TraitAnnotation#`<init>`().*/
 trait T/*<-annot::T#*/
 
 object Alias/*<-annot::Alias.*/ {

tests/semanticdb/expect/Enums.expect.scala

@@ -47,12 +47,12 @@ object Enums/*<-_empty_::Enums.*/ with
     case Refl/*<-_empty_::Enums.`<:<`.Refl#*/[C/*<-_empty_::Enums.`<:<`.Refl#[C]*/]() extends (C/*->_empty_::Enums.`<:<`.Refl#[C]*/ <:</*->_empty_::Enums.`<:<`#*/ C/*->_empty_::Enums.`<:<`.Refl#[C]*/)
 
   object <:</*<-_empty_::Enums.`<:<`.*/ with
-    given [T]: (T/*<-_empty_::Enums.`<:<`.given_T().*//*<-_empty_::Enums.`<:<`.given_T().[T]*//*->_empty_::Enums.`<:<`.given_T().[T]*/ <:</*->_empty_::Enums.`<:<`#*/ T/*->_empty_::Enums.`<:<`.given_T().[T]*/) = Refl/*->_empty_::Enums.`<:<`.Refl.*/()
+    given [T]: (T/*<-_empty_::Enums.`<:<`.given_T().*//*<-_empty_::Enums.`<:<`.given_T().[T]*//*->_empty_::Enums.`<:<`.given_T().[T]*/ <:</*->_empty_::Enums.`<:<`#*/ T/*->_empty_::Enums.`<:<`.given_T().[T]*/) = Refl/*->_empty_::Enums.`<:<`.Refl.*//*->_empty_::Enums.`<:<`.Refl.apply().*/()
 
   def [A, B]/*<-_empty_::Enums.unwrap().*//*<-_empty_::Enums.unwrap().[A]*//*<-_empty_::Enums.unwrap().[B]*/(opt/*<-_empty_::Enums.unwrap().(opt)*/: Option/*->scala::Option#*/[A/*->_empty_::Enums.unwrap().[A]*/]) unwrap(given ev/*<-_empty_::Enums.unwrap().(ev)*/: A/*->_empty_::Enums.unwrap().[A]*/ <:</*->_empty_::Enums.`<:<`#*/ Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]): Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/] = ev/*->_empty_::Enums.unwrap().(ev)*/ match
-    case Refl/*->_empty_::Enums.`<:<`.Refl.*/() => opt/*->_empty_::Enums.unwrap().(opt)*/.flatMap/*->scala::Option#flatMap().*/(identity/*->scala::Predef.identity().*/[Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]])
+    case Refl/*->_empty_::Enums.`<:<`.Refl.*//*->_empty_::Enums.`<:<`.Refl.unapply().*/() => opt/*->_empty_::Enums.unwrap().(opt)*/.flatMap/*->scala::Option#flatMap().*/(identity/*->scala::Predef.identity().*//*->local0*/[Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]])
 
-  val some1/*<-_empty_::Enums.some1.*/ = /*->_empty_::Enums.unwrap().*/Some/*->scala::Some.*/(Some/*->scala::Some.*/(1))/*->_empty_::Enums.`<:<`.given_T().*/.unwrap
+  val some1/*<-_empty_::Enums.some1.*/ = /*->_empty_::Enums.unwrap().*/Some/*->scala::Some.*//*->scala::Some.apply().*/(Some/*->scala::Some.*//*->scala::Some.apply().*/(1))/*->_empty_::Enums.`<:<`.given_T().*/.unwrap
 
   enum Planet/*<-_empty_::Enums.Planet#*/(mass/*<-_empty_::Enums.Planet#mass.*/: Double/*->scala::Double#*/, radius/*<-_empty_::Enums.Planet#radius.*/: Double/*->scala::Double#*/) extends java.lang.Enum/*->java::lang::Enum#*/[Planet/*->_empty_::Enums.Planet#*/]/*->java::lang::Enum#`<init>`().*/ with
     private final val G/*<-_empty_::Enums.Planet#G.*/ = 6.67300E-11

tests/semanticdb/expect/EtaExpansion.expect.scala

@@ -1,6 +1,6 @@
 package example
 
 class EtaExpansion/*<-example::EtaExpansion#*/ {
-  Some/*->scala::Some.*/(1).map/*->scala::Option#map().*/(identity/*->scala::Predef.identity().*/)
+  Some/*->scala::Some.*//*->scala::Some.apply().*/(1).map/*->scala::Option#map().*/(identity/*->scala::Predef.identity().*//*->local0*/)
   List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1).foldLeft/*->scala::collection::LinearSeqOps#foldLeft().*/("")(_ +/*->java::lang::String#`+`().*/ _)
 }

tests/semanticdb/expect/ForComprehension.expect.scala

@@ -3,38 +3,38 @@ package example
 class ForComprehension/*<-example::ForComprehension#*/ {
   for {
     a/*<-local0*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/
-    b/*<-local1*//*->local1*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::IterableOps#withFilter().*/
+    b/*<-local1*//*->scala::Tuple2.apply().*//*->local1*//*->local3*//*->scala::Tuple2.unapply().*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::IterableOps#withFilter().*/
     if b/*->local1*/ >/*->scala::Int#`>`(+3).*/ 1/*->scala::collection::WithFilter#map().*/
     c/*<-local2*//*->local2*/ = a/*->local0*/ +/*->scala::Int#`+`(+4).*/ b/*->local1*//*->scala::collection::immutable::List#map().*/
-  } yield (a/*->local0*/, b/*->local1*/, c/*->local2*/)
+  } yield (/*->scala::Tuple3.apply().*/a/*->local0*/, b/*->local1*/, c/*->local2*/)
   for {
     a/*<-local4*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/
     b/*<-local5*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(a/*->local4*/)/*->scala::collection::IterableOps#withFilter().*/
     if (
-      a/*->local4*/,
+      /*->scala::Tuple2.apply().*/a/*->local4*/,
       b/*->local5*/
-    ) ==/*->scala::Any#`==`().*/ (1, 2)/*->scala::collection::WithFilter#flatMap().*/
-    (
-      c/*<-local7*/,
+    ) ==/*->scala::Any#`==`().*/ (/*->scala::Tuple2.apply().*/1, 2)/*->scala::collection::WithFilter#flatMap().*/
+    /*->local6*//*->scala::Tuple2.unapply().*/(
+      /*->scala::Tuple2.unapply().*/c/*<-local7*/,
       d/*<-local8*/
-    ) <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/((a/*->local4*/, b/*->local5*/))/*->scala::collection::WithFilter#withFilter().*//*->scala::collection::IterableOps#withFilter().*/
+    ) <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/((/*->scala::Tuple2.apply().*/a/*->local4*/, b/*->local5*/))/*->scala::collection::WithFilter#withFilter().*//*->scala::collection::IterableOps#withFilter().*/
     if (
-      a/*->local4*/,
+      /*->scala::Tuple4.apply().*/a/*->local4*/,
       b/*->local5*/,
       c/*->local7*/,
       d/*->local8*/
-    ) ==/*->scala::Any#`==`().*/ (1, 2, 3, 4)/*->scala::collection::WithFilter#map().*/
-    e/*<-local9*//*->local9*/ = (
-      a/*->local4*/,
+    ) ==/*->scala::Any#`==`().*/ (/*->scala::Tuple4.apply().*/1, 2, 3, 4)/*->scala::collection::WithFilter#map().*/
+    e/*<-local9*//*->scala::Tuple2.apply().*//*->local9*/ = (
+      /*->scala::Tuple4.apply().*/a/*->local4*/,
       b/*->local5*/,
       c/*->local7*/,
       d/*->local8*/
     )/*->scala::collection::IterableOps#withFilter().*/
-    if e/*->local9*/ ==/*->scala::Any#`==`().*/ (1, 2, 3, 4)/*->scala::collection::WithFilter#flatMap().*/
+    if e/*->local9*/ ==/*->scala::Any#`==`().*/ (/*->scala::Tuple4.apply().*/1, 2, 3, 4)/*->scala::collection::WithFilter#flatMap().*/
     f/*<-local10*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(e/*->local9*/)/*->scala::collection::immutable::List#map().*/
   } yield {
     (
-      a/*->local4*/,
+      /*->scala::Tuple6.apply().*/a/*->local4*/,
       b/*->local5*/,
       c/*->local7*/,
       d/*->local8*/,

tests/semanticdb/expect/Givens.expect.scala

@@ -4,11 +4,11 @@ package b
 object Givens/*<-a::b::Givens.*/
 
   given :[A](any: A)
-    de/*<-a::b::Givens.given_sayHello_of_A.*//*<-a::b::Givens.given_sayHello_of_A.sayHello().[A]*//*<-a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->a::b::Givens.given_sayHello_of_A.sayHello().[A]*/f sayHello/*<-a::b::Givens.given_sayHello_of_A.sayHello().*/ = s"Hello, I am $any/*->a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->scala::StringContext#s().*/"
+    de/*<-a::b::Givens.given_sayHello_of_A.*//*<-a::b::Givens.given_sayHello_of_A.sayHello().[A]*//*<-a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->a::b::Givens.given_sayHello_of_A.sayHello().[A]*/f sayHello/*<-a::b::Givens.given_sayHello_of_A.sayHello().*/ = s"/*->scala::StringContext.apply().*/Hello, I am $any/*->a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->scala::StringContext#s().*/"
 
   given :[B](any: B)
-    def /*<-a::b::Givens.given_sayGoodbye_of_B.*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*/sayGoodbye/*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().*/ = s"Goodbye, from $any/*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*->scala::StringContext#s().*/"
-    def saySoLong/*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().*/ = s"So Long, from $any/*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->scala::StringContext#s().*/"
+    def /*<-a::b::Givens.given_sayGoodbye_of_B.*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*/sayGoodbye/*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().*/ = s"/*->scala::StringContext.apply().*/Goodbye, from $any/*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*->scala::StringContext#s().*/"
+    def saySoLong/*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().*/ = s"/*->scala::StringContext.apply().*/So Long, from $any/*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->scala::StringContext#s().*/"
 
   val hello1/*<-a::b::Givens.hello1.*/ = /*->a::b::Givens.given_sayHello_of_A.sayHello().*/1.sayHello
   val goodbye1/*<-a::b::Givens.goodbye1.*/ = /*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().*/1.sayGoodbye