WFlagNumericWiden,

WFlagSelfImplicit,

WFlagUnnamedBooleanLiteral,

WFlagTostringInterpolated,

= wflag()

valwarnOctalLiteral=BooleanSetting("-Woctal-literal","Warn on obsolete octal syntax.") withAbbreviation"-Ywarn-octal-literal"

valwarnUnnamedBoolean=BooleanSetting("-Wunnamed-boolean-literal","Warn about unnamed boolean literals if there is more than one or defaults are used, unless parameter has @deprecatedName.")

valwarnUnnamedStrict=BooleanSetting("-Wunnamed-boolean-literal-strict","Warn about all unnamed boolean literals, unless parameter has @deprecatedName or the method has a single leading boolean parameter.").enabling(warnUnnamedBoolean::Nil)

valwarnToString=BooleanSetting("-Wtostring-interpolated","Warn when a standard interpolator uses toString.")

objectPerformanceWarningsextendsMultiChoiceEnumeration {

valCaptured=Choice("captured","Modification of var in closure causes boxing.")

packagescala.tools

importnsc.Reporting.WarningCategory.Scala3Migration

importnsc.Reporting.WarningCategory.{Scala3Migration,WFlagTostringInterpolated}

traitFastStringInterpolatorextendsFormatInterpolator {

importc.universe._

valtreatedContents= lit.asInstanceOf[Literal].value.stringValue

valemptyLit= treatedContents.isEmpty

if (i< numLits-1) {

concatArgs+= argsIndexed(i)

if (!emptyLit) concatArgs+= lit

concatArgs+=lit

valarg= argsIndexed(i)

if (linting&&!(arg.tpe=:= definitions.StringTpe))

concatArgs+=arg

}

if (!emptyLit) concatArgs+= lit

}

defmkConcat(pos:Position,lhs:Tree,rhs:Tree):Tree=

atPos(pos)(gen.mkMethodCall(gen.mkAttributedSelect(lhs, definitions.String_+), rhs::Nil)).setType(definitions.StringTpe)

packagescala.tools.reflect

importscala.reflect.macros.runtime.Context

importscala.collection.mutable.ListBuffer

importscala.PartialFunction.cond

importscala.util.chaining._

importscala.collection.mutable.ListBuffer

importscala.reflect.macros.runtime.Context

importscala.tools.nsc.Reporting.WarningCategory,WarningCategory.WFlagTostringInterpolated

importscala.util.matching.Regex.Match

importscala.util.chaining._

importjava.util.Formattable

importdefinitions._

importtreeInfo.Applied

protectedvarlinting= settings.warnToString.value

protectedfinaldefwithoutLinting[A](body:=>A):A= {

vallinted= linting

linting=false

try bodyfinally linting= linted

}

privatedefbail(msg:String)= global.abort(msg)

defconcatenate(parts:List[Tree],args:List[Tree]):Tree

defargType(argi:Int,types:Type*):Type= {

valtpe= argTypes(argi)

types.find(t=> argConformsTo(argi, tpe, t))

.orElse(types.find(t=> argConvertsTo(argi, tpe, t)))

types.find(t=> t!=AnyTpe&& argConformsTo(argi, tpe, t))

.orElse(types.find(t=> t!=AnyTpe&& argConvertsTo(argi, tpe, t)))

.orElse(types.find(t=> t==AnyTpe&& argConformsTo(argi, tpe, t)))

.getOrElse {

valmsg="type mismatch"+ {

valreq=raw"required: (.*)".r.unanchored

defloop(remaining:List[Tree],n:Int):Unit=

remainingmatch {

case part0::more=>

case part0::remaining=>

valpart1= part0match {

caseLiteral(Constant(x:String))=> x

case _=>thrownewIllegalArgumentException("internal error: argument parts must be a list of string literals")

definsertStringConversion():Unit= {

amended+="%s"+ part

convert+=Conversion(formatPattern.findAllMatchIn("%s").next(), part0.pos, argc)// improve

argType(n-1,AnyTpe)

valcv=Conversion(part0.pos, argc)

cv.accepts(argType(n-1,AnyTpe))

convert+= cv

}

deferrorLeading(op:Conversion)= op.errorAt(Spec)(s"conversions must follow a splice;${Conversion.literalHelp}")

defaccept(op:Conversion):Unit= {

elseif (!cv.isLiteral&&!cv.isIndexed) errorLeading(cv)

formatting=true

}

loop(more, n= n+1)

loop(remaining, n= n+1)

}

loop(parts, n=0)

valformat= amended.mkString

if (actuals.isEmpty&&!formatting) constantly(format)

elseif (!reported&& actuals.forall(treeInfo.isLiteralString)) constantly(format.format(actuals.map(_.asInstanceOf[Literal].value.value).toIndexedSeq:_*))

elseif (!formatting) concatenate(amended.map(p=> constantly(p.stripPrefix("%s"))).toList, actuals.toList)

elseif (!formatting) {

withoutLinting {// already warned

concatenate(amended.map(p=> constantly(p.stripPrefix("%s"))).toList, actuals.toList)

}

}

else {

valscalaPackage=Select(Ident(nme.ROOTPKG),TermName("scala"))

valnewStringOps=Select(

caseErrorXn=> op(0)

caseDateTimeXnif op.length>1=> op(1)

caseStringXnif op.isEmpty=>'s'// accommodate the default %s

case _=> op(0)

}

arg==BigIntTpe||!cond(cc) {

case'o'|'x'|'X'if hasAnyFlag("+ (")=>"+ (".filter(hasFlag).foreach(bad=> badFlag(bad,s"only use '$bad' for BigInt conversions to o, x, X")) ;true

}

caseStringXn=> arg==StringTpe orElse (if (linting) warningAt(CC)("String format uses toString",WFlagTostringInterpolated))

case _=>true

}

kindmatch {

caseStringXnif hasFlag('#')=>FormattableTpe::Nil

defgroupPosAt(g:SpecGroup,i:Int)= pos.withPoint(pos.point+ descriptor.offset(g, i))

deferrorAt(g:SpecGroup,i:Int=0)(msg:String)= c.error(groupPosAt(g, i), msg).tap(_=> reported=true)

defwarningAt(g:SpecGroup,i:Int=0)(msg:String)= c.warning(groupPosAt(g, i), msg)

defwarningAt(g:SpecGroup,i:Int=0)(msg:String,cat:WarningCategory=WarningCategory.Other)= c.callsiteTyper.context.warning(groupPosAt(g, i), msg, cat,Nil)

}

objectConversion {

caseNone=>newConversion(m, p,ErrorXn, argc).tap(_.errorAt(Spec)(s"Missing conversion operator in '${m.matched}';$literalHelp"))

}

}

defapply(p:Position,argc:Int):Conversion=

newConversion(formatPattern.findAllMatchIn("%").next(), p,StringXn, argc)

}

stringinterpolation_macro-neg.scala:16: error: too few arguments for interpolated string

new StringContext("", "").f()

^

stringinterpolation_macro-neg.scala:19: error: type mismatch;

found : String

required: Boolean, Null

f"$s%b"

^

stringinterpolation_macro-neg.scala:20: error: type mismatch;

found : String

required: Char, Byte, Short, Int

stringinterpolation_macro-neg.scala:80: error: conversions must follow a splice; use %% for literal %, %n for newline

f"${d}random-leading-junk%d"

^

stringinterpolation_macro-neg.scala:19: warning: Boolean format is null test for non-Boolean

f"$s%b"

^

stringinterpolation_macro-neg.scala:63: warning: Index is not this arg

f"${8}%d ${9}%1$$d"

^

stringinterpolation_macro-neg.scala:65: warning: Index is not this arg

f"$s%s $s%1$$s"

^

3 warnings

46 errors

4 warnings

45 errors

tostring-interpolated.scala:7: error: String format uses toString

Applicable -Wconf / @nowarn filters for this fatal warning: msg=<part of the message>, cat=w-flag-tostring-interpolated, site=T.f

def f = f"$c"

^

tostring-interpolated.scala:8: error: interpolation uses toString

Applicable -Wconf / @nowarn filters for this fatal warning: msg=<part of the message>, cat=w-flag-tostring-interpolated, site=T.s

def s = s"$c"

^

tostring-interpolated.scala:9: error: interpolation uses toString

Applicable -Wconf / @nowarn filters for this fatal warning: msg=<part of the message>, cat=w-flag-tostring-interpolated, site=T.r

def r = raw"$c"

^

tostring-interpolated.scala:11: error: String format uses toString

Applicable -Wconf / @nowarn filters for this fatal warning: msg=<part of the message>, cat=w-flag-tostring-interpolated, site=T.format

def format = f"${c.x}%d in $c or $c%s" // warn using c.toString

^

tostring-interpolated.scala:11: error: String format uses toString

Applicable -Wconf / @nowarn filters for this fatal warning: msg=<part of the message>, cat=w-flag-tostring-interpolated, site=T.format

def format = f"${c.x}%d in $c or $c%s" // warn using c.toString

^

tostring-interpolated.scala:13: warning: Boolean format is null test for non-Boolean

def bool = f"$c%b" // warn just a null check

^

tostring-interpolated.scala:15: error: interpolation uses toString

Applicable -Wconf / @nowarn filters for this fatal warning: msg=<part of the message>, cat=w-flag-tostring-interpolated, site=T.oops

def oops = s"${null} slipped thru my fingers"

^

tostring-interpolated.scala:20: error: interpolation uses toString

Applicable -Wconf / @nowarn filters for this fatal warning: msg=<part of the message>, cat=w-flag-tostring-interpolated, site=T.greeting

def greeting = s"$sb, world"

^

1 warning

7 errors

caseclassC(x:Int)

traitT {

defc=C(42)

deff=f"$c"

defs=s"$c"

defr=raw"$c"

defformat=f"${c.x}%d in$c or$c%s"// warn using c.toString

defbool=f"$c%b"// warn just a null check

defoops=s"${null} slipped thru my fingers"

defok=s"${c.toString}"

defsb=newStringBuilder().append("hello")

defgreeting=s"$sb, world"

}

defassertEquals(s0:String,s1:String)= assert(s0== s1,s"$s0 ==$s1")

defassertEquals(s0:String,s1:String,i:Int=-1)= assert(s0== s1,s"$s0 ==$s1${if (i>=0)" at"+ i.toStringelse""}")

defnoEscape()= {

f"${null}%b"->"false",

f"${false}%b"->"false",

f"${true}%b"->"true",

f"${true&&false}%b"->"false",

f"${true&&false}%b"->"false",

f"${java.lang.Boolean.valueOf(false)}%b"->"false",

f"${java.lang.Boolean.valueOf(true)}%b"->"true",

)

for ((f, s)<- ss) assertEquals(s, f)

for (((f, s), i)<- ss.zipWithIndex) assertEquals(s, f, i)

}

noEscape()