Use Dotty naming scheme and toString

Author: allanrenucci

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -207,7 +207,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
 
     val selfType = apiType(sym.givenSelfType)
 
-    val name = sym.fullName.stripModuleClassSuffix.mangledString
+    val name = sym.fullName.toString
 
     val tparams = sym.typeParams.map(apiTypeParameter).toArray
 
@@ -241,7 +241,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
 
     val javaPlatform = ctx.platform.asInstanceOf[JavaPlatform]
     if (sym.isStatic && defType == DefinitionType.Module && javaPlatform.hasJavaMainMethod(sym)) {
-      _mainClasses += name
+      _mainClasses += sym.fullName.stripModuleClassSuffix.toString // required for sbt to find the static main method
     }
 
     api.ClassLikeDef.of(name, acc, modifiers, anns, tparams, defType)
@@ -316,7 +316,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
       if (aIsClass == bIsClass) {
         if (aIsClass) {
           if (a.is(Module) == b.is(Module))
-            a.fullName.mangledString.compareTo(b.fullName.mangledString)
+            a.fullName.toString.compareTo(b.fullName.toString)
           else if (a.is(Module))
             -1
           else
@@ -340,10 +340,10 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
     } else if (sym.isType) {
       apiTypeMember(sym.asType)
     } else if (sym.is(Mutable, butNot = Accessor)) {
-      api.Var.of(sym.name.mangledString, apiAccess(sym), apiModifiers(sym),
+      api.Var.of(sym.name.toString, apiAccess(sym), apiModifiers(sym),
         apiAnnotations(sym).toArray, apiType(sym.info))
     } else if (sym.isStable) {
-      api.Val.of(sym.name.mangledString, apiAccess(sym), apiModifiers(sym),
+      api.Val.of(sym.name.toString, apiAccess(sym), apiModifiers(sym),
         apiAnnotations(sym).toArray, apiType(sym.info))
     } else {
       apiDef(sym.asTerm)
@@ -370,7 +370,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
           } else
             (0 until pnames.length).map(Function.const(false))
         val params = (pnames, ptypes, defaults).zipped.map((pname, ptype, isDefault) =>
-          api.MethodParameter.of(pname.mangledString, apiType(ptype),
+          api.MethodParameter.of(pname.toString, apiType(ptype),
             isDefault, api.ParameterModifier.Plain))
         api.ParameterList.of(params.toArray, mt.isImplicitMethod) :: paramLists(restpe, params.length)
       case _ =>
@@ -380,20 +380,20 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
     val tparams = sym.info match {
       case pt: TypeLambda =>
         (pt.paramNames, pt.paramInfos).zipped.map((pname, pbounds) =>
-          apiTypeParameter(pname.mangledString, 0, pbounds.lo, pbounds.hi))
+          apiTypeParameter(pname.toString, 0, pbounds.lo, pbounds.hi))
       case _ =>
         Nil
     }
     val vparamss = paramLists(sym.info)
     val retTp = sym.info.finalResultType.widenExpr
 
-    api.Def.of(sym.name.mangledString, apiAccess(sym), apiModifiers(sym),
+    api.Def.of(sym.name.toString, apiAccess(sym), apiModifiers(sym),
       apiAnnotations(sym).toArray, tparams.toArray, vparamss.toArray, apiType(retTp))
   }
 
   def apiTypeMember(sym: TypeSymbol): api.TypeMember = {
     val typeParams = Array[api.TypeParameter]()
-    val name = sym.name.mangledString
+    val name = sym.name.toString
     val access = apiAccess(sym)
     val modifiers = apiModifiers(sym)
     val as = apiAnnotations(sym)
@@ -439,7 +439,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
           sym.owner.thisType
         else
           tp.prefix
-        api.Projection.of(apiType(prefix), sym.name.mangledString)
+        api.Projection.of(apiType(prefix), sym.name.toString)
       case AppliedType(tycon, args) =>
         def processArg(arg: Type): api.Type = arg match {
           case arg @ TypeBounds(lo, hi) => // Handle wildcard parameters
@@ -463,7 +463,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
         val apiRes = apiType(tl.resType)
         api.Polymorphic.of(apiRes, apiTparams.toArray)
       case rt: RefinedType =>
-        val name = rt.refinedName.mangledString
+        val name = rt.refinedName.toString
         val parent = apiType(rt.parent)
 
         def typeRefinement(name: String, tp: TypeBounds): api.TypeMember = tp match {
@@ -536,7 +536,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
       case tp: ParamRef =>
         // TODO: Distinguishing parameters based on their names alone is not enough,
         // the binder is also needed (at least for type lambdas).
-        api.ParameterRef.of(tp.paramName.mangledString)
+        api.ParameterRef.of(tp.paramName.toString)
       case tp: LazyRef =>
         apiType(tp.ref)
       case tp: TypeVar =>
@@ -557,12 +557,12 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
 
   def apiThis(sym: Symbol): api.Singleton = {
     val pathComponents = sym.ownersIterator.takeWhile(!_.isEffectiveRoot)
-      .map(s => api.Id.of(s.name.mangledString))
+      .map(s => api.Id.of(s.name.toString))
     api.Singleton.of(api.Path.of(pathComponents.toArray.reverse ++ Array(Constants.thisPath)))
   }
 
   def apiTypeParameter(tparam: ParamInfo): api.TypeParameter =
-    apiTypeParameter(tparam.paramName.mangledString, tparam.paramVariance,
+    apiTypeParameter(tparam.paramName.toString, tparam.paramVariance,
       tparam.paramInfo.bounds.lo, tparam.paramInfo.bounds.hi)
 
   def apiTypeParameter(name: String, variance: Int, lo: Type, hi: Type): api.TypeParameter =
@@ -590,7 +590,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
         if (sym.privateWithin eq NoSymbol)
           Constants.unqualified
         else
-          api.IdQualifier.of(sym.privateWithin.fullName.mangledString)
+          api.IdQualifier.of(sym.privateWithin.fullName.toString)
       if (sym.is(Protected))
         api.Protected.of(qualifier)
       else

compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala

@@ -89,7 +89,7 @@ class ExtractDependencies extends Phase {
           case (rawClassName, usedNames) =>
             val className = rawClassName
             usedNames.defaultNames.foreach { rawUsedName =>
-              val useName = rawUsedName.stripModuleClassSuffix.mangledString
+              val useName = rawUsedName.toString
               val useScopes =
                 usedNames.scopedNames.get(rawUsedName) match {
                   case None => EnumSet.of(UseScope.Default)
@@ -179,7 +179,7 @@ class ExtractDependencies extends Phase {
 
 object ExtractDependencies {
   def classNameAsString(sym: Symbol)(implicit ctx: Context): String =
-    sym.fullName.stripModuleClassSuffix.mangledString // fullName in scalac strips module class suffix
+    sym.fullName.toString
 
   def isLocal(sym: Symbol)(implicit ctx: Context): Boolean =
     sym.ownersIterator.exists(_.isTerm)
@@ -294,7 +294,7 @@ private class ExtractDependenciesCollector(responsibleForImports: Symbol)(implic
   private class PatMatDependencyTraverser(ctx0: Context) extends ExtractTypesCollector(ctx0) {
     override protected def addDependency(symbol: Symbol)(implicit ctx: Context): Unit = {
       if (!ignoreDependency(symbol) && symbol.is(Sealed)) {
-        val encName = nonLocalEnclosingClass(ctx.owner).fullName.stripModuleClassSuffix.mangledString
+        val encName = nonLocalEnclosingClass(ctx.owner).fullName.toString
         val nameUsed = _usedNames.getOrElseUpdate(encName, new NameUsedInClass)
 
         nameUsed.defaultNames += symbol.name