Big Cleanup

Author: Sporarum

TypesEverywhere.scala

@@ -2937,7 +2937,7 @@ object Parsers {
 
       def recur(firstClause: Boolean, nparams: Int): List[List[TypeDef] | List[ValDef]] =
         newLineOptWhenFollowedBy(LPAREN)
-        newLineOptWhenFollowedBy(LBRACKET) //I have doubts this works //TODO: test this
+        newLineOptWhenFollowedBy(LBRACKET)
         if in.token == LPAREN then
           val paramsStart = in.offset
           val params = paramClause(
@@ -3468,7 +3468,7 @@ object Parsers {
         argumentExprss(mkApply(Ident(nme.CONSTRUCTOR), argumentExprs()))
       }
 
-    /** TypeDcl ::=  id [TypeParamClause] {FunParamClause} TypeBounds [‘=’ Type] //TODO: change to {ParamClauses} ?
+    /** TypeDcl ::=  id [TypeParamClause] {FunParamClause} TypeBounds [‘=’ Type]
      */
     def typeDefOrDcl(start: Offset, mods: Modifiers): Tree = {
       newLinesOpt()
@@ -3565,7 +3565,7 @@ object Parsers {
       val tparams = typeParamClauseOpt(ParamOwner.Class)
       val cmods = fromWithinClassConstr(constrModsOpt())
       val vparamss = paramClauses(ofClass = true, ofCaseClass = isCaseClass)
-      makeConstructor(tparams, vparamss).withMods(cmods) //TODO: Reafactor to take List[List[ValDef] | List[TypeDef]]
+      makeConstructor(tparams, vparamss).withMods(cmods)
     }
 
     /** ConstrMods        ::=  {Annotation} [AccessModifier]
@@ -3654,7 +3654,7 @@ object Parsers {
     }
 
     /** GivenDef          ::=  [GivenSig] (AnnotType [‘=’ Expr] | StructuralInstance)
-     *  GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClauses} ‘:’ //TODO: Change to {Params}
+     *  GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClauses} ‘:’
      */
     def givenDef(start: Offset, mods: Modifiers, givenMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, givenMod)
@@ -3702,7 +3702,7 @@ object Parsers {
     }
 
     /** Extension  ::=  ‘extension’ [DefTypeParamClause] {UsingParamClause} ‘(’ DefTermParam ‘)’
-     *                  {UsingParamClause} ExtMethods //TODO: Change to {Params} ?
+     *                  {UsingParamClause} ExtMethods
      */
     def extension(): ExtMethods =
       val start = in.skipToken()

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -404,9 +404,7 @@ trait Applications extends Compatibility {
     private var _ok = true
 
     def ok: Boolean = _ok
-    def ok_=(x: Boolean): Unit = 
-      //if !x then println("set ok to false")
-      _ok = x
+    def ok_=(x: Boolean): Unit = _ok = x
 
     /** The function's type after widening and instantiating polytypes
      *  with TypeParamRefs in constraint set
@@ -416,7 +414,6 @@ trait Applications extends Compatibility {
         t.widen match{
           case funType: MethodType => funType
           case funType: PolyType => 
-            //rec(constrained(funType).resultType) //TODO: Could replace rec(etc) by etc.methType ?
             rec(instantiateWithTypeVars(funType))
           case tp => tp
         }
@@ -666,7 +663,6 @@ trait Applications extends Compatibility {
           defn.isFunctionType(argtpe1) && formal.match
             case SAMType(sam) => argtpe <:< sam.toFunctionType(isJava = formal.classSymbol.is(JavaDefined))
             case _ => false
-        //println(s"argOK($arg,$formal) = ${isCompatible(argtpe, formal)}")
         isCompatible(argtpe, formal)
         // Only allow SAM-conversion to PartialFunction if implicit conversions
         // are enabled. This is necessary to avoid ambiguity between an overload
@@ -713,7 +709,6 @@ trait Applications extends Compatibility {
    */
   class ApplicableToTrees(methRef: TermRef, args: List[Tree], resultType: Type, argMatch: ArgMatch)(using Context)
   extends TestApplication(methRef, methRef.widen, args, resultType, argMatch) {
-    //println("ApplicableToTrees created")
     def argType(arg: Tree, formal: Type): Type =
       if untpd.isContextualClosure(arg) && defn.isContextFunctionType(formal) then arg.tpe
       else normalize(arg.tpe, formal)
@@ -1090,8 +1085,6 @@ trait Applications extends Compatibility {
     val typedArgs = if (isNamed) typedNamedArgs(tree.args) else tree.args.mapconserve(typedType(_))
     record("typedTypeApply")
     typedExpr(tree.fun, PolyProto(typedArgs, pt)) match {
-      /* case _: TypeApply if !ctx.isAfterTyper =>  //TODO: assess removing this is okay
-        errorTree(tree, "illegal repeated type application") */
       case typedFn =>
         typedFn.tpe.widen match {
           case pt: PolyType =>
@@ -1399,10 +1392,8 @@ trait Applications extends Compatibility {
    *  @param  resultType   The expected result type of the application
    */
   def isApplicableMethodRef(methRef: TermRef, args: List[Tree], resultType: Type, keepConstraint: Boolean, argMatch: ArgMatch)(using Context): Boolean = {
-    //println("entered isApplicableMethodRef")
     def isApp(using Context): Boolean =
       new ApplicableToTrees(methRef, args, resultType, argMatch).success
-    //println(isApp) // check above ^
     if (keepConstraint) isApp else explore(isApp)
   }
 
@@ -1764,16 +1755,10 @@ trait Applications extends Compatibility {
      *  probability of pruning the search. result type comparisons are neither cheap nor
      *  do they prune much, on average.
      */
-    def adaptByResult(chosen: TermRef, alts: List[TermRef]) = 
-      //println("entered adaptByResult")
-      //println(chosen.symbol.showDcl)
-      //println(alts.map(_.symbol.showDcl)) 
-      pt match {
+    def adaptByResult(chosen: TermRef, alts: List[TermRef]) = pt match {
         case pt: FunProto if !explore(resultConforms(chosen.symbol, chosen, pt.resultType)) =>
-          //println("pt funproto")
           val conformingAlts = alts.filterConserve(alt =>
             (alt ne chosen) && explore(resultConforms(alt.symbol, alt, pt.resultType)))
-          //println(conformingAlts.map(_.symbol.showDcl)) 
           conformingAlts match {
             case Nil => chosen
             case alt2 :: Nil => alt2
@@ -1787,7 +1772,6 @@ trait Applications extends Compatibility {
       }
 
     def resolve(alts: List[TermRef]): List[TermRef] =
-      //println("enter resolve")
       pt match
         case pt: FunProto =>
           if pt.applyKind == ApplyKind.Using then
@@ -1798,18 +1782,11 @@ trait Applications extends Compatibility {
         case _ =>
 
       var found = withoutMode(Mode.ImplicitsEnabled)(resolveOverloaded1(alts, pt))
-      //println("found =")
-      //println(found.map(_.symbol.showDcl))
       if found.isEmpty && ctx.mode.is(Mode.ImplicitsEnabled) then
-        //println("update found")
         found = resolveOverloaded1(alts, pt)
       found match
-        case alt :: Nil => 
-          //println("resolve1")
-          adaptByResult(alt, alts) :: Nil
-        case _ =>
-          //println("resolve2") 
-          found
+        case alt :: Nil => adaptByResult(alt, alts) :: Nil
+        case _ => found
     end resolve
 
     /** Try an apply method, if
@@ -1857,9 +1834,6 @@ trait Applications extends Compatibility {
     trace(i"resolve over $alts%, %, pt = $pt", typr, show = true) {
     record(s"resolveOverloaded1", alts.length)
 
-    //println(pt.show)
-    //println(pt)
-
     def isDetermined(alts: List[TermRef]) = alts.isEmpty || alts.tail.isEmpty
 
     /** The shape of given tree as a type; cannot handle named arguments. */
@@ -1959,25 +1933,17 @@ trait Applications extends Compatibility {
         record("resolveOverloaded.FunProto", alts.length)
         val alts1 = narrowBySize(alts)
         //report.log(i"narrowed by size: ${alts1.map(_.symbol.showDcl)}%, %")
-        //println(i"narrowed by size: ${alts1.map(_.symbol.showDcl)}%, %")
         if isDetermined(alts1) then alts1
         else
           record("resolveOverloaded.narrowedBySize", alts1.length)
           val alts2 = narrowByShapes(alts1)
           //report.log(i"narrowed by shape: ${alts2.map(_.symbol.showDcl)}%, %")
-          //println(i"narrowed by shape: ${alts2.map(_.symbol.showDcl)}%, %")
           if isDetermined(alts2) 
-          then
-            //println("1")
-            //println(alts2.map(_.symbol.showDcl)) 
-            alts2
+          then alts2
           else
             record("resolveOverloaded.narrowedByShape", alts2.length)
             pretypeArgs(alts2, pt)
-            val res = narrowByTrees(alts2, pt.typedArgs(normArg(alts2, _, _)), resultType)
-            //println("2")
-            //println(res.map(_.symbol.showDcl))
-            res
+            narrowByTrees(alts2, pt.typedArgs(normArg(alts2, _, _)), resultType)
 
       case pt @ PolyProto(targs1, pt1) =>
         val alts1 = alts.filterConserve(pt.canInstantiate)

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

@@ -1,3 +1,4 @@
 def f1[T][U](x: T, y: U): (T, U) = (x, y)
 def f2[T](x: T)[U](y: U): (T, U) = (x, y)
-def f3[T, U][V](x: T): U = ???
+def f3[T, U][V](x: T): U = ???
+def f4[T](x: T)[U <: x.type](y: U): (T, U) = (x, y)