importjava.io.IOException

importjava.nio.charset.Charset

importjava.nio.file.{Files,Path,Paths}

importjava.util.regex.PatternSyntaxException

importscala.annotation.nowarn

importscala.annotation.{nowarn,tailrec}

importscala.collection.mutable

importscala.reflect.internal

importscala.reflect.internal.util.StringOps.countElementsAsString

importscala.reflect.internal.util.{CodeAction,NoSourceFile,Position,SourceFile}

importscala.reflect.internal.util.{CodeAction,NoSourceFile,Position,SourceFile,TextEdit}

importscala.tools.nsc.Reporting.Version.{NonParseableVersion,ParseableVersion}

importscala.tools.nsc.Reporting._

importscala.tools.nsc.settings.NoScalaVersion

else conf

}

privatelazyvalquickfixFilters= {

if (settings.quickfix.isSetByUser&& settings.quickfix.value.isEmpty) {

globalError(s"Missing message filter for `-quickfix`; see `-quickfix:help` or use `-quickfix:any` to apply all available quick fixes.")

}else {

valparsed= settings.quickfix.value.map(WConf.parseFilter(_, rootDirPrefix))

valmsgs= parsed.collect {caseLeft(msg)=> msg }

if (msgs.nonEmpty) {

globalError(s"Failed to parse `-quickfix` filters:${settings.quickfix.value.mkString(",")}\n${msgs.mkString("\n")}")

}else parsed.collect {caseRight(f)=> f }

}

}

privatevalskipRewriteAction=Set(Action.WarningSummary,Action.InfoSummary,Action.Silent)

privatedefregisterTextEdit(m:Message):Boolean=

if (quickfixFilters.exists(f=> f.matches(m))) {

textEdits.addAll(m.actions.flatMap(_.edits))

}

privatedefregisterErrorTextEdit(pos:Position,msg:String,actions:List[CodeAction]):Boolean= {

valmatches= quickfixFilters.exists({

caseMessageFilter.Any=>true

casemp:MessageFilter.MessagePattern=> mp.check(msg)

casesp:MessageFilter.SourcePattern=> sp.check(pos)

case _=>false

})

if (matches)

textEdits.addAll(actions.flatMap(_.edits))

matches

}

privatevalsummarizedWarnings: mutable.Map[WarningCategory, mutable.LinkedHashMap[Position,Message]]= mutable.HashMap.empty

privatevalsummarizedInfos: mutable.Map[WarningCategory, mutable.LinkedHashMap[Position,Message]]= mutable.HashMap.empty

privatevalsuppressions: mutable.LinkedHashMap[SourceFile, mutable.ListBuffer[Suppression]]= mutable.LinkedHashMap.empty

privatevalsuppressionsComplete: mutable.Set[SourceFile]= mutable.Set.empty

privatevalsuspendedMessages: mutable.LinkedHashMap[SourceFile, mutable.LinkedHashSet[Message]]= mutable.LinkedHashMap.empty

privatevaltextEdits: mutable.Set[TextEdit]= mutable.Set.empty

definitFrom(old:PerRunReporting):Unit= {

suspendedMessages++= old.suspendedMessages

sups<- suppressions.remove(source)

sup<- sups.reverse

}if (!sup.used&&!sup.synthetic) issueWarning(Message.Plain(sup.annotPos,"@nowarn annotation does not suppress any warnings",WarningCategory.UnusedNowarn,"",Nil))

quickfix(textEdits)

textEdits.clear()

}

defreportSuspendedMessages(unit:CompilationUnit):Unit= {

}

privatedefissueWarning(warning:Message):Unit= {

valaction= wconf.action(warning)

valquickfixed= {

if (!skipRewriteAction(action)&& registerTextEdit(warning))s"[rewritten by -quickfix]${warning.msg}"

elseif (warning.actions.exists(_.edits.nonEmpty))s"[quick fix available]${warning.msg}"

else warning.msg

}

defifNonEmpty(kind:String,filter:String)=if (filter.nonEmpty)s",$kind=$filter"else""

s"msg=<part of the message>, cat=${warning.category.name}"+

defhelpMsg(kind:String,isError:Boolean=false)=

s"${warning.msg}${scala3migration(isError)}\nApplicable -Wconf / @nowarn filters for this$kind:$filterHelp"

wconf.action(warning)match {

s"$quickfixed${scala3migration(isError)}\nApplicable -Wconf / @nowarn filters for this$kind:$filterHelp"

actionmatch {

caseAction.Error=> reporter.error(warning.pos, helpMsg("fatal warning", isError=true), warning.actions)

caseAction.Warning=> reporter.warning(warning.pos,warning.msg, warning.actions)

caseAction.Warning=> reporter.warning(warning.pos,quickfixed, warning.actions)

caseAction.WarningVerbose=> reporter.warning(warning.pos, helpMsg("warning"), warning.actions)

caseAction.Info=> reporter.echo(warning.pos,warning.msg, warning.actions)

caseAction.Info=> reporter.echo(warning.pos,quickfixed, warning.actions)

caseAction.InfoVerbose=> reporter.echo(warning.pos, helpMsg("message"), warning.actions)

case a@ (Action.WarningSummary|Action.InfoSummary)=>

valm= summaryMap(a, warning.category.summaryCategory)

defwarning(pos:Position,msg:String,category:WarningCategory,site:Symbol,origin:String):Unit=

issueIfNotSuppressed(Message.Origin(pos, msg, category, siteName(site), origin, actions=Nil))

deferror(pos:Position,msg:String,actions:List[CodeAction]):Unit= {

valquickfixed= {

if (registerErrorTextEdit(pos, msg, actions))s"[rewritten by -quickfix]$msg"

elseif (actions.exists(_.edits.nonEmpty))s"[quick fix available]$msg"

else msg

}

reporter.error(pos, quickfixed, actions)

}

defdeprecationWarnings:List[(Position,String)]= summaryMap(Action.WarningSummary,WarningCategory.Deprecation).toList.map(p=> (p._1, p._2.msg))

defuncheckedWarnings:List[(Position,String)]= summaryMap(Action.WarningSummary,WarningCategory.Unchecked).toList.map(p=> (p._1, p._2.msg))

if (settings.fatalWarnings.value&& reporter.hasWarnings)

reporter.error(NoPosition,"No warnings can be incurred under -Werror.")

}

privateobjectquickfix {

defcodeOf(pos:Position,source:SourceFile):String=

if (pos.start< pos.end)newString(source.content.slice(pos.start, pos.end))

else {

valline= source.offsetToLine(pos.point)

valcode= source.lines(line).next()

valcaret=""* (pos.point- source.lineToOffset(line))+"^"

s"$code\n$caret"

}

defcheckNoOverlap(patches:List[TextEdit],source:SourceFile):Boolean= {

for (List(p1, p2)<- patches.sliding(2)if p1.position.end> p2.position.start) {

ok=false

s"""overlapping quick fixes in${source.file.file.getAbsolutePath}:

|add `${p1.newText}` at

|${codeOf(p1.position, source)}

|add `${p2.newText}` at

|${codeOf(p2.position, source)}""".stripMargin.trim

issueWarning(Message.Plain(p1.position, msg,WarningCategory.Other,"",Nil))

}

ok

}

defunderlyingFile(source:SourceFile):Option[Path]= {

valfileClass= source.file.getClass.getName

valp=if (fileClass.endsWith("xsbt.ZincVirtualFile")) {

importscala.language.reflectiveCalls

valpath= source.file.asInstanceOf[ {defunderlying(): {defid():String}}].underlying().id()

Some(Paths.get(path))

}else

Option(source.file.file).map(_.toPath)

valr= p.filter(Files.exists(_))

if (r.isEmpty)

issueWarning(Message.Plain(NoPosition,s"Failed to apply quick fixes, file does not exist:${source.file}",WarningCategory.Other,"",Nil))

r

}

valencoding=Charset.forName(settings.encoding.value)

definsertEdits(sourceChars:Array[Char],edits:List[TextEdit],file:Path):Array[Byte]= {

valpatchedChars=newArray[Char](sourceChars.length+ edits.iterator.map(_.delta).sum)

@tailrecdefloop(edits:List[TextEdit],inIdx:Int,outIdx:Int):Unit= {

defcopy(upTo:Int):Int= {

valuntouched= upTo- inIdx

System.arraycopy(sourceChars, inIdx, patchedChars, outIdx, untouched)

outIdx+ untouched

}

editsmatch {

case e:: es=>

valoutNew= copy(e.position.start)

e.newText.copyToArray(patchedChars, outNew)

loop(es, e.position.end, outNew+ e.newText.length)

case _=>

valoutNew= copy(sourceChars.length)

if (outNew!= patchedChars.length)

issueWarning(Message.Plain(NoPosition,s"Unexpected content length when applying quick fixes; verify the changes to${file.toFile.getAbsolutePath}",WarningCategory.Other,"",Nil))

}

}

loop(edits,0,0)

newString(patchedChars).getBytes(encoding)

}

defapply(edits: mutable.Set[TextEdit]):Unit= {

for ((source, edits)<- edits.groupBy(_.position.source).view.mapValues(_.toList.sortBy(_.position.start))) {

if (checkNoOverlap(edits, source)) {

underlyingFile(source) foreach { file=>

valsourceChars=newString(Files.readAllBytes(file), encoding).toCharArray

tryFiles.write(file, insertEdits(sourceChars, edits, file))

catch {

casee:IOException=>

issueWarning(Message.Plain(NoPosition,s"Failed to apply quick fixes to${file.toFile.getAbsolutePath}\n${e.getMessage}",WarningCategory.Other,"",Nil))

}

}

}

}

}

}

}

}

}

finalcaseclassMessagePattern(pattern:Regex)extendsMessageFilter {

defmatches(message:Message):Boolean= pattern.findFirstIn(message.msg).nonEmpty

defcheck(msg:String)= pattern.findFirstIn(msg).nonEmpty

defmatches(message:Message):Boolean= check(message.msg)

}

finalcaseclassSitePattern(pattern:Regex)extendsMessageFilter {

finalcaseclassSourcePattern(pattern:Regex)extendsMessageFilter {

private[this]valcache= mutable.Map.empty[SourceFile,Boolean]

defmatches(message:Message):Boolean= cache.getOrElseUpdate(message.pos.source, {

valsourcePath=message.pos.source.file.canonicalPath.replace("\\","/")

defcheck(pos:Position)= cache.getOrElseUpdate(pos.source, {

valsourcePath= pos.source.file.canonicalPath.replace("\\","/")

pattern.findFirstIn(sourcePath).nonEmpty

})

defmatches(message:Message):Boolean= check(message.pos)

}

finalcaseclassDeprecatedOrigin(pattern:Regex)extendsMessageFilter {

valsyntaxErrors=newListBuffer[(Int,String,List[CodeAction])]

defshowSyntaxErrors()=

for ((offset, msg, actions)<- syntaxErrors)

reporter.error(o2p(offset), msg, actions)

runReporting.error(o2p(offset), msg, actions)

overridedefsyntaxError(offset:Offset,msg:String,actions:List[CodeAction]):Unit= {

if (smartParsing) syntaxErrors+= ((offset, msg, actions))

elsereporter.error(o2p(offset), msg, actions)

elserunReporting.error(o2p(offset), msg, actions)

}

overridedefincompleteInputError(msg:String,actions:List[CodeAction]):Unit= {

valnowarn=BooleanSetting ("-nowarn","Generate no warnings.") withAbbreviation"--no-warnings" withPostSetHook { s=>if (s.value) maxwarns.value=0 }

valprint=BooleanSetting ("-print","Print program with Scala-specific features removed.") withAbbreviation"--print"

valquickfix=MultiStringSetting(

"-quickfix",

"filters",

"Apply quick fixes provided by the compiler for warnings and errors to source files",

helpText=Some(

|""".stripMargin),

prepend=true)

ChoiceSetting("-release","release","Compile for a version of the Java API and target class file.",AllTargetVersions, normalizeTarget(javaSpecVersion))

.withPostSetHook { setting=>

caseclassTextEdit(position:Position,newText:String)

caseclassTextEdit(position:Position,newText:String) {

defdelta:Int= newText.length- (position.end- position.start)

}

auto-application.scala:6: error: Int does not take parameters

("": Object).##()

^

auto-application.scala:9: warning: Auto-application to `()` is deprecated. Supply the empty argument list `()` explicitly to invoke method meth,

auto-application.scala:9: warning:[quick fix available]Auto-application to `()` is deprecated. Supply the empty argument list `()` explicitly to invoke method meth,

or remove the empty argument list from its definition (Java-defined methods are exempt).

In Scala 3, an unapplied method like this will be eta-expanded into a function.

meth // warn, auto-application (of nilary methods) is deprecated

for-comprehension-old.scala:6: error: `val` keyword in for comprehension is unsupported: just remove `val`

for-comprehension-old.scala:6: error:[quick fix available]`val` keyword in for comprehension is unsupported: just remove `val`

for (val x <- 1 to 5 ; y = x) yield x+y // fail

^

for-comprehension-old.scala:7: error: `val` keyword in for comprehension is unsupported: just remove `val`

for-comprehension-old.scala:7: error:[quick fix available]`val` keyword in for comprehension is unsupported: just remove `val`

for (val x <- 1 to 5 ; val y = x) yield x+y // fail

^

for-comprehension-old.scala:11: error: `val` keyword in for comprehension is unsupported: just remove `val`

for-comprehension-old.scala:11: error:[quick fix available]`val` keyword in for comprehension is unsupported: just remove `val`

for (z <- 1 to 2 ; val x <- 1 to 5 ; y = x) yield x+y // fail

^

for-comprehension-old.scala:12: error: `val` keyword in for comprehension is unsupported: just remove `val`

for-comprehension-old.scala:12: error:[quick fix available]`val` keyword in for comprehension is unsupported: just remove `val`

for (z <- 1 to 2 ; val x <- 1 to 5 ; val y = x) yield x+y // fail

^

for-comprehension-old.scala:5: warning: `val` keyword in for comprehension is deprecated: instead, bind the value without `val`

for-comprehension-old.scala:5: warning:[quick fix available]`val` keyword in for comprehension is deprecated: instead, bind the value without `val`

for (x <- 1 to 5 ; val y = x) yield x+y // fail

^

for-comprehension-old.scala:7: warning: `val` keyword in for comprehension is deprecated: instead, bind the value without `val`

for-comprehension-old.scala:7: warning:[quick fix available]`val` keyword in for comprehension is deprecated: instead, bind the value without `val`

for (val x <- 1 to 5 ; val y = x) yield x+y // fail

^

for-comprehension-old.scala:10: warning: `val` keyword in for comprehension is deprecated: instead, bind the value without `val`

for-comprehension-old.scala:10: warning:[quick fix available]`val` keyword in for comprehension is deprecated: instead, bind the value without `val`

for (z <- 1 to 2 ; x <- 1 to 5 ; val y = x) yield x+y // fail

^

for-comprehension-old.scala:12: warning: `val` keyword in for comprehension is deprecated: instead, bind the value without `val`

for-comprehension-old.scala:12: warning:[quick fix available]`val` keyword in for comprehension is deprecated: instead, bind the value without `val`

for (z <- 1 to 2 ; val x <- 1 to 5 ; val y = x) yield x+y // fail

^

4 warnings