Emit a friendly error when scala-xml is missing

This is similar to what Scala 2 does.

Author: smarter

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -223,6 +223,8 @@ class Definitions {
     lazy val Sys_errorR: TermRef = SysPackage.moduleClass.requiredMethodRef(nme.error)
     def Sys_error(implicit ctx: Context): Symbol = Sys_errorR.symbol
 
+  lazy val ScalaXmlPackageClass: Symbol = ctx.getPackageClassIfDefined("scala.xml")
+
   lazy val CompiletimePackageObjectRef: TermRef = ctx.requiredModuleRef("scala.compiletime.package")
   lazy val CompiletimePackageObject: Symbol = CompiletimePackageObjectRef.symbol.moduleClass
     lazy val Compiletime_errorR: TermRef = CompiletimePackageObjectRef.symbol.requiredMethodRef(nme.error)

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -383,6 +383,15 @@ trait Symbols { this: Context =>
       .requiredSymbol("class", name, generateStubs = false)(_.isClass)
   }
 
+  /** Get ClassSymbol if package is either defined in current compilation run
+   *  or present on classpath.
+   *  Returns NoSymbol otherwise. */
+  def getPackageClassIfDefined(path: PreName): Symbol = {
+    val name = path.toTypeName
+    base.staticRef(name, isPackage = true, generateStubs = false)
+      .requiredSymbol("package", name, generateStubs = false)(_ is PackageClass)
+  }
+
   def requiredModule(path: PreName): TermSymbol = {
     val name = path.toTermName
     base.staticRef(name).requiredSymbol("object", name)(_ is Module).asTerm

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

@@ -5,7 +5,7 @@ package parsing
 import scala.annotation.internal.sharable
 import scala.collection.mutable.ListBuffer
 import scala.collection.immutable.BitSet
-import util.{ SourceFile, SourcePosition }
+import util.{ SourceFile, SourcePosition, NoSourcePosition }
 import Tokens._
 import Scanners._
 import xml.MarkupParsers.MarkupParser
@@ -473,8 +473,21 @@ object Parsers {
 
 /* -------------- XML ---------------------------------------------------- */
 
-    /** the markup parser */
-    lazy val xmlp: xml.MarkupParsers.MarkupParser = new MarkupParser(this, true)
+    /** The markup parser.
+     *  The first time this lazy val is accessed, we assume we were trying to parse an XML literal.
+     *  The current position is recorded for later error reporting if it turns out
+     *  that we don't have scala-xml on the compilation classpath.
+     */
+    lazy val xmlp: xml.MarkupParsers.MarkupParser = {
+      myFirstXmlPos = source.atSpan(Span(in.offset))
+      new MarkupParser(this, true)
+    }
+
+    /** The position of the first XML literal encountered while parsing,
+     *  NoSourcePosition if there were no XML literals.
+     */
+    def firstXmlPos: SourcePosition = myFirstXmlPos
+    private[this] var myFirstXmlPos: SourcePosition = NoSourcePosition
 
     object symbXMLBuilder extends xml.SymbolicXMLBuilder(this, true) // DEBUG choices
 

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

@@ -11,6 +11,7 @@ import parsing.Parsers.Parser
 import config.Config
 import config.Printers.{typr, default}
 import util.Stats._
+import util.{ SourcePosition, NoSourcePosition }
 import scala.util.control.NonFatal
 import ast.Trees._
 
@@ -25,6 +26,11 @@ class FrontEnd extends Phase {
   /** The contexts for compilation units that are parsed but not yet entered */
   private[this] var remaining: List[Context] = Nil
 
+  /** The position of the first XML literal encountered while parsing,
+   *  NoSourcePosition if there were no XML literals.
+   */
+  private[this] var firstXmlPos: SourcePosition = NoSourcePosition
+
   /** Does a source file ending with `<name>.scala` belong to a compilation unit
    *  that is parsed but not yet entered?
    */
@@ -41,9 +47,17 @@ class FrontEnd extends Phase {
 
   def parse(implicit ctx: Context): Unit = monitor("parsing") {
     val unit = ctx.compilationUnit
+
     unit.untpdTree =
       if (unit.isJava) new JavaParser(unit.source).parse()
-      else new Parser(unit.source).parse()
+      else {
+        val p = new Parser(unit.source)
+        val tree = p.parse()
+        if (p.firstXmlPos.exists && !firstXmlPos.exists)
+          firstXmlPos = p.firstXmlPos
+        tree
+      }
+
     val printer = if (ctx.settings.Xprint.value.contains("parser")) default else typr
     printer.println("parsed:\n" + unit.untpdTree.show)
     if (Config.checkPositions)
@@ -86,6 +100,12 @@ class FrontEnd extends Phase {
       enterSyms(remaining.head)
       remaining = remaining.tail
     }
+
+    if (firstXmlPos.exists && !defn.ScalaXmlPackageClass.exists)
+      ctx.error("""To support XML literals, your project must depend on scala-xml.
+                  |See https://github.com/scala/scala-xml for more information.""".stripMargin,
+        firstXmlPos)
+
     unitContexts.foreach(typeCheck(_))
     record("total trees after typer", ast.Trees.ntrees)
     unitContexts.map(_.compilationUnit).filterNot(discardAfterTyper)

tests/neg/xml.check

@@ -0,0 +1,9 @@
+-- Error: tests/neg/xml.scala:2:10 -------------------------------------------------------------------------------------
+2 |  val a = <foo>bla</foo> // error // error
+  |          ^
+  |          To support XML literals, your project must depend on scala-xml.
+  |          See https://github.com/scala/scala-xml for more information.
+-- [E008] Member Not Found Error: tests/neg/xml.scala:2:11 -------------------------------------------------------------
+2 |  val a = <foo>bla</foo> // error // error
+  |           ^
+  |           value xml is not a member of scala - did you mean scala.&?