Use NoSymbol instead of Options

Author: nicolasstucki

community-build/community-projects/shapeless

@@ -1532,9 +1532,9 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def Symbol_fields(self: Symbol)(given Context): List[Symbol] =
     self.unforcedDecls.filter(isField)
 
-  def Symbol_field(self: Symbol)(name: String)(given Context): Option[Symbol] = {
+  def Symbol_field(self: Symbol)(name: String)(given Context): Symbol = {
     val sym = self.unforcedDecls.find(sym => sym.name == name.toTermName)
-    if (sym.exists && isField(sym)) Some(sym) else None
+    if (isField(sym)) sym else core.Symbols.NoSymbol
   }
 
   def Symbol_classMethod(self: Symbol)(name: String)(given Context): List[DefDefSymbol] =
@@ -1568,11 +1568,6 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
       case sym if sym.is(Flags.CaseAccessor) => sym.asTerm
     }
 
-  def Symbol_companionModule(self: Symbol)(given Context): Option[ValDefSymbol] = {
-    val sym = self.companionModule
-    if (sym.exists) Some(sym.asTerm) else None
-  }
-
   private def isField(sym: Symbol)(given Context): Boolean = sym.isTerm && !sym.is(Flags.Method)
 
   def Symbol_of(fullName: String)(given ctx: Context): ClassDefSymbol = ctx.requiredClass(fullName)
@@ -1607,15 +1602,11 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def isValDefSymbol(symbol: Symbol)(given Context): Boolean =
     symbol.isTerm && !symbol.is(core.Flags.Method) && !symbol.is(core.Flags.Case)
 
-  def Symbol_moduleClass(self: Symbol)(given Context): Option[ClassDefSymbol] = {
-    val sym = self.moduleClass
-    if (sym.exists) Some(sym.asClass) else None
-  }
+  def Symbol_moduleClass(self: Symbol)(given Context): Symbol = self.moduleClass
 
-  def Symbol_companionClass(self: Symbol)(given Context): Option[ClassDefSymbol] = {
-    val sym = self.companionClass
-    if (sym.exists) Some(sym.asClass) else None
-  }
+  def Symbol_companionClass(self: Symbol)(given Context): Symbol = self.companionClass
+
+  def Symbol_companionModule(self: Symbol)(given Context): Symbol = self.companionModule
 
   type BindSymbol = core.Symbols.TermSymbol
 

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

@@ -1267,7 +1267,7 @@ trait CompilerInterface {
   def Symbol_fields(self: Symbol)(given ctx: Context): List[Symbol]
 
   /** Field with the given name directly declared in the class */
-  def Symbol_field(self: Symbol)(name: String)(given ctx: Context): Option[Symbol]
+  def Symbol_field(self: Symbol)(name: String)(given ctx: Context): Symbol
 
   /** Get non-private named methods defined directly inside the class */
   def Symbol_classMethod(self: Symbol)(name: String)(given ctx: Context): List[DefDefSymbol]
@@ -1284,9 +1284,6 @@ trait CompilerInterface {
   /** Fields of a case class type -- only the ones declared in primary constructor */
   def Symbol_caseFields(self: Symbol)(given ctx: Context): List[ValDefSymbol]
 
-  /** The symbol of the companion module */
-  def Symbol_companionModule(self: Symbol)(given ctx: Context): Option[ValDefSymbol]
-
   def Symbol_of(fullName: String)(given ctx: Context): ClassDefSymbol
 
   /** Symbol of a type (parameter or member) definition. */
@@ -1319,9 +1316,13 @@ trait CompilerInterface {
   def isValDefSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
   /** The class symbol of the companion module class */
-  def Symbol_moduleClass(self: Symbol)(given ctx: Context): Option[ClassDefSymbol]
+  def Symbol_moduleClass(self: Symbol)(given ctx: Context): Symbol
 
-  def Symbol_companionClass(self: Symbol)(given ctx: Context): Option[ClassDefSymbol]
+  /** The symbol of the companion class */
+  def Symbol_companionClass(self: Symbol)(given ctx: Context): Symbol
+
+  /** The symbol of the companion module */
+  def Symbol_companionModule(self: Symbol)(given ctx: Context): Symbol
 
   /** Symbol representing a bind definition. */
   type BindSymbol <: TermSymbol

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -29,7 +29,6 @@ trait SymbolOps extends Core {
     /** This symbol is protected within the resulting type */
     def protectedWithin(given ctx: Context): Option[Type] = internal.Symbol_protectedWithin(self)
 
-
     /** The name of this symbol */
     def name(given ctx: Context): String = internal.Symbol_name(self)
 
@@ -110,7 +109,7 @@ trait SymbolOps extends Core {
       internal.Symbol_fields(self)
 
     /** Field with the given name directly declared in the class */
-    def field(name: String)(given ctx: Context): Option[Symbol] =
+    def field(name: String)(given ctx: Context): Symbol =
       internal.Symbol_field(self)(name)
 
     /** Get non-private named methods defined directly inside the class */
@@ -133,10 +132,6 @@ trait SymbolOps extends Core {
     def caseFields(given ctx: Context): List[ValDefSymbol] =
       internal.Symbol_caseFields(self)
 
-    /** The symbol of the companion module */
-    def companionModule(given ctx: Context): Option[ValDefSymbol] =
-      internal.Symbol_companionModule(self)
-
     def isTypeParam(given ctx: Context): Boolean =
       internal.Symbol_isTypeParam(self)
 
@@ -145,11 +140,16 @@ trait SymbolOps extends Core {
       internal.Symbol_signature(self)
 
     /** The class symbol of the companion module class */
-    def moduleClass(given ctx: Context): Option[ClassDefSymbol] =
+    def moduleClass(given ctx: Context): Symbol =
       internal.Symbol_moduleClass(self)
 
-    def companionClass(given ctx: Context): Option[ClassDefSymbol] =
+    /** The symbol of the companion class */
+    def companionClass(given ctx: Context): Symbol =
       internal.Symbol_companionClass(self)
+
+    /** The symbol of the companion module */
+    def companionModule(given ctx: Context): Symbol =
+      internal.Symbol_companionModule(self)
   }
 
 }

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

@@ -45,7 +45,7 @@ object TypeToolbox {
   private def fieldInImpl(t: Type[_], mem: String)(given qctx: QuoteContext): Expr[String] = {
     import qctx.tasty._
     val field = t.unseal.symbol.asClassDef.field(mem)
-    Expr(field.map(_.name).getOrElse(""))
+    Expr(if field.isNoSymbol then "" else field.name)
   }
 
   inline def fieldsIn[T]: Seq[String] = ${fieldsInImpl('[T])}
@@ -89,19 +89,19 @@ object TypeToolbox {
   inline def companion[T1, T2]: Boolean = ${companionImpl('[T1], '[T2])}
   private def companionImpl(t1: Type[_], t2: Type[_])(given qctx: QuoteContext): Expr[Boolean] = {
     import qctx.tasty._
-    val res = t1.unseal.symbol.asClassDef.companionModule.contains(t2.unseal.symbol)
+    val res = t1.unseal.symbol.asClassDef.companionModule == t2.unseal.symbol
     Expr(res)
   }
 
   inline def companionName[T1]: String = ${companionNameImpl('[T1])}
   private def companionNameImpl(tp: Type[_])(given qctx: QuoteContext): Expr[String] = {
     import qctx.tasty._
     val sym = tp.unseal.symbol
-    val companionClassOpt =
-      if sym.isClassDef then sym.asClassDef.companionModule.getOrElse(Symbol.noSymbol).companionClass
-      else if sym.isValDef then sym.asValDef.companionClass
-      else None
-    Expr(companionClassOpt.map(_.fullName).getOrElse(""))
+    val companionClass =
+      if sym.isClassDef then sym.companionModule.companionClass
+      else if sym.isValDef then sym.companionClass
+      else Symbol.noSymbol
+    Expr(if companionClass.isNoSymbol then "" else companionClass.fullName)
   }
 
 }

tests/run-macros/gestalt-type-toolbox-reflect/Macro_1.scala

@@ -73,7 +73,7 @@ class Interpreter[R <: Reflection & Singleton](reflect0: R) extends TreeInterpre
           jvmReflection.interpretStaticVal(fn.symbol.owner, fn.symbol)
         case _ =>
           if (fn.symbol.flags.is(Flags.Object))
-            jvmReflection.loadModule(fn.symbol.asValDef.moduleClass.get)
+            jvmReflection.loadModule(fn.symbol.asValDef.moduleClass)
           else
             jvmReflection.interpretStaticVal(fn.symbol.owner, fn.symbol)
       }