Remove exception for SingletonTypes in typeSymbol

typeSymbol now follows underlying type for SingletonTypes,
same as for other TypeProxys.

Author: odersky

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

@@ -690,7 +690,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
   private def isSimpleThrowable(tp: Type)(using Context): Boolean = tp match {
     case tp @ TypeRef(pre, _) =>
-      (pre == NoPrefix || pre.widen.typeSymbol.isStatic) &&
+      (pre == NoPrefix || pre.typeSymbol.isStatic) &&
       (tp.symbol derivesFrom defn.ThrowableClass) && !tp.symbol.is(Trait)
     case _ =>
       false

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -998,11 +998,10 @@ class Definitions {
       FunctionType(args.length, isContextual, isErased).appliedTo(args ::: resultType :: Nil)
     def unapply(ft: Type)(using Context): Option[(List[Type], Type, Boolean, Boolean)] = {
       val tsym = ft.typeSymbol
-      if (isFunctionClass(tsym)) {
+      if isFunctionClass(tsym) && ft.isRef(tsym) then
         val targs = ft.dealias.argInfos
         if (targs.isEmpty) None
         else Some(targs.init, targs.last, tsym.name.isContextFunction, tsym.name.isErasedFunction)
-      }
       else None
     }
   }
@@ -1379,15 +1378,16 @@ class Definitions {
   /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ContextFunctionN
    *  instance?
    */
-  def isNonRefinedFunction(tp: Type)(using Context): Boolean = {
+  def isNonRefinedFunction(tp: Type)(using Context): Boolean =
     val arity = functionArity(tp)
     val sym = tp.dealias.typeSymbol
 
-    arity >= 0 &&
-      isFunctionClass(sym) &&
-      tp.isRef(FunctionType(arity, sym.name.isContextFunction, sym.name.isErasedFunction).typeSymbol) &&
-      !tp.isInstanceOf[RefinedType]
-  }
+    arity >= 0
+    && isFunctionClass(sym)
+    && tp.isRef(
+        FunctionType(arity, sym.name.isContextFunction, sym.name.isErasedFunction).typeSymbol,
+        skipRefined = false)
+  end isNonRefinedFunction
 
   /** Is `tp` a representation of a (possibly dependent) function type or an alias of such? */
   def isFunctionType(tp: Type)(using Context): Boolean =
@@ -1460,9 +1460,9 @@ class Definitions {
       if ctx.erasedTypes then
         atPhase(erasurePhase)(unapply(tp))
       else
-        val tp1 = tp.dealias
-        if isContextFunctionClass(tp1.typeSymbol) then
-          val args = asContextFunctionType(tp).dropDependentRefinement.argInfos
+        val tp1 = asContextFunctionType(tp)
+        if tp1.exists then
+          val args = tp1.dropDependentRefinement.argInfos
           Some((args.init, args.last, tp1.typeSymbol.name.isErasedFunction))
         else None
 

compiler/src/dotty/tools/dotc/core/TypeApplications.scala

@@ -445,7 +445,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  otherwise return Nil.
    *  Existential types in arguments are returned as TypeBounds instances.
    */
-  final def argInfos(using Context): List[Type] = self.stripTypeVar.stripAnnots match {
+  final def argInfos(using Context): List[Type] = self.stripped match {
     case AppliedType(tycon, args) => args
     case _ => Nil
   }

compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -310,7 +310,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         def compareThis = {
           val cls2 = tp2.cls
           tp1 match {
-            case tp1: NamedType if cls2.is(Module) && cls2.eq(tp1.widen.typeSymbol) =>
+            case tp1: NamedType if cls2.is(Module) && cls2.eq(tp1.typeSymbol) =>
               cls2.isStaticOwner ||
               recur(tp1.prefix, cls2.owner.thisType) ||
               secondTry
@@ -391,7 +391,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case tp1: ThisType =>
         val cls1 = tp1.cls
         tp2 match {
-          case tp2: TermRef if cls1.is(Module) && cls1.eq(tp2.widen.typeSymbol) =>
+          case tp2: TermRef if cls1.is(Module) && cls1.eq(tp2.typeSymbol) =>
             cls1.isStaticOwner ||
             recur(cls1.owner.thisType, tp2.prefix) ||
             thirdTry

compiler/src/dotty/tools/dotc/core/TypeErasure.scala

@@ -571,7 +571,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
   /** The erasure of a function result type. */
   private def eraseResult(tp: Type)(using Context): Type = tp match {
     case tp: TypeRef =>
-      val sym = tp.typeSymbol
+      val sym = tp.symbol
       if (sym eq defn.UnitClass) sym.typeRef
       // For a value class V, "new V(x)" should have type V for type adaptation to work
       // correctly (see SIP-15 and [[Erasure.Boxing.adaptToType]]), so the return type of a

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -419,7 +419,6 @@ object Types {
     @tailrec final def typeSymbol(using Context): Symbol = this match {
       case tp: TypeRef => tp.symbol
       case tp: ClassInfo => tp.cls
-      case tp: SingletonType => NoSymbol
       case tp: TypeProxy => tp.underlying.typeSymbol
       case  _: JavaArrayType => defn.ArrayClass
       case _ => NoSymbol
@@ -774,8 +773,8 @@ object Types {
           core.println(s"findMember exception for $this member $name, pre = $pre, recCount = $recCount")
 
           def showPrefixSafely(pre: Type)(using Context): String = pre.stripTypeVar match {
-            case pre: TermRef => i"${pre.termSymbol.name}."
-            case pre: TypeRef => i"${pre.typeSymbol.name}#"
+            case pre: TermRef => i"${pre.symbol.name}."
+            case pre: TypeRef => i"${pre.symbol.name}#"
             case pre: TypeProxy => showPrefixSafely(pre.underlying)
             case _ => if (pre.typeSymbol.exists) i"${pre.typeSymbol.name}#" else "."
           }

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -283,7 +283,7 @@ import ast.tpd
 
   class NotAMember(site: Type, val name: Name, selected: String, addendum: => String = "")(using Context)
   extends NotFoundMsg(NotAMemberID) {
-    //println(i"site = $site, decls = ${site.decls}, source = ${site.widen.typeSymbol.sourceFile}") //DEBUG
+    //println(i"site = $site, decls = ${site.decls}, source = ${site.typeSymbol.sourceFile}") //DEBUG
 
     def msg = {
       import core.Flags._

compiler/src/dotty/tools/dotc/transform/ElimOpaque.scala

@@ -66,7 +66,7 @@ class ElimOpaque extends MiniPhase with DenotTransformer {
     if sym == defn.Any_== || sym == defn.Any_!= then
       tree match
         case Apply(Select(receiver, name: TermName), args)
-        if atPhase(thisPhase)(receiver.tpe.widen.dealias.typeSymbol.isOpaqueAlias) =>
+        if atPhase(thisPhase)(receiver.tpe.widenDealias.typeSymbol.isOpaqueAlias) =>
           applyOverloaded(receiver, name, args, Nil, defn.BooleanType)
         case _ =>
           tree

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -161,7 +161,7 @@ class Erasure extends Phase with DenotTransformer {
 
   def assertErased(tp: Type, tree: tpd.Tree = tpd.EmptyTree)(using Context): Unit = {
     def isAllowed(cls: Symbol, sourceName: String) =
-      tp.widen.typeSymbol == cls && ctx.compilationUnit.source.file.name == sourceName
+      tp.typeSymbol == cls && ctx.compilationUnit.source.file.name == sourceName
     assert(isErasedType(tp) ||
            isAllowed(defn.ArrayClass, "Array.scala") ||
            isAllowed(defn.TupleClass, "Tuple.scala") ||
@@ -229,7 +229,7 @@ object Erasure {
      */
     private def safelyRemovableUnboxArg(tree: Tree)(using Context): Tree = tree match {
       case Apply(fn, arg :: Nil)
-      if isUnbox(fn.symbol) && defn.ScalaBoxedClasses().contains(arg.tpe.widen.typeSymbol) =>
+      if isUnbox(fn.symbol) && defn.ScalaBoxedClasses().contains(arg.tpe.typeSymbol) =>
         arg
       case _ =>
         EmptyTree
@@ -640,7 +640,7 @@ object Erasure {
         if !sym.exists && tree.name == nme.apply then
           // PolyFunction apply Selects will not have a symbol, so deduce the owner
           // from the typed qual.
-          val owner = qual1.tpe.widen.typeSymbol
+          val owner = qual1.tpe.typeSymbol
           if defn.isFunctionClass(owner) then owner else NoSymbol
         else
           val owner = sym.maybeOwner

compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala

@@ -48,7 +48,7 @@ class InterceptedMethods extends MiniPhase {
 
   // TODO: add missing cases from scalac
   private def poundPoundValue(tree: Tree)(using Context) = {
-    val s = tree.tpe.widen.typeSymbol
+    val s = tree.tpe.typeSymbol
 
     def staticsCall(methodName: TermName): Tree =
       ref(defn.staticsMethodRef(methodName)).appliedTo(tree)

compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala

@@ -72,7 +72,7 @@ class TryCatchPatterns extends MiniPhase {
 
   private def isSimpleThrowable(tp: Type)(using Context): Boolean = tp.stripAnnots match {
     case tp @ TypeRef(pre, _) =>
-      (pre == NoPrefix || pre.widen.typeSymbol.isStatic) && // Does not require outer class check
+      (pre == NoPrefix || pre.typeSymbol.isStatic) && // Does not require outer class check
       !tp.symbol.is(Flags.Trait) && // Traits not supported by JVM
       tp.derivesFrom(defn.ThrowableClass)
     case tp: AppliedType =>

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -486,7 +486,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
       case tp @ RefinedType(parent, _, _) =>
         erase(parent)
 
-      case tref: TypeRef if tref.typeSymbol.isPatternBound =>
+      case tref: TypeRef if tref.symbol.isPatternBound =>
         if (inArray) tref.underlying else WildcardType
 
       case _ => tp

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -116,7 +116,7 @@ object Applications {
       if (sel.exists) sel :: tupleSelectors(n + 1, tp) else Nil
     }
     def genTupleSelectors(n: Int, tp: Type): List[Type] = tp match {
-      case tp: AppliedType if !defn.isTupleClass(tp.typeSymbol) && tp.derivesFrom(defn.PairClass) =>
+      case tp: AppliedType if !defn.isTupleClass(tp.tycon.typeSymbol) && tp.derivesFrom(defn.PairClass) =>
         val List(head, tail) = tp.args
         head :: genTupleSelectors(n, tail)
       case _ => tupleSelectors(n, tp)

compiler/src/dotty/tools/dotc/typer/ImportInfo.scala

@@ -186,7 +186,7 @@ class ImportInfo(symf: Context ?=> Symbol,
   def featureImported(feature: TermName, owner: Symbol)(using Context): Boolean =
 
     def compute =
-      val isImportOwner = site.widen.typeSymbol.eq(owner)
+      val isImportOwner = site.typeSymbol.eq(owner)
       if isImportOwner && forwardMapping.contains(feature) then true
       else if isImportOwner && excluded.contains(feature) then false
       else

compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala

@@ -327,7 +327,7 @@ trait QuotesAndSplices {
         val isFreshTypeBindings = freshTypeBindings.map(_.symbol).toSet
         val typeMap = new TypeMap() {
           def apply(tp: Type): Type = tp match {
-            case tp: TypeRef if tp.typeSymbol.isTypeSplice =>
+            case tp: TypeRef if tp.symbol.isTypeSplice =>
               val tp1 = tp.dealias
               if (isFreshTypeBindings(tp1.typeSymbol)) tp1
               else tp
@@ -408,7 +408,7 @@ trait QuotesAndSplices {
     class ReplaceBindings extends TypeMap() {
       override def apply(tp: Type): Type = tp match {
         case tp: TypeRef =>
-          val tp1 = if (tp.typeSymbol.isTypeSplice) tp.dealias else tp
+          val tp1 = if (tp.symbol.isTypeSplice) tp.dealias else tp
           mapOver(typeBindings.get(tp1.typeSymbol).fold(tp)(_.symbol.typeRef))
         case tp => mapOver(tp)
       }

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -1166,7 +1166,7 @@ class RefChecks extends MiniPhase { thisPhase =>
         case _ => false
       }
       def underlyingClass(tp: Type): Symbol = {
-        val sym = tp.widen.typeSymbol
+        val sym = tp.typeSymbol
         if (sym.isAbstractOrParamType) underlyingClass(sym.info.bounds.hi)
         else sym
       }