replace some s"..." by i"..."

Conflicts:
	src/dotty/tools/dotc/typer/TypeAssigner.scala

Author: samuelgruetter

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

@@ -588,9 +588,9 @@ trait Applications extends Compatibility { self: Typer =>
       def extractorMemberType(tp: Type, name: Name) = {
         val ref = tp member name
         if (ref.isOverloaded)
-          errorType(s"Overloaded reference to ${ref.show} is not allowed in extractor", tree.pos)
+          errorType(i"Overloaded reference to $ref is not allowed in extractor", tree.pos)
         else if (ref.info.isInstanceOf[PolyType])
-          errorType(s"Reference to polymorphic ${ref.show}: ${ref.info.show} is not allowed in extractor", tree.pos)
+          errorType(i"Reference to polymorphic $ref: ${ref.info} is not allowed in extractor", tree.pos)
         else
           ref.info.widenExpr.dealias
       }
@@ -618,7 +618,7 @@ trait Applications extends Compatibility { self: Typer =>
       if (unapplyResult derivesFrom defn.SeqClass) seqSelector :: Nil
       else if (unapplyResult isRef defn.BooleanClass) Nil
       else {
-        ctx.error(s"${unapplyResult.show} is not a valid result type of an unapply method of an extractor", tree.pos)
+        ctx.error(i"$unapplyResult is not a valid result type of an unapply method of an extractor", tree.pos)
         Nil
       }
     }
@@ -636,7 +636,7 @@ trait Applications extends Compatibility { self: Typer =>
     unapplyFn.tpe.widen match {
       case mt: MethodType if mt.paramTypes.length == 1 && !mt.isDependent =>
         val unapplyArgType = mt.paramTypes.head
-        unapp.println(s"unapp arg tpe = ${unapplyArgType.show}, pt = ${pt.show}")
+        unapp.println(i"unapp arg tpe = $unapplyArgType, pt = $pt")
         def wpt = widenForMatchSelector(pt) // needed?
         val ownType =
           if (pt <:< unapplyArgType) {

src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -204,7 +204,7 @@ trait TypeAssigner {
       case Nil =>
         errorType(d"$mix does not name a parent class of $cls", tree.pos)
       case p :: q :: _ =>
-        errorType(s"ambiguous parent class qualifier", tree.pos)
+        errorType("ambiguous parent class qualifier", tree.pos)
     }
     val owntype =
       if (!mix.isEmpty) findMixinSuper(cls.info)
@@ -217,9 +217,9 @@ trait TypeAssigner {
     val ownType = fn.tpe.widen match {
       case fntpe @ MethodType(_, ptypes) =>
         if (sameLength(ptypes, args)) fntpe.instantiate(args.tpes)
-        else errorType(s"wrong number of parameters for ${fn.tpe}; expected: ${ptypes.length}", tree.pos)
+        else errorType(i"wrong number of parameters for ${fn.tpe}; expected: ${ptypes.length}", tree.pos)
       case t =>
-        errorType(s"${err.exprStr(fn)} does not take parameters", tree.pos)
+        errorType(i"${err.exprStr(fn)} does not take parameters", tree.pos)
     }
     tree.withType(ownType)
   }
@@ -231,7 +231,7 @@ trait TypeAssigner {
         if (sameLength(argTypes, pt.paramNames)) pt.instantiate(argTypes)
         else errorType(d"wrong number of type parameters for ${fn.tpe}; expected: ${pt.paramNames.length}", tree.pos)
       case _ =>
-        errorType(s"${err.exprStr(fn)} does not take type parameters", tree.pos)
+        errorType(i"${err.exprStr(fn)} does not take type parameters", tree.pos)
     }
     tree.withType(ownType)
   }

src/dotty/tools/dotc/typer/Typer.scala

@@ -490,15 +490,15 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         }
         val ofFun =
           if (nme.syntheticParamNames(args.length + 1) contains param.name)
-            s" of expanded function ${tree.show}"
+            i" of expanded function $tree"
           else
             ""
-        errorType(s"missing parameter type for parameter ${param.name}$ofFun, expected = ${pt.show}", param.pos)
+        errorType(i"missing parameter type for parameter ${param.name}$ofFun, expected = $pt", param.pos)
       }
 
       def protoFormal(i: Int): Type =
         if (protoFormals.length == params.length) protoFormals(i)
-        else errorType(s"wrong number of parameters, expected: ${protoFormals.length}", tree.pos)
+        else errorType(i"wrong number of parameters, expected: ${protoFormals.length}", tree.pos)
 
       val inferredParams: List[untpd.ValDef] =
         for ((param, i) <- params.zipWithIndex) yield
@@ -700,7 +700,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
     val res = cpy.RefinedTypeTree(tree, tpt1, refinements1) withType
       (tpt1.tpe /: refinements1)(addRefinement)
-    typr.println(s"typed refinement: ${res.tpe.show}")
+    typr.println(i"typed refinement: ${res.tpe}")
     res
   }
 
@@ -728,7 +728,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
   def typedBind(tree: untpd.Bind, pt: Type)(implicit ctx: Context): Bind = track("typedBind") {
     val body1 = typed(tree.body, pt)
-    typr.println(s"typed bind ${tree.show} pt = ${pt.show} bodytpe = ${body1.tpe.show}")
+    typr.println(i"typed bind $tree pt = $pt bodytpe = ${body1.tpe}")
     val sym = ctx.newSymbol(ctx.owner, tree.name.asTermName, EmptyFlags, body1.tpe, coord = tree.pos)
     assignType(cpy.Bind(tree, tree.name, body1), sym)
   }
@@ -951,7 +951,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
   }
 
-  def typed(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = /*>|>*/ ctx.traceIndented (s"typing ${tree.show}", typr, show = true) /*<|<*/ {
+  def typed(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = /*>|>*/ ctx.traceIndented (i"typing $tree", typr, show = true) /*<|<*/ {
     if (!tree.isEmpty && ctx.typerState.isGlobalCommittable) assert(tree.pos.exists, tree)
     try adapt(typedUnadapted(tree, pt), pt)
     catch {
@@ -1158,7 +1158,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         if (tree.tpe <:< pt) tree
         else if (ctx.mode is Mode.Pattern) tree // no subtype check for pattern
         else {
-          typr.println(s"adapt to subtype ${tree.tpe.show} !<:< ${pt.show}")
+          typr.println(i"adapt to subtype ${tree.tpe} !<:< $pt")
           //typr.println(TypeComparer.explained(implicit ctx => tree.tpe <:< pt))
           adaptToSubType(wtp)
         }