clean up code

Author: TheDrawingCoder-Gamer

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

@@ -958,6 +958,7 @@ class Definitions {
   def TupleClass(using Context): ClassSymbol = TupleTypeRef.symbol.asClass
     @tu lazy val Tuple_cons: Symbol = TupleClass.requiredMethod("*:")
   @tu lazy val TupleModule: Symbol = requiredModule("scala.Tuple")
+    @tu lazy val Tuple_Elem: Symbol = TupleModule.requiredType("Elem")
   @tu lazy val EmptyTupleClass: Symbol = requiredClass("scala.EmptyTuple")
   @tu lazy val EmptyTupleModule: Symbol = requiredModule("scala.EmptyTuple")
   @tu lazy val NonEmptyTupleTypeRef: TypeRef = requiredClassRef("scala.NonEmptyTuple")
@@ -1270,6 +1271,32 @@ class Definitions {
       else None
   }
 
+  // Pattern matcher of tuple selectors at the type level
+  // Matches Tuple.Elem[x, constant] and x._1.type
+  object TupleSelectorOf:
+    def unapply(tp: Type)(using Context): Option[(Type, Int)] =
+      if tp.isRef(Tuple_Elem) then
+        // get the arg infos for tuple elem
+        tp.argInfos match
+          case tupleType :: ConstantType(c) :: Nil
+            if c.isIntRange && (isTupleNType(tupleType) || tupleType.isRef(PairClass)) =>
+              Some((tupleType, c.intValue))
+          // we should probably report an error here, but its probably handled elsewhere
+          case _ => None
+      else
+        tp.dealias match
+          // very explicitly ONLY check for isTupleNType
+          // pair class doesn't have selector fields
+          case TermRef(tupleType, field) if isTupleNType(tupleType) =>
+            field match
+              case name: SimpleName =>
+                name.toString match
+                  case s"_$id" =>
+                    id.toIntOption.map(it => (tupleType, it - 1))
+                  case _ => None
+              case _ => None
+          case _ => None
+
   object ArrayOf {
     def apply(elem: Type)(using Context): Type =
       if (ctx.erasedTypes) JavaArrayType(elem)
@@ -1473,7 +1500,7 @@ class Definitions {
   def patchStdLibClass(denot: ClassDenotation)(using Context): Unit =
     // Do not patch the stdlib files if we explicitly disable it
     // This is only to be used during the migration of the stdlib
-    if ctx.settings.YnoStdlibPatches.value then 
+    if ctx.settings.YnoStdlibPatches.value then
       return
 
     def patch2(denot: ClassDenotation, patchCls: Symbol): Unit =

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

@@ -108,43 +108,37 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       case AppliedType(_, funArgs @ fun :: tupled :: Nil) =>
         def doesFunctionTupleInto(baseFun: Type, actualArgs: List[Type],
             actualRet: Type, tupled: Type) =
-          tupled.dealias =:= constructDependentTupleType(actualArgs, actualRet, defn.isContextFunctionType(baseFun))
+          tupled =:= constructDependentTupleType(actualArgs, actualRet, defn.isContextFunctionType(baseFun))
         def doesFunctionUntupleTo(baseFun: Type, actualArgs: List[Type],
             actualRet: Type, untupled: Type) =
-              untupled.dealias =:= untupleDependentTupleType(actualArgs, actualRet, defn.isContextFunctionType(baseFun))
+              untupled =:= untupleDependentTupleType(actualArgs, actualRet, defn.isContextFunctionType(baseFun))
 
         def functionTypeEqual(baseFun: Type, actualArgs: List[Type],
             actualRet: Type, expected: Type) =
-          expected.dealias =:= defn.FunctionNOf(actualArgs, actualRet, defn.isContextFunctionType(baseFun))
+          expected =:= defn.FunctionNOf(actualArgs, actualRet, defn.isContextFunctionType(baseFun))
         def untupleDependentTupleType(args: List[Type], ret: Type, contextual: Boolean): Type =
           val methodKind = if contextual then ContextualMethodType else MethodType
 
-
-          val p = methodKind(args.indices.map(nme.syntheticParamName).toList)(
+          val arity = args.length
+          methodKind(args.indices.map(nme.syntheticParamName).toList)(
             mt => args,
             mt =>
               val tpeMap = new TypeMap:
                 def apply(tp: Type): Type =
                   tp match
-                    case TermRef(TermParamRef(_, paramNum), name) =>
-                      name match
-                        case x: TermName =>
-                          x.toString match
-                            // hack upon hack upon hack
-                            // please make there be a reverse map so i dont have to do this : (
-                            case s"_$id" =>
-                              mt.paramRefs(id.toInt)
-                            case _ => ???
-                        case _ => ???
+                    case defn.TupleSelectorOf(TermParamRef(_, paramNum), fieldNum) =>
+                      if fieldNum >= arity then
+                        NoType
+                      else
+                        mt.paramRefs(fieldNum)
                     case _ => mapOver(tp)
               tpeMap(ret)
           )
-          p
 
         def constructDependentTupleType(args: List[Type], ret: Type, contextual: Boolean): Type =
           val methodKind = if contextual then ContextualMethodType else MethodType
 
-          val p = methodKind(List(nme.syntheticParamName(0)))(
+          methodKind(List(nme.syntheticParamName(0)))(
             mt => List(defn.tupleType(args)),
             mt =>
               val tpeMap = new TypeMap:
@@ -156,35 +150,33 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
                       mapOver(tp)
               tpeMap(ret)
           ).toFunctionType()
-          p
-        val dealiasedFun = fun.dealias
-        val dealiasedTupled = tupled.dealias
+
         val arity: Int =
           if defn.isFunctionNType(fun) then
             // TupledFunction[(...) => R, ?]
             // dont use functionArgInfos it dealiases and drops dependents
 
-            dealiasedFun match
-              case defn.RefinedFunctionOf(method: MethodType) if doesFunctionTupleInto(dealiasedFun, method.paramInfos, method.resType, dealiasedTupled) =>
+            fun.dealias match
+              case defn.RefinedFunctionOf(method: MethodType) if doesFunctionTupleInto(fun, method.paramInfos, method.resType, tupled) =>
                 method.paramInfos.size
               // poly types are unsupported
               case defn.RefinedFunctionOf(_) => -1
               case _ =>
                 fun.functionArgInfos match
                   case funArgs :+ funRet
-                  if functionTypeEqual(dealiasedFun, defn.tupleType(funArgs) :: Nil, funRet, dealiasedTupled) =>
+                  if functionTypeEqual(fun, defn.tupleType(funArgs) :: Nil, funRet, tupled) =>
                     // TupledFunction[(...funArgs...) => funRet, ?]
                     funArgs.size
                   case _ => -1
           else if defn.isFunctionNType(tupled) then
             // TupledFunction[?, (...) => R]
-            dealiasedTupled match
+            tupled.dealias match
               case defn.RefinedFunctionOf(method: MethodType) =>
                 method.argInfos match
                   case tupledArgs :: funRet :: Nil =>
                     // TupledFunction[?, ((...)) => R]
                     tupledArgs.tupleElementTypes match
-                      case Some(args) if doesFunctionUntupleTo(dealiasedTupled, args, funRet, dealiasedFun) =>
+                      case Some(args) if doesFunctionUntupleTo(tupled, args, funRet, fun) =>
                         args.size
                       case _ => -1
                   case _ => -1
@@ -193,7 +185,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
                   case tupledArgs :: funRet :: Nil =>
                     // TupledFunction[?, ((...)) => R]
                     tupledArgs.tupleElementTypes match
-                        case Some(args) if functionTypeEqual(dealiasedTupled, args, funRet, dealiasedFun) =>
+                        case Some(args) if functionTypeEqual(tupled, args, funRet, fun) =>
                           args.size
                         case _ => -1
                   case _ => -1