1 package dotty.tools
2 package dotc
3 package reporting
4 package diagnostic
5 
6 import dotc.core._
7 import Contexts.Context
8 import Decorators._
9 import Symbols._
10 import Names._
11 import NameOps._
12 import Types._
13 import util.SourcePosition
14 import config.Settings.Setting
15 import interfaces.Diagnostic.{ERROR, INFO, WARNING}
16 import dotc.parsing.Scanners.Token
17 import dotc.parsing.Tokens
18 import printing.Highlighting._
19 import printing.Formatting
20 import ErrorMessageID._
21 import Denotations.SingleDenotation
22 import dotty.tools.dotc.ast.Trees
23 import dotty.tools.dotc.config.ScalaVersion
24 import dotty.tools.dotc.core.Flags._
25 import dotty.tools.dotc.core.SymDenotations.SymDenotation
26 import scala.util.control.NonFatal
27 
28 object messages {
29 
30   // `MessageContainer`s to be consumed by `Reporter` ---------------------- //
31   class Error(
32     msgFn: => Message,
33     pos: SourcePosition
34   ) extends MessageContainer(msgFn, pos, ERROR)
35 
36   class Warning(
37     msgFn: => Message,
38     pos: SourcePosition
39   ) extends MessageContainer(msgFn, pos, WARNING) {
40     def toError: Error = new Error(msgFn, pos)
41   }
42 
43   class Info(
44     msgFn: => Message,
45     pos: SourcePosition
46   ) extends MessageContainer(msgFn, pos, INFO)
47 
48   abstract class ConditionalWarning(
49     msgFn: => Message,
50     pos: SourcePosition
51   ) extends Warning(msgFn, pos) {
52     def enablingOption(implicit ctx: Context): Setting[Boolean]
53   }
54 
55   class FeatureWarning(
56     msgFn: => Message,
57     pos: SourcePosition
58   ) extends ConditionalWarning(msgFn, pos) {
59     def enablingOption(implicit ctx: Context) = ctx.settings.feature
60   }
61 
62   class UncheckedWarning(
63     msgFn: => Message,
64     pos: SourcePosition
65   ) extends ConditionalWarning(msgFn, pos) {
66     def enablingOption(implicit ctx: Context) = ctx.settings.unchecked
67   }
68 
69   class DeprecationWarning(
70     msgFn: => Message,
71     pos: SourcePosition
72   ) extends ConditionalWarning(msgFn, pos) {
73     def enablingOption(implicit ctx: Context) = ctx.settings.deprecation
74   }
75 
76   class MigrationWarning(
77     msgFn: => Message,
78     pos: SourcePosition
79   ) extends ConditionalWarning(msgFn, pos) {
80     def enablingOption(implicit ctx: Context) = ctx.settings.migration
81   }
82 
83   /**  Messages
84     *  ========
85     *  The role of messages is to provide the necessary details for a simple to
86     *  understand diagnostic event. Each message can be turned into a message
87     *  container (one of the above) by calling the appropriate method on them.
88     *  For instance:
89     *
90     *  ```scala
91     *  EmptyCatchBlock(tree).error(pos)   // res: Error
92     *  EmptyCatchBlock(tree).warning(pos) // res: Warning
93     *  ```
94     */
95   import ast.Trees._
96   import ast.untpd
97   import ast.tpd
98 
99   /** Helper methods for messages */
100   def implicitClassRestrictionsText(implicit ctx: Context) =
101     hl"""|${NoColor("For a full list of restrictions on implicit classes visit")}
102          |${Blue("http://docs.scala-lang.org/overviews/core/implicit-classes.html")}"""
103 
104 
105   // Syntax Errors ---------------------------------------------------------- //
106   abstract class EmptyCatchOrFinallyBlock(tryBody: untpd.Tree, errNo: ErrorMessageID)(implicit ctx: Context)
107   extends Message(EmptyCatchOrFinallyBlockID) {
108     val explanation = {
109       val tryString = tryBody match {
110         case Block(Nil, untpd.EmptyTree) => "{}"
111         case _ => tryBody.show
112       }
113 
114       val code1 =
115         s"""|import scala.util.control.NonFatal
116             |
117             |try $tryString catch {
118             |  case NonFatal(e) => ???
119             |}""".stripMargin
120 
121       val code2 =
122         s"""|try $tryString finally {
123             |  // perform your cleanup here!
124             |}""".stripMargin
125 
126       hl"""|A ${"try"} expression should be followed by some mechanism to handle any exceptions
127            |thrown. Typically a ${"catch"} expression follows the ${"try"} and pattern matches
128            |on any expected exceptions. For example:
129            |
130            |$code1
131            |
132            |It is also possible to follow a ${"try"} immediately by a ${"finally"} - letting the
133            |exception propagate - but still allowing for some clean up in ${"finally"}:
134            |
135            |$code2
136            |
137            |It is recommended to use the ${"NonFatal"} extractor to catch all exceptions as it
138            |correctly handles transfer functions like ${"return"}."""
139     }
140   }
141 
142   case class EmptyCatchBlock(tryBody: untpd.Tree)(implicit ctx: Context)
143   extends EmptyCatchOrFinallyBlock(tryBody, EmptyCatchBlockID) {
144     val kind = "Syntax"
145     val msg =
146       hl"""|The ${"catch"} block does not contain a valid expression, try
147            |adding a case like - `${"case e: Exception =>"}` to the block"""
148   }
149 
150   case class EmptyCatchAndFinallyBlock(tryBody: untpd.Tree)(implicit ctx: Context)
151   extends EmptyCatchOrFinallyBlock(tryBody, EmptyCatchAndFinallyBlockID) {
152     val kind = "Syntax"
153     val msg =
154       hl"""|A ${"try"} without ${"catch"} or ${"finally"} is equivalent to putting
155            |its body in a block; no exceptions are handled."""
156   }
157 
158   case class DeprecatedWithOperator()(implicit ctx: Context)
159   extends Message(DeprecatedWithOperatorID) {
160     val kind = "Syntax"
161     val msg =
162       hl"""${"with"} as a type operator has been deprecated; use `&' instead"""
163     val explanation =
164       hl"""|Dotty introduces intersection types - `&' types. These replace the
165            |use of the ${"with"} keyword. There are a few differences in
166            |semantics between intersection types and using `${"with"}'."""
167   }
168 
169   case class CaseClassMissingParamList(cdef: untpd.TypeDef)(implicit ctx: Context)
170   extends Message(CaseClassMissingParamListID) {
171     val kind = "Syntax"
172     val msg =
173       hl"""|A ${"case class"} must have at least one parameter list"""
174 
175     val explanation =
176       hl"""|${cdef.name} must have at least one parameter list, if you would rather
177            |have a singleton representation of ${cdef.name}, use a "${"case object"}".
178            |Or, add an explicit `()' as a parameter list to ${cdef.name}."""
179   }
180 
181   case class AnonymousFunctionMissingParamType(param: untpd.ValDef,
182                                                args: List[untpd.Tree],
183                                                tree: untpd.Function,
184                                                pt: Type)
185                                               (implicit ctx: Context)
186   extends Message(AnonymousFunctionMissingParamTypeID) {
187     val kind = "Syntax"
188 
189     val msg = {
190       val ofFun =
191         if (MethodType.syntheticParamNames(args.length + 1) contains param.name)
192           i" of expanded function:\n$tree"
193         else
194           ""
195 
196       i"""missing parameter type
197          |
198          |The argument types of an anonymous function must be fully known. (SLS 8.5)
199          |Expected type: $pt
200          |Missing type for parameter ${param.name}$ofFun"""
201     }
202 
203     val explanation =
204       hl"""|Anonymous functions must define a type. For example, if you define a function like this one:
205            |
206            |${"val f = { case x: Int => x + 1 }"}
207            |
208            |Make sure you give it a type of what you expect to match and help the type inference system:
209            |
210            |${"val f: Any => Int = { case x: Int => x + 1 }"} """
211   }
212 
213   case class WildcardOnTypeArgumentNotAllowedOnNew()(implicit ctx: Context)
214   extends Message(WildcardOnTypeArgumentNotAllowedOnNewID) {
215     val kind = "syntax"
216     val msg = "type argument must be fully defined"
217 
218     val code1 =
219       """
220         |object TyperDemo {
221         |  class Team[A]
222         |  val team = new Team[_]
223         |}
224       """.stripMargin
225 
226     val code2 =
227       """
228         |object TyperDemo {
229         |  class Team[A]
230         |  val team = new Team[Int]
231         |}
232       """.stripMargin
233 
234     val explanation =
235       hl"""|Wildcard on arguments is not allowed when declaring a new type.
236            |
237            |Given the following example:
238            |
239            |$code1
240            |
241            |You must complete all the type parameters, for instance:
242            |
243            |$code2 """
244   }
245 
246 
247   // Type Errors ------------------------------------------------------------ //
248   case class DuplicateBind(bind: untpd.Bind, tree: untpd.CaseDef)(implicit ctx: Context)
249   extends Message(DuplicateBindID) {
250     val kind = "Naming"
251     val msg = em"duplicate pattern variable: `${bind.name}`"
252 
253     val explanation = {
254       val pat = tree.pat.show
255       val guard = tree.guard match {
256         case untpd.EmptyTree => ""
257         case guard => s"if ${guard.show}"
258       }
259 
260       val body = tree.body match {
261         case Block(Nil, untpd.EmptyTree) => ""
262         case body => s" ${body.show}"
263       }
264 
265       val caseDef = s"case $pat$guard => $body"
266 
267       hl"""|For each ${"case"} bound variable names have to be unique. In:
268            |
269            |$caseDef
270            |
271            |`${bind.name}` is not unique. Rename one of the bound variables!"""
272     }
273   }
274 
275   case class MissingIdent(tree: untpd.Ident, treeKind: String, name: String)(implicit ctx: Context)
276   extends Message(MissingIdentID) {
277     val kind = "Unbound Identifier"
278     val msg = em"not found: $treeKind$name"
279 
280     val explanation = {
281       hl"""|The identifier for `$treeKind$name` is not bound, that is,
282            |no declaration for this identifier can be found.
283            |That can happen for instance if $name or its declaration has either been
284            |misspelt, or if you're forgetting an import"""
285     }
286   }
287 
288   case class TypeMismatch(found: Type, expected: Type, whyNoMatch: String = "", implicitFailure: String = "")(implicit ctx: Context)
289   extends Message(TypeMismatchID) {
290     val kind = "Type Mismatch"
291     val msg = {
292       val (where, printCtx) = Formatting.disambiguateTypes(found, expected)
293       val (fnd, exp) = Formatting.typeDiff(found, expected)(printCtx)
294       s"""|found:    $fnd
295           |required: $exp
296           |
297           |$where""".stripMargin + whyNoMatch + implicitFailure
298     }
299 
300     val explanation = ""
301   }
302 
303   case class NotAMember(site: Type, name: Name, selected: String)(implicit ctx: Context)
304   extends Message(NotAMemberID) {
305     val kind = "Member Not Found"
306 
307     //println(i"site = $site, decls = ${site.decls}, source = ${site.widen.typeSymbol.sourceFile}") //DEBUG
308 
309     val msg = {
310       import core.Flags._
311       val maxDist = 3
312       val decls = site.decls.toList.flatMap { sym =>
313         if (sym.flagsUNSAFE.is(Synthetic | PrivateOrLocal) || sym.isConstructor) Nil
314         else List((sym.name.show, sym))
315       }
316 
317       // Calculate Levenshtein distance
318       def distance(n1: Iterable[_], n2: Iterable[_]) =
319         n1.foldLeft(List.range(0, n2.size)) { (prev, x) =>
320           (prev zip prev.tail zip n2).scanLeft(prev.head + 1) {
321             case (h, ((d, v), y)) => math.min(
322               math.min(h + 1, v + 1),
323               if (x == y) d else d + 1
324             )
325           }
326         }.last
327 
328       // Count number of wrong characters
329       def incorrectChars(x: (String, Int, Symbol)): (String, Symbol, Int) = {
330         val (currName, _, sym) = x
331         val matching = name.show.zip(currName).foldLeft(0) {
332           case (acc, (x,y)) => if (x != y) acc + 1 else acc
333         }
334         (currName, sym, matching)
335       }
336 
337       // Get closest match in `site`
338       val closest =
339         decls
340         .map { case (n, sym) => (n, distance(n, name.show), sym) }
341         .collect { case (n, dist, sym) if dist <= maxDist => (n, dist, sym) }
342         .groupBy(_._2).toList
343         .sortBy(_._1)
344         .headOption.map(_._2).getOrElse(Nil)
345         .map(incorrectChars).toList
346         .sortBy(_._3)
347         .take(1).map { case (n, sym, _) => (n, sym) }
348 
349       val siteName = site match {
350         case site: NamedType => site.name.show
351         case site => i"$site"
352       }
353 
354       val closeMember = closest match {
355         case (n, sym) :: Nil => hl""" - did you mean `${s"$siteName.$n"}`?"""
356         case Nil => ""
357         case _ => assert(
358           false,
359           "Could not single out one distinct member to match on input with"
360         )
361       }
362 
363       ex"$selected `$name` is not a member of ${site.widen}$closeMember"
364     }
365 
366     val explanation = ""
367   }
368 
369   case class EarlyDefinitionsNotSupported()(implicit ctx: Context)
370   extends Message(EarlyDefinitionsNotSupportedID) {
371     val kind = "Syntax"
372     val msg = "early definitions are not supported; use trait parameters instead"
373 
374     val explanation = {
375       val code1 =
376         """|trait Logging {
377            |  val f: File
378            |  f.open()
379            |  onExit(f.close())
380            |  def log(msg: String) = f.write(msg)
381            |}
382            |
383            |class B extends Logging {
384            |  val f = new File("log.data") // triggers a NullPointerException
385            |}
386            |
387            |// early definition gets around the NullPointerException
388            |class C extends {
389            |  val f = new File("log.data")
390            |} with Logging""".stripMargin
391 
392       val code2 =
393         """|trait Logging(f: File) {
394            |  f.open()
395            |  onExit(f.close())
396            |  def log(msg: String) = f.write(msg)
397            |}
398            |
399            |class C extends Logging(new File("log.data"))""".stripMargin
400 
401       hl"""|Earlier versions of Scala did not support trait parameters and "early
402            |definitions" (also known as "early initializers") were used as an alternative.
403            |
404            |Example of old syntax:
405            |
406            |$code1
407            |
408            |The above code can now be written as:
409            |
410            |$code2
411            |"""
412     }
413   }
414 
415   case class TopLevelImplicitClass(cdef: untpd.TypeDef)(implicit ctx: Context)
416   extends Message(TopLevelImplicitClassID) {
417     val kind = "Syntax"
418     val msg = hl"""An ${"implicit class"} may not be top-level"""
419 
420     val explanation = {
421       val TypeDef(name, impl @ Template(constr0, parents, self, _)) = cdef
422       val exampleArgs =
423         if(constr0.vparamss.isEmpty) "..."
424         else constr0.vparamss(0).map(_.withMods(untpd.Modifiers()).show).mkString(", ")
425       def defHasBody[T] = impl.body.exists(!_.isEmpty)
426       val exampleBody = if (defHasBody) "{\n ...\n }" else ""
427       hl"""|There may not be any method, member or object in scope with the same name as
428            |the implicit class and a case class automatically gets a companion object with
429            |the same name created by the compiler which would cause a naming conflict if it
430            |were allowed.
431            |
432            |""" + implicitClassRestrictionsText + hl"""|
433            |
434            |To resolve the conflict declare ${cdef.name} inside of an ${"object"} then import the class
435            |from the object at the use site if needed, for example:
436            |
437            |object Implicits {
438            |  implicit class ${cdef.name}($exampleArgs)$exampleBody
439            |}
440            |
441            |// At the use site:
442            |import Implicits.${cdef.name}"""
443     }
444   }
445 
446   case class ImplicitCaseClass(cdef: untpd.TypeDef)(implicit ctx: Context)
447   extends Message(ImplicitCaseClassID) {
448     val kind = "Syntax"
449     val msg = hl"""A ${"case class"} may not be defined as ${"implicit"}"""
450 
451     val explanation =
452       hl"""|implicit classes may not be case classes. Instead use a plain class:
453            |
454            |implicit class ${cdef.name}...
455            |
456            |""" + implicitClassRestrictionsText
457   }
458 
459   case class ImplicitClassPrimaryConstructorArity()(implicit ctx: Context)
460   extends Message(ImplicitClassPrimaryConstructorArityID){
461     val kind = "Syntax"
462     val msg = "Implicit classes must accept exactly one primary constructor parameter"
463     val explanation = {
464       val example = "implicit class RichDate(date: java.util.Date)"
465       hl"""Implicit classes may only take one non-implicit argument in their constructor. For example:
466           |
467           | $example
468           |
469           |While it’s possible to create an implicit class with more than one non-implicit argument,
470           |such classes aren’t used during implicit lookup.
471           |""" + implicitClassRestrictionsText
472     }
473   }
474 
475   case class ObjectMayNotHaveSelfType(mdef: untpd.ModuleDef)(implicit ctx: Context)
476   extends Message(ObjectMayNotHaveSelfTypeID) {
477     val kind = "Syntax"
478     val msg = hl"""${"object"}s must not have a self ${"type"}"""
479 
480     val explanation = {
481       val untpd.ModuleDef(name, tmpl) = mdef
482       val ValDef(_, selfTpt, _) = tmpl.self
483       hl"""|${"object"}s must not have a self ${"type"}:
484            |
485            |Consider these alternative solutions:
486            |  - Create a trait or a class instead of an object
487            |  - Let the object extend a trait containing the self type:
488            |
489            |    object $name extends ${selfTpt.show}"""
490     }
491   }
492 
493   case class TupleTooLong(ts: List[untpd.Tree])(implicit ctx: Context)
494   extends Message(TupleTooLongID) {
495     import Definitions.MaxTupleArity
496     val kind = "Syntax"
497     val msg = hl"""A ${"tuple"} cannot have more than ${MaxTupleArity} members"""
498 
499     val explanation = {
500       val members = ts.map(_.showSummary).grouped(MaxTupleArity)
501       val nestedRepresentation = members.map(_.mkString(", ")).mkString(")(")
502       hl"""|This restriction will be removed in the future.
503            |Currently it is possible to use nested tuples when more than $MaxTupleArity are needed, for example:
504            |
505            |((${nestedRepresentation}))"""
506     }
507   }
508 
509   case class RepeatedModifier(modifier: String)(implicit ctx:Context)
510   extends Message(RepeatedModifierID) {
511     val kind = "Syntax"
512     val msg = hl"""repeated modifier $modifier"""
513 
514     val explanation = {
515       val code1 = hl"""private private val Origin = Point(0, 0)"""
516       val code2 = hl"""private final val Origin = Point(0, 0)"""
517       hl"""This happens when you accidentally specify the same modifier twice.
518            |
519            |Example:
520            |
521            |$code1
522            |
523            |instead of
524            |
525            |$code2
526            |
527            |"""
528     }
529   }
530 
531   case class InterpolatedStringError()(implicit ctx:Context)
532   extends Message(InterpolatedStringErrorID) {
533     val kind = "Syntax"
534     val msg = "error in interpolated string: identifier or block expected"
535     val explanation = {
536       val code1 = "s\"$new Point(0, 0)\""
537       val code2 = "s\"${new Point(0, 0)}\""
538       hl"""|This usually happens when you forget to place your expressions inside curly braces.
539            |
540            |$code1
541            |
542            |should be written as
543            |
544            |$code2
545            |"""
546     }
547   }
548 
549   case class UnboundPlaceholderParameter()(implicit ctx:Context)
550   extends Message(UnboundPlaceholderParameterID) {
551     val kind = "Syntax"
552     val msg = "unbound placeholder parameter; incorrect use of `_`"
553     val explanation =
554       hl"""|The `_` placeholder syntax was used where it could not be bound.
555            |Consider explicitly writing the variable binding.
556            |
557            |This can be done by replacing `_` with a variable (eg. `x`)
558            |and adding ${"x =>"} where applicable.
559            |
560            |Example before:
561            |
562            |${"{ _ }"}
563            |
564            |Example after:
565            |
566            |${"x => { x }"}
567            |
568            |Another common occurrence for this error is defining a val with `_`:
569            |
570            |${"val a = _"}
571            |
572            |But this val definition isn't very useful, it can never be assigned
573            |another value. And thus will always remain uninitialized.
574            |Consider replacing the ${"val"} with ${"var"}:
575            |
576            |${"var a = _"}
577            |
578            |Note that this use of `_` is not placeholder syntax,
579            |but an uninitialized var definition.
580            |Only fields can be left uninitialized in this manner; local variables
581            |must be initialized.
582            |"""
583   }
584 
585   case class IllegalStartSimpleExpr(illegalToken: String)(implicit ctx: Context)
586   extends Message(IllegalStartSimpleExprID) {
587     val kind = "Syntax"
588     val msg = "illegal start of simple expression"
589     val explanation = {
590       hl"""|An expression yields a value. In the case of the simple expression, this error
591            |commonly occurs when there's a missing parenthesis or brace. The reason being
592            |that a simple expression is one of the following:
593            |
594            |- Block
595            |- Expression in parenthesis
596            |- Identifier
597            |- Object creation
598            |- Literal
599            |
600            |which cannot start with ${Red(illegalToken)}."""
601     }
602   }
603 
604   case class MissingReturnType()(implicit ctx:Context)
605   extends Message(MissingReturnTypeID) {
606     val kind = "Syntax"
607     val msg = "missing return type"
608     val explanation =
609       hl"""|An abstract declaration must have a return type. For example:
610            |
611            |trait Shape {
612            |  def area: Double // abstract declaration returning a ${"Double"}
613            |}"""
614   }
615 
616   case class MissingReturnTypeWithReturnStatement(method: Symbol)(implicit ctx: Context)
617   extends Message(MissingReturnTypeWithReturnStatementID) {
618     val kind = "Syntax"
619     val msg = hl"$method has a return statement; it needs a result type"
620     val explanation =
621       hl"""|If a method contains a ${"return"} statement, it must have an
622            |explicit return type. For example:
623            |
624            |${"def good: Int /* explicit return type */ = return 1"}"""
625   }
626 
627   case class YieldOrDoExpectedInForComprehension()(implicit ctx: Context)
628   extends Message(YieldOrDoExpectedInForComprehensionID) {
629     val kind = "Syntax"
630     val msg = hl"${"yield"} or ${"do"} expected"
631 
632     val explanation =
633       hl"""|When the enumerators in a for comprehension are not placed in parentheses or
634            |braces, a ${"do"} or ${"yield"} statement is required after the enumerators
635            |section of the comprehension.
636            |
637            |You can save some keystrokes by omitting the parentheses and writing
638            |
639            |${"val numbers = for i <- 1 to 3 yield i"}
640            |
641            |  instead of
642            |
643            |${"val numbers = for (i <- 1 to 3) yield i"}
644            |
645            |but the ${"yield"} keyword is still required.
646            |
647            |For comprehensions that simply perform a side effect without yielding anything
648            |can also be written without parentheses but a ${"do"} keyword has to be
649            |included. For example,
650            |
651            |${"for (i <- 1 to 3) println(i)"}
652            |
653            |can be written as
654            |
655            |${"for i <- 1 to 3 do println(i) // notice the 'do' keyword"}
656            |
657            |"""
658   }
659 
660   case class ProperDefinitionNotFound()(implicit ctx: Context)
661   extends Message(ProperDefinitionNotFoundID) {
662     val kind = "Definition Not Found"
663     val msg = hl"""Proper definition was not found in ${"@usecase"}"""
664 
665     val explanation = {
666       val noUsecase =
667         "def map[B, That](f: A => B)(implicit bf: CanBuildFrom[List[A], B, That]): That"
668 
669       val usecase =
670         """|/** Map from List[A] => List[B]
671            |  *
672            |  * @usecase def map[B](f: A => B): List[B]
673            |  */
674            |def map[B, That](f: A => B)(implicit bf: CanBuildFrom[List[A], B, That]): That
675            |""".stripMargin
676 
677       hl"""|Usecases are only supported for ${"def"}s. They exist because with Scala's
678            |advanced type-system, we sometimes end up with seemingly scary signatures.
679            |The usage of these methods, however, needs not be - for instance the `map`
680            |function
681            |
682            |${"List(1, 2, 3).map(2 * _) // res: List(2, 4, 6)"}
683            |
684            |is easy to understand and use - but has a rather bulky signature:
685            |
686            |$noUsecase
687            |
688            |to mitigate this and ease the usage of such functions we have the ${"@usecase"}
689            |annotation for docstrings. Which can be used like this:
690            |
691            |$usecase
692            |
693            |When creating the docs, the signature of the method is substituted by the
694            |usecase and the compiler makes sure that it is valid. Because of this, you're
695            |only allowed to use ${"def"}s when defining usecases."""
696     }
697   }
698 
699   case class ByNameParameterNotSupported()(implicit ctx: Context)
700   extends Message(ByNameParameterNotSupportedID) {
701     val kind = "Syntax"
702     val msg = "By-name parameter type not allowed here."
703 
704     val explanation =
705       hl"""|By-name parameters act like functions that are only evaluated when referenced,
706            |allowing for lazy evaluation of a parameter.
707            |
708            |An example of using a by-name parameter would look like:
709            |${"def func(f: => Boolean) = f // 'f' is evaluated when referenced within the function"}
710            |
711            |An example of the syntax of passing an actual function as a parameter:
712            |${"def func(f: (Boolean => Boolean)) = f(true)"}
713            |
714            |or:
715            |
716            |${"def func(f: Boolean => Boolean) = f(true)"}
717            |
718            |And the usage could be as such:
719            |${"func(bool => // do something...)"}
720            |"""
721   }
722 
723   case class WrongNumberOfTypeArgs(fntpe: Type, expectedArgs: List[ParamInfo], actual: List[untpd.Tree])(implicit ctx: Context)
724   extends Message(WrongNumberOfTypeArgsID) {
725     val kind = "Syntax"
726 
727     private val expectedCount = expectedArgs.length
728     private val actualCount = actual.length
729     private val msgPrefix = if (actualCount > expectedCount) "Too many" else "Not enough"
730 
731     //TODO add def simpleParamName to ParamInfo
732     private val expectedArgString = expectedArgs
733       .map(_.paramName.unexpandedName.show)
734       .mkString("[", ", ", "]")
735 
736     private val actualArgString = actual.map(_.show).mkString("[", ", ", "]")
737 
738     private val prettyName =
739       try
740         fntpe.termSymbol match {
741           case NoSymbol => fntpe.show
742           case symbol   => symbol.showFullName
743         }
744       catch {
745         case NonFatal(ex) => fntpe.show
746       }
747 
748     val msg =
749       hl"""|${NoColor(msgPrefix)} type arguments for $prettyName$expectedArgString
750            |expected: $expectedArgString
751            |actual:   ${NoColor(actualArgString)}""".stripMargin
752 
753     val explanation = {
754       val tooManyTypeParams =
755         """|val tuple2: (Int, String) = (1, "one")
756            |val list: List[(Int, String)] = List(tuple2)""".stripMargin
757 
758       if (actualCount > expectedCount)
759         hl"""|You have supplied too many type parameters
760              |
761              |For example List takes a single type parameter (List[A])
762              |If you need to hold more types in a list then you need to combine them
763              |into another data type that can contain the number of types you need,
764              |In this example one solution would be to use a Tuple:
765              |
766              |${tooManyTypeParams}"""
767       else
768         hl"""|You have not supplied enough type parameters
769              |If you specify one type parameter then you need to specify every type parameter."""
770     }
771   }
772 
773   case class IllegalVariableInPatternAlternative()(implicit ctx: Context)
774   extends Message(IllegalVariableInPatternAlternativeID) {
775     val kind = "Syntax"
776     val msg = "Variables are not allowed in alternative patterns"
777     val explanation = {
778       val varInAlternative =
779         """|def g(pair: (Int,Int)): Int = pair match {
780            |  case (1, n) | (n, 1) => n
781            |  case _ => 0
782            |}""".stripMargin
783 
784       val fixedVarInAlternative =
785         """|def g(pair: (Int,Int)): Int = pair match {
786            |  case (1, n) => n
787            |  case (n, 1) => n
788            |  case _ => 0
789            |}""".stripMargin
790 
791       hl"""|Variables are not allowed within alternate pattern matches. You can workaround
792            |this issue by adding additional cases for each alternative. For example, the
793            |illegal function:
794            |
795            |$varInAlternative
796            |could be implemented by moving each alternative into a separate case:
797            |
798            |$fixedVarInAlternative"""
799     }
800   }
801 
802   case class IdentifierExpected(identifier: String)(implicit ctx: Context)
803   extends Message(IdentifierExpectedID) {
804     val kind = "Syntax"
805     val msg = "identifier expected"
806     val explanation = {
807       val wrongIdentifier = s"def foo: $identifier = {...}"
808       val validIdentifier = s"def foo = {...}"
809       hl"""|An identifier expected, but `$identifier` found. This could be because
810            |`$identifier` is not a valid identifier. As a workaround, the compiler could
811            |infer the type for you. For example, instead of:
812            |
813            |$wrongIdentifier
814            |
815            |Write your code like:
816            |
817            |$validIdentifier
818            |
819            |"""
820     }
821   }
822 
823   case class AuxConstructorNeedsNonImplicitParameter()(implicit ctx:Context)
824   extends Message(AuxConstructorNeedsNonImplicitParameterID) {
825     val kind = "Syntax"
826     val msg = "auxiliary constructor needs non-implicit parameter list"
827     val explanation =
828       hl"""|Only the primary constructor is allowed an ${"implicit"} parameter list;
829            |auxiliary constructors need non-implicit parameter lists. When a primary
830            |constructor has an implicit argslist, auxiliary constructors that call the
831            |primary constructor must specify the implicit value.
832            |
833            |To resolve this issue check for:
834            | - forgotten parenthesis on ${"this"} (${"def this() = { ... }"})
835            | - auxiliary constructors specify the implicit value
836            |"""
837   }
838 
839   case class IncorrectRepeatedParameterSyntax()(implicit ctx: Context)
840   extends Message(IncorrectRepeatedParameterSyntaxID) {
841     val kind = "Syntax"
842     val msg = "'*' expected"
843     val explanation =
844       hl"""|Expected * in '_*' operator.
845            |
846            |The '_*' operator can be used to supply a sequence-based argument
847            |to a method with a variable-length or repeated parameter. It is used
848            |to expand the sequence to a variable number of arguments, such that:
849            |func(args: _*) would expand to func(arg1, arg2 ... argN).
850            |
851            |Below is an example of how a method with a variable-length
852            |parameter can be declared and used.
853            |
854            |Squares the arguments of a variable-length parameter:
855            |${"def square(args: Int*) = args.map(a => a * a)"}
856            |
857            |Usage:
858            |${"square(1, 2, 3) // res0: List[Int] = List(1, 4, 9)"}
859            |
860            |Secondary Usage with '_*':
861            |${"val ints = List(2, 3, 4)  // ints: List[Int] = List(2, 3, 4)"}
862            |${"square(ints: _*)          // res1: List[Int] = List(4, 9, 16)"}
863            |""".stripMargin
864   }
865 
866   case class IllegalLiteral()(implicit ctx: Context)
867   extends Message(IllegalLiteralID) {
868     val kind = "Syntax"
869     val msg = "illegal literal"
870     val explanation =
871       hl"""|Available literals can be divided into several groups:
872            | - Integer literals: 0, 21, 0xFFFFFFFF, -42L
873            | - Floating Point Literals: 0.0, 1e30f, 3.14159f, 1.0e-100, .1
874            | - Boolean Literals: true, false
875            | - Character Literals: 'a', '\u0041', '\n'
876            | - String Literals: "Hello, World!"
877            | - null
878            |"""
879   }
880 
881   case class PatternMatchExhaustivity(uncovered: String)(implicit ctx: Context)
882   extends Message(PatternMatchExhaustivityID) {
883     val kind = "Pattern Match Exhaustivity"
884     val msg =
885       hl"""|match may not be exhaustive.
886            |
887            |It would fail on: $uncovered"""
888 
889 
890     val explanation =
891       hl"""|There are several ways to make the match exhaustive:
892            | - Add missing cases as shown in the warning
893            | - If an extractor always return 'Some(...)', write 'Some[X]' for its return type
894            | - Add a 'case _ => ...' at the end to match all remaining cases
895            |"""
896   }
897 
898   case class UncheckedTypePattern(msg: String)(implicit ctx: Context)
899     extends Message(UncheckedTypePatternID) {
900     val kind = "Pattern Match Exhaustivity"
901 
902     val explanation =
903       hl"""|Type arguments and type refinements are erased during compile time, thus it's
904            |impossible to check them at run-time.
905            |
906            |You can either replace the type arguments by `_` or use `@unchecked`.
907            |"""
908   }
909 
910   case class MatchCaseUnreachable()(implicit ctx: Context)
911   extends Message(MatchCaseUnreachableID) {
912     val kind = s"""Match ${hl"case"} Unreachable"""
913     val msg = "unreachable code"
914     val explanation = ""
915   }
916 
917   case class SeqWildcardPatternPos()(implicit ctx: Context)
918   extends Message(SeqWildcardPatternPosID) {
919     val kind = "Syntax"
920     val msg = "`_*' can be used only for last argument"
921     val explanation = {
922       val code =
923         """def sumOfTheFirstTwo(list: List[Int]): Int = list match {
924           |  case List(first, second, x:_*) => first + second
925           |  case _ => 0
926           |}"""
927       hl"""|Sequence wildcard pattern is expected at the end of an argument list.
928            |This pattern matches any remaining elements in a sequence.
929            |Consider the following example:
930            |
931            |$code
932            |
933            |Calling:
934            |
935            |${"sumOfTheFirstTwo(List(1, 2, 10))"}
936            |
937            |would give 3 as a result"""
938     }
939   }
940 
941   case class IllegalStartOfSimplePattern()(implicit ctx: Context)
942   extends Message(IllegalStartOfSimplePatternID) {
943     val kind = "Syntax"
944     val msg = "illegal start of simple pattern"
945     val explanation = {
946       val sipCode =
947         """def f(x: Int, y: Int) = x match {
948           |  case `y` => ...
949           |}
950         """
951       val constructorPatternsCode =
952         """case class Person(name: String, age: Int)
953           |
954           |def test(p: Person) = p match {
955           |  case Person(name, age) => ...
956           |}
957         """
958       val tupplePatternsCode =
959         """def swap(tuple: (String, Int)): (Int, String) = tuple match {
960           |  case (text, number) => (number, text)
961           |}
962         """
963       val patternSequencesCode =
964         """def getSecondValue(list: List[Int]): Int = list match {
965           |  case List(_, second, x:_*) => second
966           |  case _ => 0
967           |}"""
968       hl"""|Simple patterns can be divided into several groups:
969            |- Variable Patterns: ${"case x => ..."}.
970            |  It matches any value, and binds the variable name to that value.
971            |  A special case is the wild-card pattern _ which is treated as if it was a fresh
972            |  variable on each occurrence.
973            |
974            |- Typed Patterns: ${"case x: Int => ..."} or ${"case _: Int => ..."}.
975            |  This pattern matches any value matched by the specified type; it binds the variable
976            |  name to that value.
977            |
978            |- Literal Patterns: ${"case 123 => ..."} or ${"case 'A' => ..."}.
979            |  This type of pattern matches any value that is equal to the specified literal.
980            |
981            |- Stable Identifier Patterns:
982            |
983            |  $sipCode
984            |
985            |  the match succeeds only if the x argument and the y argument of f are equal.
986            |
987            |- Constructor Patterns:
988            |
989            |  $constructorPatternsCode
990            |
991            |  The pattern binds all object's fields to the variable names (name and age, in this
992            |  case).
993            |
994            |- Tuple Patterns:
995            |
996            |  $tupplePatternsCode
997            |
998            |  Calling:
999            |
1000            |  ${"""swap(("Luftballons", 99)"""}
1001            |
1002            |  would give ${"""(99, "Luftballons")"""} as a result.
1003            |
1004            |- Pattern Sequences:
1005            |
1006            |  $patternSequencesCode
1007            |
1008            |  Calling:
1009            |
1010            |  ${"getSecondValue(List(1, 10, 2))"}
1011            |
1012            |  would give 10 as a result.
1013            |  This pattern is possible because a companion object for the List class has a method
1014            |  with the following signature:
1015            |
1016            |  ${"def unapplySeq[A](x: List[A]): Some[List[A]]"}
1017            |"""
1018     }
1019   }
1020 
1021   case class PkgDuplicateSymbol(existing: Symbol)(implicit ctx: Context)
1022   extends Message(PkgDuplicateSymbolID) {
1023     val kind = "Duplicate Symbol"
1024     val msg = hl"trying to define package with same name as `$existing`"
1025     val explanation = ""
1026   }
1027 
1028   case class ExistentialTypesNoLongerSupported()(implicit ctx: Context)
1029   extends Message(ExistentialTypesNoLongerSupportedID) {
1030     val kind = "Syntax"
1031     val msg =
1032       hl"""|Existential types are no longer supported -
1033            |use a wildcard or dependent type instead"""
1034     val explanation =
1035       hl"""|The use of existential types is no longer supported.
1036            |
1037            |You should use a wildcard or dependent type instead.
1038            |
1039            |For example:
1040            |
1041            |Instead of using ${"forSome"} to specify a type variable
1042            |
1043            |${"List[T forSome { type T }]"}
1044            |
1045            |Try using a wildcard type variable
1046            |
1047            |${"List[_]"}
1048            |"""
1049   }
1050 
1051   case class UnboundWildcardType()(implicit ctx: Context)
1052   extends Message(UnboundWildcardTypeID) {
1053     val kind = "Syntax"
1054     val msg = "Unbound wildcard type"
1055     val explanation =
1056       hl"""|The wildcard type syntax (`_`) was used where it could not be bound.
1057            |Replace `_` with a non-wildcard type. If the type doesn't matter,
1058            |try replacing `_` with ${"Any"}.
1059            |
1060            |Examples:
1061            |
1062            |- Parameter lists
1063            |
1064            |  Instead of:
1065            |    ${"def foo(x: _) = ..."}
1066            |
1067            |  Use ${"Any"} if the type doesn't matter:
1068            |    ${"def foo(x: Any) = ..."}
1069            |
1070            |- Type arguments
1071            |
1072            |  Instead of:
1073            |    ${"val foo = List[_](1, 2)"}
1074            |
1075            |  Use:
1076            |    ${"val foo = List[Int](1, 2)"}
1077            |
1078            |- Type bounds
1079            |
1080            |  Instead of:
1081            |    ${"def foo[T <: _](x: T) = ..."}
1082            |
1083            |  Remove the bounds if the type doesn't matter:
1084            |    ${"def foo[T](x: T) = ..."}
1085            |
1086            |- ${"val"} and ${"def"} types
1087            |
1088            |  Instead of:
1089            |    ${"val foo: _ = 3"}
1090            |
1091            |  Use:
1092            |    ${"val foo: Int = 3"}
1093            |"""
1094   }
1095 
1096   case class DanglingThisInPath()(implicit ctx: Context) extends Message(DanglingThisInPathID) {
1097     val kind = "Syntax"
1098     val msg = hl"""Expected an additional member selection after the keyword ${"this"}"""
1099 
1100     val contextCode =
1101       """  trait Outer {
1102         |    val member: Int
1103         |    type Member
1104         |    trait Inner {
1105         |      ...
1106         |    }
1107         |  }"""
1108 
1109     val importCode =
1110       """  import Outer.this.member
1111         |  //               ^^^^^^^"""
1112 
1113     val typeCode =
1114       """  type T = Outer.this.Member
1115         |  //                 ^^^^^^^"""
1116 
1117     val explanation =
1118       hl"""|Paths of imports and type selections must not end with the keyword ${"this"}.
1119            |
1120            |Maybe you forgot to select a member of ${"this"}? As an example, in the
1121            |following context:
1122            |${contextCode}
1123            |
1124            |- this is a valid import expression using a path
1125            |${importCode}
1126            |
1127            |- this is a valid type using a path
1128            |${typeCode}
1129            |"""
1130   }
1131 
1132   case class OverridesNothing(member: Symbol)(implicit ctx: Context)
1133   extends Message(OverridesNothingID) {
1134     val kind = "Reference"
1135     val msg = hl"""${member} overrides nothing"""
1136 
1137     val explanation =
1138       hl"""|There must be a field or method with the name `${member.name}` in a super
1139            |class of `${member.owner}` to override it. Did you misspell it?
1140            |Are you extending the right classes?
1141            |"""
1142   }
1143 
1144   case class OverridesNothingButNameExists(member: Symbol, existing: List[Denotations.SingleDenotation])(implicit ctx: Context)
1145   extends Message(OverridesNothingButNameExistsID) {
1146     val kind = "Reference"
1147     val msg = hl"""${member} has a different signature than the overridden declaration"""
1148 
1149     val existingDecl = existing.map(_.showDcl).mkString("  \n")
1150 
1151     val explanation =
1152       hl"""|There must be a non-final field or method with the name `${member.name}` and the
1153            |same parameter list in a super class of `${member.owner}` to override it.
1154            |
1155            |  ${member.showDcl}
1156            |
1157            |The super classes of `${member.owner}` contain the following members
1158            |named `${member.name}`:
1159            |  ${existingDecl}
1160            |"""
1161   }
1162 
1163   case class ForwardReferenceExtendsOverDefinition(value: Symbol, definition: Symbol)(implicit ctx: Context)
1164   extends Message(ForwardReferenceExtendsOverDefinitionID) {
1165     val kind = "Reference"
1166     val msg = hl"`${definition.name}` is a forward reference extending over the definition of `${value.name}`"
1167 
1168     val explanation =
1169       hl"""|`${definition.name}` is used before you define it, and the definition of `${value.name}`
1170            |appears between that use and the definition of `${definition.name}`.
1171            |
1172            |Forward references are allowed only, if there are no value definitions between
1173            |the reference and the referred method definition.
1174            |
1175            |Define `${definition.name}` before it is used,
1176            |or move the definition of `${value.name}` so it does not appear between
1177            |the declaration of `${definition.name}` and its use,
1178            |or define `${value.name}` as lazy.
1179            |""".stripMargin
1180   }
1181 
1182   case class ExpectedTokenButFound(expected: Token, found: Token)(implicit ctx: Context)
1183   extends Message(ExpectedTokenButFoundID) {
1184     val kind = "Syntax"
1185 
1186     private val expectedText =
1187       if (Tokens.isIdentifier(expected)) "an identifier"
1188       else Tokens.showToken(expected)
1189 
1190     private val foundText = Tokens.showToken(found)
1191 
1192     val msg = hl"""${expectedText} expected, but ${foundText} found"""
1193 
1194     private val ifKeyword =
1195       if (Tokens.isIdentifier(expected) && Tokens.isKeyword(found))
1196         s"""
1197            |If you necessarily want to use $foundText as identifier, you may put it in backticks.""".stripMargin
1198       else
1199         ""
1200     val explanation = s"$ifKeyword"
1201   }
1202 
1203   case class MixedLeftAndRightAssociativeOps(op1: Name, op2: Name, op2LeftAssoc: Boolean)(implicit ctx: Context)
1204   extends Message(MixedLeftAndRightAssociativeOpsID) {
1205     val kind = "Syntax"
1206     val op1Asso = if (op2LeftAssoc) "which is right-associative" else "which is left-associative"
1207     val op2Asso = if (op2LeftAssoc) "which is left-associative" else "which is right-associative"
1208     val msg = s"`${op1}` (${op1Asso}) and `${op2}` ($op2Asso) have same precedence and may not be mixed"
1209     val explanation =
1210       s"""|The operators ${op1} and ${op2} are used as infix operators in the same expression,
1211           |but they bind to different sides:
1212           |${op1} is applied to the operand to its ${if (op2LeftAssoc) "right" else "left"}
1213           |${op2} is applied to the operand to its ${if (op2LeftAssoc) "left" else "right"}
1214           |As both have the same precedence the compiler can't decide which to apply first.
1215           |
1216           |You may use parenthesis to make the application order explicit,
1217           |or use method application syntax `operand1.${op1}(operand2)`.
1218           |
1219           |Operators ending in a colon `:` are right-associative. All other operators are left-associative.
1220           |
1221           |Infix operator precedence is determined by the operator's first character. Characters are listed
1222           |below in increasing order of precedence, with characters on the same line having the same precedence.
1223           |  (all letters)
1224           |  |
1225           |  ^
1226           |  &
1227           |  = !
1228           |  < >
1229           |  :
1230           |  + -
1231           |  * / %
1232           |  (all other special characters)
1233           |Operators starting with a letter have lowest precedence, followed by operators starting with `|`, etc.
1234           |""".stripMargin
1235   }
1236 
1237   case class CantInstantiateAbstractClassOrTrait(cls: Symbol, isTrait: Boolean)(implicit ctx: Context)
1238   extends Message(CantInstantiateAbstractClassOrTraitID) {
1239     val kind = "Usage"
1240     private val traitOrAbstract = if (isTrait) hl"a trait" else hl"abstract"
1241     val msg = hl"""${cls.name} is ${traitOrAbstract}; it cannot be instantiated"""
1242     val explanation =
1243       hl"""|Abstract classes and traits need to be extended by a concrete class or object
1244            |to make their functionality accessible.
1245            |
1246            |You may want to create an anonymous class extending ${cls.name} with
1247            |  ${s"class ${cls.name} { }"}
1248            |
1249            |or add a companion object with
1250            |  ${s"object ${cls.name} extends ${cls.name}"}
1251            |
1252            |You need to implement any abstract members in both cases.
1253            |""".stripMargin
1254   }
1255 
1256   case class OverloadedOrRecursiveMethodNeedsResultType(tree: Names.TermName)(implicit ctx: Context)
1257   extends Message(OverloadedOrRecursiveMethodNeedsResultTypeID) {
1258     val kind = "Syntax"
1259     val msg = hl"""overloaded or recursive method ${tree} needs return type"""
1260     val explanation =
1261       hl"""Case 1: ${tree} is overloaded
1262           |If there are multiple methods named `${tree.name}` and at least one definition of
1263           |it calls another, you need to specify the calling method's return type.
1264           |
1265           |Case 2: ${tree} is recursive
1266           |If `${tree.name}` calls itself on any path, you need to specify its return type.
1267           |""".stripMargin
1268   }
1269 
1270   case class RecursiveValueNeedsResultType(tree: Names.TermName)(implicit ctx: Context)
1271   extends Message(RecursiveValueNeedsResultTypeID) {
1272     val kind = "Syntax"
1273     val msg = hl"""recursive value ${tree.name} needs type"""
1274     val explanation =
1275       hl"""The definition of `${tree.name}` is recursive and you need to specify its type.
1276           |""".stripMargin
1277   }
1278 
1279   case class CyclicReferenceInvolving(denot: SymDenotation)(implicit ctx: Context)
1280   extends Message(CyclicReferenceInvolvingID) {
1281     val kind = "Syntax"
1282     val msg = hl"""cyclic reference involving $denot"""
1283     val explanation =
1284       hl"""|$denot is declared as part of a cycle which makes it impossible for the
1285            |compiler to decide upon ${denot.name}'s type.
1286            |""".stripMargin
1287   }
1288 
1289   case class CyclicReferenceInvolvingImplicit(cycleSym: Symbol)(implicit ctx: Context)
1290   extends Message(CyclicReferenceInvolvingImplicitID) {
1291     val kind = "Syntax"
1292     val msg = hl"""cyclic reference involving implicit $cycleSym"""
1293     val explanation =
1294       hl"""|This happens when the right hand-side of $cycleSym's definition involves an implicit search.
1295            |To avoid this error, give `${cycleSym.name}` an explicit type.
1296            |""".stripMargin
1297   }
1298 
1299   case class SuperQualMustBeParent(qual: untpd.Ident, cls: Symbols.ClassSymbol)(implicit ctx: Context)
1300   extends Message(SuperQualMustBeParentID) {
1301 
1302     val msg = hl"""|$qual does not name a parent of $cls"""
1303     val kind = "Reference"
1304 
1305     private val parents: Seq[String] = (cls.info.parents map (_.typeSymbol.name.show)).sorted
1306 
1307     val explanation =
1308       hl"""|When a qualifier ${"T"} is used in a ${"super"} prefix of the form ${"C.super[T]"},
1309            |${"T"} must be a parent type of ${"C"}.
1310            |
1311            |In this case, the parents of $cls are:
1312            |${parents.mkString("  - ", "\n  - ", "")}
1313            |""".stripMargin
1314   }
1315 
1316   case class VarArgsParamMustComeLast()(implicit ctx: Context)
1317   extends Message(IncorrectRepeatedParameterSyntaxID) {
1318     val msg = "varargs parameter must come last"
1319     val kind = "Syntax"
1320     val explanation =
1321       hl"""|The varargs field must be the last field in the method signature.
1322            |Attempting to define a field in a method signature after a varargs field is an error.
1323            |"""
1324   }
1325 
1326   case class AmbiguousImport(name: Names.Name, newPrec: Int, prevPrec: Int, prevCtx: Context)(implicit ctx: Context)
1327     extends Message(AmbiguousImportID) {
1328 
1329     import typer.Typer.BindingPrec
1330 
1331     /** A string which explains how something was bound; Depending on `prec` this is either
1332       *      imported by <tree>
1333       *  or  defined in <symbol>
1334       */
1335     private def bindingString(prec: Int, whereFound: Context, qualifier: String = "") = {
1336       val howVisible = prec match {
1337         case BindingPrec.definition => "defined"
1338         case BindingPrec.namedImport => "imported by name"
1339         case BindingPrec.wildImport => "imported"
1340         case BindingPrec.packageClause => "found"
1341       }
1342       if (BindingPrec.isImportPrec(prec)) {
1343         ex"""$howVisible$qualifier by ${hl"${whereFound.importInfo}"}"""
1344       } else
1345         ex"""$howVisible$qualifier in ${hl"${whereFound.owner}"}"""
1346     }
1347 
1348 
1349     val msg =
1350       i"""|reference to `${hl"$name"}` is ambiguous
1351           |it is both ${bindingString(newPrec, ctx)}
1352           |and ${bindingString(prevPrec, prevCtx, " subsequently")}"""
1353 
1354     val kind = "Reference"
1355 
1356     val explanation =
1357       hl"""|The compiler can't decide which of the possible choices you
1358            |are referencing with $name.
1359            |Note:
1360            |- Definitions take precedence over imports
1361            |- Named imports take precedence over wildcard imports
1362            |- You may replace a name when imported using
1363            |  ${"import"} scala.{ $name => ${name.show + "Tick"} }
1364            |"""
1365   }
1366 
1367   case class MethodDoesNotTakeParameters(tree: tpd.Tree, methPartType: Types.Type)(err: typer.ErrorReporting.Errors)(implicit ctx: Context)
1368   extends Message(MethodDoesNotTakeParametersId) {
1369     private val more = tree match {
1370       case Apply(_, _) => " more"
1371       case _ => ""
1372     }
1373 
1374     val msg = hl"${err.refStr(methPartType)} does not take$more parameters"
1375 
1376     val kind = "Reference"
1377 
1378     private val noParameters = if (methPartType.widenSingleton.isInstanceOf[ExprType])
1379       hl"""|As ${err.refStr(methPartType)} is defined without parenthesis, you may
1380            |not use any at call-site, either.
1381            |"""
1382     else
1383       ""
1384 
1385     val explanation =
1386       s"""|You have specified more parameter lists as defined in the method definition(s).
1387           |$noParameters""".stripMargin
1388 
1389   }
1390 
1391   case class AmbiguousOverload(tree: tpd.Tree, alts: List[SingleDenotation], pt: Type)(
1392     err: typer.ErrorReporting.Errors)(
1393     implicit ctx: Context)
1394   extends Message(AmbiguousOverloadID) {
1395 
1396     private val all = if (alts.length == 2) "both" else "all"
1397     val msg =
1398       s"""|Ambiguous overload. The ${err.overloadedAltsStr(alts)}
1399           |$all match ${err.expectedTypeStr(pt)}""".stripMargin
1400     val kind = "Reference"
1401     val explanation =
1402       hl"""|There are ${alts.length} methods that could be referenced as the compiler knows too little
1403            |about the expected type.
1404            |You may specify the expected type e.g. by
1405            |- assigning it to a value with a specified type, or
1406            |- adding a type ascription as in `${"instance.myMethod: String => Int"}`
1407            |"""
1408   }
1409 
1410   case class ReassignmentToVal(name: Names.Name)(implicit ctx: Context)
1411     extends Message(ReassignmentToValID) {
1412     val kind = "Reference"
1413     val msg = hl"""reassignment to val `$name`"""
1414     val explanation =
1415       hl"""|You can not assign a new value to `$name` as values can't be changed.
1416            |Keep in mind that every statement has a value, so you may e.g. use
1417            |  ${"val"} $name ${"= if (condition) 2 else 5"}
1418            |In case you need a reassignable name, you can declare it as
1419            |variable
1420            |  ${"var"} $name ${"="} ...
1421            |""".stripMargin
1422   }
1423 
1424   case class TypeDoesNotTakeParameters(tpe: Types.Type, params: List[Trees.Tree[Trees.Untyped]])(implicit ctx: Context)
1425     extends Message(TypeDoesNotTakeParametersID) {
1426     val kind = "Reference"
1427     val msg = hl"$tpe does not take type parameters"
1428 
1429     private val ps =
1430       if (params.size == 1) s"a type parameter ${params.head}"
1431       else s"type parameters ${params.map(_.show).mkString(", ")}"
1432 
1433     val explanation =
1434       i"""You specified ${NoColor(ps)} for ${hl"$tpe"}, which is not
1435          |declared to take any.
1436          |"""
1437   }
1438 
1439   case class ParameterizedTypeLacksArguments(psym: Symbol)(implicit ctx: Context)
1440     extends Message(ParameterizedTypeLacksArgumentsID) {
1441     val msg = hl"parameterized $psym lacks argument list"
1442     val kind = "Reference"
1443     val explanation =
1444       hl"""The $psym is declared with non-implicit parameters, you may not leave
1445           |out the parameter list when extending it.
1446           |"""
1447   }
1448 
1449   case class VarValParametersMayNotBeCallByName(name: Names.TermName, mutable: Boolean)(implicit ctx: Context)
1450     extends Message(VarValParametersMayNotBeCallByNameID) {
1451     val msg = s"${if (mutable) "`var'" else "`val'"} parameters may not be call-by-name"
1452     val kind = "Syntax"
1453     val explanation =
1454       hl"""${"var"} and ${"val"} parameters of classes and traits may no be call-by-name. In case you
1455           |want the parameter to be evaluated on demand, consider making it just a parameter
1456           |and a ${"def"} in the class such as
1457           |  ${s"class MyClass(${name}Tick: => String) {"}
1458           |  ${s"  def $name() = ${name}Tick"}
1459           |  ${"}"}
1460           |"""
1461   }
1462 
1463   case class MissingTypeParameterFor(tpe: Type)(implicit ctx: Context)
1464     extends Message(MissingTypeParameterForID) {
1465     val msg = hl"missing type parameter for ${tpe}"
1466     val kind = "Syntax"
1467     val explanation = ""
1468   }
1469 
1470   case class DoesNotConformToBound(tpe: Type, which: String, bound: Type)(
1471     err: typer.ErrorReporting.Errors)(implicit ctx: Context)
1472     extends Message(DoesNotConformToBoundID) {
1473     val msg = hl"Type argument ${tpe} does not conform to $which bound $bound ${err.whyNoMatchStr(tpe, bound)}"
1474     val kind = "Type Mismatch"
1475     val explanation = ""
1476   }
1477 
1478   case class DoesNotConformToSelfType(category: String, selfType: Type, cls: Symbol,
1479                                       otherSelf: Type, relation: String, other: Symbol)(
1480     implicit ctx: Context)
1481     extends Message(DoesNotConformToSelfTypeID) {
1482     val msg = hl"""$category: self type $selfType of $cls does not conform to self type $otherSelf
1483                   |of $relation $other"""
1484     val kind = "Type Mismatch"
1485     val explanation =
1486       hl"""You mixed in $other which requires self type $otherSelf, but $cls has self type
1487           |$selfType and does not inherit from $otherSelf.
1488           |
1489           |Note: Self types are indicated with the notation
1490           |  ${s"class "}$other ${"{ this: "}$otherSelf${" => "}
1491         """
1492   }
1493 
1494   case class DoesNotConformToSelfTypeCantBeInstantiated(tp: Type, selfType: Type)(
1495     implicit ctx: Context)
1496     extends Message(DoesNotConformToSelfTypeCantBeInstantiatedID) {
1497     val msg = hl"""$tp does not conform to its self type $selfType; cannot be instantiated"""
1498     val kind = "Type Mismatch"
1499     val explanation =
1500       hl"""To create an instance of $tp it needs to inherit $selfType in some way.
1501           |
1502           |Note: Self types are indicated with the notation
1503           |  ${s"class "}$tp ${"{ this: "}$selfType${" => "}
1504           |"""
1505   }
1506 
1507   case class AbstractMemberMayNotHaveModifier(sym: Symbol, flag: FlagSet)(
1508     implicit ctx: Context)
1509     extends Message(AbstractMemberMayNotHaveModifierID) {
1510     val msg = hl"""${"abstract"} $sym may not have `$flag' modifier"""
1511     val kind = "Syntax"
1512     val explanation = ""
1513   }
1514 
1515   case class TopLevelCantBeImplicit(sym: Symbol)(
1516     implicit ctx: Context)
1517     extends Message(TopLevelCantBeImplicitID) {
1518     val msg = hl"""${"implicit"} modifier cannot be used for top-level definitions"""
1519     val kind = "Syntax"
1520     val explanation = ""
1521   }
1522 
1523   case class TypesAndTraitsCantBeImplicit(sym: Symbol)(
1524     implicit ctx: Context)
1525     extends Message(TypesAndTraitsCantBeImplicitID) {
1526     val msg = hl"""${"implicit"} modifier cannot be used for types or traits"""
1527     val kind = "Syntax"
1528     val explanation = ""
1529   }
1530 
1531   case class OnlyClassesCanBeAbstract(sym: Symbol)(
1532     implicit ctx: Context)
1533     extends Message(OnlyClassesCanBeAbstractID) {
1534     val msg = hl"""${"abstract"} modifier can be used only for classes; it should be omitted for abstract members"""
1535     val kind = "Syntax"
1536     val explanation = ""
1537   }
1538 
1539   case class AbstractOverrideOnlyInTraits(sym: Symbol)(
1540     implicit ctx: Context)
1541     extends Message(AbstractOverrideOnlyInTraitsID) {
1542     val msg = hl"""${"abstract override"} modifier only allowed for members of traits"""
1543     val kind = "Syntax"
1544     val explanation = ""
1545   }
1546 
1547   case class TraitsMayNotBeFinal(sym: Symbol)(
1548     implicit ctx: Context)
1549     extends Message(TraitsMayNotBeFinalID) {
1550     val msg = hl"""$sym may not be ${"final"}"""
1551     val kind = "Syntax"
1552     val explanation =
1553       "A trait can never be final since it is abstract and must be extended to be useful."
1554   }
1555 
1556   case class NativeMembersMayNotHaveImplementation(sym: Symbol)(
1557     implicit ctx: Context)
1558     extends Message(NativeMembersMayNotHaveImplementationID) {
1559     val msg = hl"""${"@native"} members may not have an implementation"""
1560     val kind = "Syntax"
1561     val explanation = ""
1562   }
1563 
1564   case class OnlyClassesCanHaveDeclaredButUndefinedMembers(sym: Symbol)(
1565     implicit ctx: Context)
1566     extends Message(OnlyClassesCanHaveDeclaredButUndefinedMembersID) {
1567 
1568     private val varNote =
1569       if (sym.is(Mutable)) "Note that variables need to be initialized to be defined."
1570       else ""
1571     val msg = hl"""only classes can have declared but undefined members"""
1572     val kind = "Syntax"
1573     val explanation = s"$varNote"
1574   }
1575 
1576   case class CannotExtendAnyVal(sym: Symbol)(implicit ctx: Context)
1577     extends Message(CannotExtendAnyValID) {
1578     val msg = hl"""$sym cannot extend ${"AnyVal"}"""
1579     val kind = "Syntax"
1580     val explanation =
1581       hl"""Only classes (not traits) are allowed to extend ${"AnyVal"}, but traits may extend
1582           |${"Any"} to become ${Green("\"universal traits\"")} which may only have ${"def"} members.
1583           |Universal traits can be mixed into classes that extend ${"AnyVal"}.
1584           |"""
1585   }
1586 
1587   case class CannotHaveSameNameAs(sym: Symbol, cls: Symbol, reason: CannotHaveSameNameAs.Reason)(implicit ctx: Context)
1588     extends Message(CannotHaveSameNameAsID) {
1589     import CannotHaveSameNameAs._
1590     def reasonMessage: String = reason match {
1591       case CannotBeOverridden => "class definitions cannot be overridden"
1592       case DefinedInSelf(self) =>
1593         s"""cannot define ${sym.showKind} member with the same name as a ${cls.showKind} member in self reference ${self.name}.
1594            |(Note: this can be resolved by using another name)
1595            |""".stripMargin
1596     }
1597 
1598     val msg = hl"""$sym cannot have the same name as ${cls.showLocated} -- """ + reasonMessage
1599     val kind = "Syntax"
1600     val explanation = ""
1601   }
1602   object CannotHaveSameNameAs {
1603     sealed trait Reason
1604     case object CannotBeOverridden extends Reason
1605     case class DefinedInSelf(self: tpd.ValDef) extends Reason
1606   }
1607 
1608   case class ValueClassesMayNotDefineInner(valueClass: Symbol, inner: Symbol)(implicit ctx: Context)
1609     extends Message(ValueClassesMayNotDefineInnerID) {
1610     val msg = hl"""value classes may not define an inner class"""
1611     val kind = "Syntax"
1612     val explanation = ""
1613   }
1614 
1615   case class ValueClassesMayNotDefineNonParameterField(valueClass: Symbol, field: Symbol)(implicit ctx: Context)
1616     extends Message(ValueClassesMayNotDefineNonParameterFieldID) {
1617     val msg = hl"""value classes may not define non-parameter field"""
1618     val kind = "Syntax"
1619     val explanation = ""
1620   }
1621 
1622   case class ValueClassesMayNotDefineASecondaryConstructor(valueClass: Symbol, constructor: Symbol)(implicit ctx: Context)
1623     extends Message(ValueClassesMayNotDefineASecondaryConstructorID) {
1624     val msg = hl"""value classes may not define a secondary constructor"""
1625     val kind = "Syntax"
1626     val explanation = ""
1627   }
1628 
1629   case class ValueClassesMayNotContainInitalization(valueClass: Symbol)(implicit ctx: Context)
1630     extends Message(ValueClassesMayNotContainInitalizationID) {
1631     val msg = hl"""value classes may not contain initialization statements"""
1632     val kind = "Syntax"
1633     val explanation = ""
1634   }
1635 
1636   case class ValueClassesMayNotBeAbstract(valueClass: Symbol)(implicit ctx: Context)
1637     extends Message(ValueClassesMayNotBeAbstractID) {
1638     val msg = hl"""value classes may not be ${"abstract"}"""
1639     val kind = "Syntax"
1640     val explanation = ""
1641   }
1642 
1643   case class ValueClassesMayNotBeContainted(valueClass: Symbol)(implicit ctx: Context)
1644     extends Message(ValueClassesMayNotBeContaintedID) {
1645     private val localOrMember = if (valueClass.owner.isTerm) "local class" else "member of another class"
1646     val msg = s"""value classes may not be a $localOrMember"""
1647     val kind = "Syntax"
1648     val explanation = ""
1649   }
1650 
1651   case class ValueClassesMayNotWrapItself(valueClass: Symbol)(implicit ctx: Context)
1652     extends Message(ValueClassesMayNotWrapItselfID) {
1653     val msg = """a value class may not wrap itself"""
1654     val kind = "Syntax"
1655     val explanation = ""
1656   }
1657 
1658   case class ValueClassParameterMayNotBeAVar(valueClass: Symbol, param: Symbol)(implicit ctx: Context)
1659     extends Message(ValueClassParameterMayNotBeAVarID) {
1660     val msg = hl"""a value class parameter may not be a ${"var"}"""
1661     val kind = "Syntax"
1662     val explanation =
1663       hl"""A value class must have exactly one ${"val"} parameter.
1664           |"""
1665   }
1666 
1667   case class ValueClassNeedsOneValParam(valueClass: Symbol)(implicit ctx: Context)
1668     extends Message(ValueClassNeedsExactlyOneValParamID) {
1669     val msg = hl"""value class needs one ${"val"} parameter"""
1670     val kind = "Syntax"
1671     val explanation = ""
1672   }
1673 
1674   case class OnlyCaseClassOrCaseObjectAllowed()(implicit ctx: Context)
1675     extends Message(OnlyCaseClassOrCaseObjectAllowedID) {
1676     val msg = "only `case class` or `case object` allowed"
1677     val kind = "Syntax"
1678     val explanation = ""
1679   }
1680 
1681   case class ExpectedClassOrObjectDef()(implicit ctx: Context)
1682     extends Message(ExpectedClassOrObjectDefID) {
1683     val kind = "Syntax"
1684     val msg = "expected class or object definition"
1685     val explanation = ""
1686   }
1687 
1688   case class SuperCallsNotAllowedInline(symbol: Symbol)(implicit ctx: Context)
1689     extends Message(SuperCallsNotAllowedInlineID) {
1690     val kind = "Syntax"
1691     val msg = s"super call not allowed in inline $symbol"
1692     val explanation = "Method inlining prohibits calling superclass methods, as it may lead to confusion about which super is being called."
1693   }
1694 
1695   case class ModifiersNotAllowed(flags: FlagSet, printableType: Option[String])(implicit ctx: Context)
1696     extends Message(ModifiersNotAllowedID) {
1697     val kind = "Syntax"
1698     val msg = s"modifier(s) `$flags' not allowed for ${printableType.getOrElse("combination")}"
1699     val explanation = {
1700       val first = "sealed def y: Int = 1"
1701       val second = "sealed lazy class z"
1702       hl"""You tried to use a modifier that is inapplicable for the type of item under modification
1703          |
1704          |  Please see the official Scala Language Specification section on modifiers:
1705          |  https://www.scala-lang.org/files/archive/spec/2.11/05-classes-and-objects.html#modifiers
1706          |
1707          |Consider the following example:
1708          |$first
1709          |In this instance, the modifier 'sealed' is not applicable to the item type 'def' (method)
1710          |$second
1711          |In this instance, the modifier combination is not supported
1712         """
1713     }
1714   }
1715 
1716   case class ImplicitFunctionTypeNeedsNonEmptyParameterList()(implicit ctx: Context)
1717     extends Message(ImplicitFunctionTypeNeedsNonEmptyParameterListID) {
1718     val kind = "Syntax"
1719     val msg = "implicit function type needs non-empty parameter list"
1720     val explanation = {
1721       val code1 = "type Transactional[T] = implicit Transaction => T"
1722       val code2 = "val cl: implicit A => B"
1723       hl"""It is not allowed to leave implicit function parameter list empty.
1724          |Possible ways to define implicit function type:
1725          |
1726          |$code1
1727          |
1728          |or
1729          |
1730          |$code2""".stripMargin
1731     }
1732   }
1733 
1734   case class WrongNumberOfParameters(expected: Int)(implicit ctx: Context)
1735     extends Message(WrongNumberOfParametersID) {
1736     val kind = "Syntax"
1737     val msg = s"wrong number of parameters, expected: $expected"
1738     val explanation = ""
1739   }
1740 
1741   case class DuplicatePrivateProtectedQualifier()(implicit ctx: Context)
1742     extends Message(DuplicatePrivateProtectedQualifierID) {
1743     val kind = "Syntax"
1744     val msg = "duplicate private/protected qualifier"
1745     val explanation =
1746       hl"It is not allowed to combine `private` and `protected` modifiers even if they are qualified to different scopes"
1747   }
1748 
1749   case class ExpectedStartOfTopLevelDefinition()(implicit ctx: Context)
1750     extends Message(ExpectedStartOfTopLevelDefinitionID) {
1751     val kind = "Syntax"
1752     val msg = "expected start of definition"
1753     val explanation =
1754       hl"you have to provide either ${"class"}, ${"trait"}, ${"object"}, or ${"enum"} definitions after qualifiers"
1755   }
1756 
1757   case class NoReturnFromInline(owner: Symbol)(implicit ctx: Context)
1758     extends Message(NoReturnFromInlineID) {
1759     val kind = "Syntax"
1760     val msg = hl"no explicit ${"return"} allowed from inline $owner"
1761     val explanation =
1762       hl"""Methods marked with ${"@inline"} may not use ${"return"} statements.
1763           |Instead, you should rely on the last expression's value being
1764           |returned from a method.
1765           |"""
1766   }
1767 
1768   case class ReturnOutsideMethodDefinition(owner: Symbol)(implicit ctx: Context)
1769     extends Message(ReturnOutsideMethodDefinitionID) {
1770     val kind = "Syntax"
1771     val msg = hl"${"return"} outside method definition"
1772     val explanation =
1773       hl"""You used ${"return"} in ${owner}.
1774           |${"return"} is a keyword and may only be used within method declarations.
1775           |"""
1776   }
1777 
1778   case class ExtendFinalClass(clazz:Symbol, finalClazz: Symbol)(implicit ctx: Context)
1779     extends Message(ExtendFinalClassID) {
1780     val kind = "Syntax"
1781     val msg = hl"$clazz cannot extend ${"final"} $finalClazz"
1782     val explanation =
1783       hl"""A class marked with the ${"final"} keyword cannot be extended"""
1784   }
1785 
1786   case class EnumCaseDefinitionInNonEnumOwner(owner: Symbol)(implicit ctx: Context)
1787     extends Message(EnumCaseDefinitionInNonEnumOwnerID) {
1788       val kind = "Syntax"
1789       val msg = em"case not allowed here, since owner ${owner} is not an ${"enum"} object"
1790       val explanation =
1791         hl"""${"enum"} cases are only allowed within the companion ${"object"} of an ${"enum class"}.
1792             |If you want to create an ${"enum"} case, make sure the corresponding ${"enum class"} exists
1793             |and has the ${"enum"} keyword."""
1794   }
1795 
1796   case class ExpectedTypeBoundOrEquals(found: Token)(implicit ctx: Context)
1797     extends Message(ExpectedTypeBoundOrEqualsID) {
1798     val kind = "Syntax"
1799     val msg = hl"${"="}, ${">:"}, or ${"<:"} expected, but ${Tokens.showToken(found)} found"
1800 
1801     val explanation =
1802       hl"""Type parameters and abstract types may be constrained by a type bound.
1803            |Such type bounds limit the concrete values of the type variables and possibly
1804            |reveal more information about the members of such types.
1805            |
1806            |A lower type bound ${"B >: A"} expresses that the type variable ${"B"}
1807            |refers to a supertype of type ${"A"}.
1808            |
1809            |An upper type bound ${"T <: A"} declares that type variable ${"T"}
1810            |refers to a subtype of type ${"A"}.
1811            |"""
1812   }
1813 
1814   case class ClassAndCompanionNameClash(cls: Symbol, other: Symbol)(implicit ctx: Context)
1815     extends Message(ClassAndCompanionNameClashID) {
1816     val kind = "Naming"
1817     val msg = hl"Name clash: both ${cls.owner} and its companion object defines ${cls.name.stripModuleClassSuffix}"
1818     val explanation = {
1819       val kind = if (cls.owner.is(Flags.Trait)) "trait" else "class"
1820 
1821       hl"""|A $kind and its companion object cannot both define a ${"class"}, ${"trait"} or ${"object"} with the same name:
1822            |  - ${cls.owner} defines ${cls}
1823            |  - ${other.owner} defines ${other}"""
1824       }
1825   }
1826 
1827   case class TailrecNotApplicable(method: Symbol)(implicit ctx: Context)
1828     extends Message(TailrecNotApplicableID) {
1829     val kind = "Syntax"
1830     val msg = hl"TailRec optimisation not applicable, $method is neither ${"private"} nor ${"final"}."
1831     val explanation =
1832       hl"A method annotated ${"@tailrec"} must be declared ${"private"} or ${"final"} so it can't be overridden."
1833   }
1834 
1835   case class FailureToEliminateExistential(tp: Type, tp1: Type, tp2: Type, boundSyms: List[Symbol])(implicit ctx: Context)
1836     extends Message(FailureToEliminateExistentialID) {
1837     val kind = "Compatibility"
1838     val msg = "Failure to eliminate existential type. Proceed at own risk."
1839     val explanation = {
1840       val originalType = ctx.dclsText(boundSyms, "; ").show
1841       hl"""original type    : $tp forSome ${originalType}
1842           |reduces to       : $tp1
1843           |type used instead: $tp2"""
1844     }
1845   }
1846 
1847   case class OnlyFunctionsCanBeFollowedByUnderscore(pt: Type)(implicit ctx: Context)
1848     extends Message(OnlyFunctionsCanBeFollowedByUnderscoreID) {
1849     val kind = "Syntax"
1850     val msg = hl"Not a function: $pt: cannot be followed by ${"_"}"
1851     val explanation =
1852       hl"""The syntax ${"x _"} is no longer supported if ${"x"} is not a function.
1853           |To convert to a function value, you need to explicitly write ${"() => x"}"""
1854   }
1855 
1856   case class MissingEmptyArgumentList(method: Symbol)(implicit ctx: Context)
1857     extends Message(MissingEmptyArgumentListID) {
1858     val kind = "Syntax"
1859     val msg = hl"$method must be called with ${"()"} argument"
1860     val explanation = {
1861       val codeExample =
1862         """def next(): T = ...
1863           |next     // is expanded to next()"""
1864 
1865       hl"""Previously an empty argument list () was implicitly inserted when calling a nullary method without arguments. E.g.
1866           |
1867           |$codeExample
1868           |
1869           |In Dotty, this idiom is an error. The application syntax has to follow exactly the parameter syntax.
1870           |Excluded from this rule are methods that are defined in Java or that override methods defined in Java."""
1871     }
1872   }
1873 
1874   case class DuplicateNamedTypeParameter(name: Name)(implicit ctx: Context)
1875     extends Message(DuplicateNamedTypeParameterID) {
1876     val kind = "Syntax"
1877     val msg = hl"Type parameter $name was defined multiple times."
1878     val explanation = ""
1879   }
1880 
1881   case class UndefinedNamedTypeParameter(undefinedName: Name, definedNames: List[Name])(implicit ctx: Context)
1882     extends Message(UndefinedNamedTypeParameterID) {
1883     val kind = "Syntax"
1884     val msg = hl"Type parameter $undefinedName is undefined. Expected one of ${definedNames.map(_.show).mkString(", ")}."
1885     val explanation = ""
1886   }
1887 
1888   case class IllegalStartOfStatement(isModifier: Boolean)(implicit ctx: Context) extends Message(IllegalStartOfStatementID) {
1889     val kind = "Syntax"
1890     val msg = {
1891       val addendum = if (isModifier) ": no modifiers allowed here" else ""
1892       "Illegal start of statement" + addendum
1893     }
1894     val explanation = "A statement is either an import, a definition or an expression."
1895   }
1896 
1897   case class TraitIsExpected(symbol: Symbol)(implicit ctx: Context) extends Message(TraitIsExpectedID) {
1898     val kind = "Syntax"
1899     val msg = hl"$symbol is not a trait"
1900     val explanation = {
1901       val errorCodeExample =
1902         """class A
1903           |class B
1904           |
1905           |val a = new A with B // will fail with a compile error - class B is not a trait""".stripMargin
1906       val codeExample =
1907         """class A
1908           |trait B
1909           |
1910           |val a = new A with B // compiles normally""".stripMargin
1911 
1912       hl"""Only traits can be mixed into classes using a ${"with"} keyword.
1913           |Consider the following example:
1914           |
1915           |$errorCodeExample
1916           |
1917           |The example mentioned above would fail because B is not a trait.
1918           |But if you make B a trait it will be compiled without any errors:
1919           |
1920           |$codeExample
1921           |"""
1922     }
1923   }
1924 
1925   case class TraitRedefinedFinalMethodFromAnyRef(method: Symbol)(implicit ctx: Context) extends Message(TraitRedefinedFinalMethodFromAnyRefID) {
1926     val kind = "Syntax"
1927     val msg = hl"Traits cannot redefine final $method from ${"class AnyRef"}."
1928     val explanation = ""
1929   }
1930 
1931   case class PackageNameAlreadyDefined(pkg: Symbol)(implicit ctx: Context) extends Message(PackageNameAlreadyDefinedID) {
1932     val msg = hl"${pkg} is already defined, cannot be a ${"package"}"
1933     val kind = "Naming"
1934     val explanation =
1935       hl"An ${"object"} cannot have the same name as an existing ${"package"}. Rename either one of them."
1936   }
1937 
1938   case class UnapplyInvalidNumberOfArguments(qual: untpd.Tree, argTypes: List[Type])(implicit ctx: Context)
1939     extends Message(UnapplyInvalidNumberOfArgumentsID) {
1940     val kind = "Syntax"
1941     val msg = hl"Wrong number of argument patterns for $qual; expected: ($argTypes%, %)"
1942     val explanation =
1943       hl"""The Unapply method of $qual was used with incorrect number of arguments.
1944           |Expected usage would be something like:
1945           |case $qual(${argTypes.map(_ => '_')}%, %) => ...
1946           |
1947         |where subsequent arguments would have following types: ($argTypes%, %).
1948         |""".stripMargin
1949   }
1950 
1951   case class StaticFieldsOnlyAllowedInObjects(member: Symbol)(implicit ctx: Context) extends Message(StaticFieldsOnlyAllowedInObjectsID) {
1952     val msg = hl"${"@static"} $member in ${member.owner} must be defined inside an ${"object"}."
1953     val kind = "Syntax"
1954     val explanation =
1955       hl"${"@static"} members are only allowed inside objects."
1956   }
1957 
1958   case class CyclicInheritance(symbol: Symbol, addendum: String)(implicit ctx: Context) extends Message(CyclicInheritanceID) {
1959     val kind = "Syntax"
1960     val msg = hl"Cyclic inheritance: $symbol extends itself$addendum"
1961     val explanation = {
1962       val codeExample = "class A extends A"
1963 
1964       hl"""Cyclic inheritance is prohibited in Dotty.
1965           |Consider the following example:
1966           |
1967           |$codeExample
1968           |
1969           |The example mentioned above would fail because this type of inheritance hierarchy
1970           |creates a "cycle" where a not yet defined class A extends itself which makes
1971           |impossible to instantiate an object of this class"""
1972     }
1973   }
1974 
1975   case class BadSymbolicReference(denot: SymDenotation)(implicit ctx: Context) extends Message(BadSymbolicReferenceID) {
1976     val kind = "Reference"
1977 
1978     val msg = {
1979       val denotationOwner = denot.owner
1980       val denotationName = ctx.fresh.setSetting(ctx.settings.YdebugNames, true).nameString(denot.name)
1981       val file = denot.symbol.associatedFile
1982       val (location, src) =
1983         if (file != null) (s" in $file", file.toString)
1984         else ("", "the signature")
1985 
1986       hl"""Bad symbolic reference. A signature$location
1987           |refers to $denotationName in ${denotationOwner.showKind} ${denotationOwner.showFullName} which is not available.
1988           |It may be completely missing from the current classpath, or the version on
1989           |the classpath might be incompatible with the version used when compiling $src."""
1990     }
1991 
1992     val explanation = ""
1993   }
1994 
1995   case class UnableToExtendSealedClass(pclazz: Symbol)(implicit ctx: Context) extends Message(UnableToExtendSealedClassID) {
1996     val kind = "Syntax"
1997     val msg = hl"Cannot extend ${"sealed"} $pclazz in a different source file"
1998     val explanation = "A sealed class or trait can only be extended in the same file as its declaration"
1999   }
2000 
2001   case class SymbolHasUnparsableVersionNumber(symbol: Symbol, migrationMessage: String)(implicit ctx: Context)
2002   extends Message(SymbolHasUnparsableVersionNumberID) {
2003     val kind = "Syntax"
2004     val msg = hl"${symbol.showLocated} has an unparsable version number: $migrationMessage"
2005     val explanation =
2006       hl"""$migrationMessage
2007           |
2008           |The ${symbol.showLocated} is marked with ${"@migration"} indicating it has changed semantics
2009           |between versions and the ${"-Xmigration"} settings is used to warn about constructs
2010           |whose behavior may have changed since version change."""
2011   }
2012 
2013   case class SymbolChangedSemanticsInVersion(
2014     symbol: Symbol,
2015     migrationVersion: ScalaVersion
2016   )(implicit ctx: Context) extends Message(SymbolChangedSemanticsInVersionID) {
2017     val kind = "Syntax"
2018     val msg = hl"${symbol.showLocated} has changed semantics in version $migrationVersion"
2019     val explanation = {
2020       hl"""The ${symbol.showLocated} is marked with ${"@migration"} indicating it has changed semantics
2021           |between versions and the ${"-Xmigration"} settings is used to warn about constructs
2022           |whose behavior may have changed since version change."""
2023     }
2024   }
2025 
2026   case class UnableToEmitSwitch(tooFewCases: Boolean)(implicit ctx: Context)
2027   extends Message(UnableToEmitSwitchID) {
2028     val kind = "Syntax"
2029     val tooFewStr = if (tooFewCases) " since there are not enough cases" else ""
2030     val msg = hl"Could not emit switch for ${"@switch"} annotated match$tooFewStr"
2031     val explanation = {
2032       val codeExample =
2033         """val ConstantB = 'B'
2034           |final val ConstantC = 'C'
2035           |def tokenMe(ch: Char) = (ch: @switch) match {
2036           |  case '\t' | '\n' => 1
2037           |  case 'A'         => 2
2038           |  case ConstantB   => 3  // a non-literal may prevent switch generation: this would not compile
2039           |  case ConstantC   => 4  // a constant value is allowed
2040           |  case _           => 5
2041           |}""".stripMargin
2042 
2043       hl"""If annotated with ${"@switch"}, the compiler will verify that the match has been compiled to a
2044           |tableswitch or lookupswitch and issue an error if it instead compiles into a series of conditional
2045           |expressions. Example usage:
2046           |
2047           |$codeExample
2048           |
2049           |The compiler will not apply the optimisation if:
2050           |- the matched value is not of type ${"Int"}, ${"Byte"}, ${"Short"} or ${"Char"}
2051           |- the matched value is not a constant literal
2052           |- there are less than three cases"""
2053     }
2054   }
2055 
2056   case class MissingCompanionForStatic(member: Symbol)(implicit ctx: Context) extends Message(MissingCompanionForStaticID) {
2057     val msg = hl"${member.owner} does not have a companion class"
2058     val kind = "Syntax"
2059     val explanation =
2060       hl"An object that contains ${"@static"} members must have a companion class."
2061   }
2062 
2063   case class PolymorphicMethodMissingTypeInParent(rsym: Symbol, parentSym: Symbol)(implicit ctx: Context)
2064   extends Message(PolymorphicMethodMissingTypeInParentID) {
2065     val kind = "Syntax"
2066     val msg = hl"polymorphic refinement $rsym without matching type in parent $parentSym is no longer allowed"
2067     val explanation =
2068       hl"""Polymorphic $rsym is not allowed in the structural refinement of $parentSym because
2069           |$rsym does not override any method in $parentSym. Structural refinement does not allow for
2070           |polymorphic methods."""
2071   }
2072 
2073   case class ParamsNoInline(owner: Symbol)(implicit ctx: Context)
2074     extends Message(ParamsNoInlineID) {
2075     val kind = "Syntax"
2076     val msg = hl"""${"inline"} modifier cannot be used for a ${owner.showKind} parameter"""
2077     val explanation = ""
2078   }
2079 
2080   case class JavaSymbolIsNotAValue(symbol: Symbol)(implicit ctx: Context) extends Message(JavaSymbolIsNotAValueID) {
2081     val kind = "Type Mismatch"
2082     val msg = {
2083       val kind =
2084         if (symbol is Package) hl"$symbol"
2085         else hl"Java defined ${"class " + symbol.name}"
2086 
2087       s"$kind is not a value"
2088     }
2089     val explanation = ""
2090   }
2091 }