Fix compiler options: allow global scalac options, and got it to build again.

Author: liufengyun

project/DottyBuild.scala

@@ -13,11 +13,11 @@ trait DottyBuild { this: BuildCommons =>
 
   // List of available night build at https://repo1.maven.org/maven2/ch/epfl/lamp/dotty-compiler_0.14/
   // lazy val dottyVersion = dottyLatestNightlyBuild.get
-  lazy val dottyVersion = "0.19.0"
+  lazy val dottyVersion = "0.21.0-RC1"
   lazy val dottySettings = List(
     scalaVersion := dottyVersion,
     libraryDependencies := libraryDependencies.value.map(_.withDottyCompat(scalaVersion.value)),
-    scalacOptions := List("-language:implicitConversions", "-noindent", "-Xprint-suspension")
+    scalacOptions ++= List("-language:implicitConversions", "-noindent", "-Xprint-suspension")
   )
 
   lazy val scalacticDotty = Project("scalacticDotty", file("scalactic.dotty"))

project/scalatest.scala

@@ -140,7 +140,7 @@ object ScalatestBuild extends BuildCommons with DottyBuild with NativeBuild with
 
   def sharedSettings: Seq[Setting[_]] = 
     commonSharedSettings ++ Seq(
-      scalaVersion := "2.13.0",
+      scalaVersion := "2.13.1",
       crossScalaVersions := supportedScalaVersions,
       libraryDependencies ++= {
         if (isDotty.value)

scalatest.dotty/src/main/scala/org/scalatest/CompileMacro.scala

@@ -16,6 +16,7 @@
 package org.scalatest
 
 import org.scalactic._
+import org.scalatest.words.{TypeCheckWord, CompileWord}
 import org.scalatest.exceptions._
 
 import scala.quoted._
@@ -157,4 +158,161 @@ object CompileMacro {
           )($prettifier)
        }
   }
+
+  // check that a code snippet does not compile
+  def assertNotCompileImpl[T](self: Expr[T], compileWord: Expr[CompileWord], pos: Expr[source.Position])(shouldOrMust: String)(implicit qctx: QuoteContext): Expr[Assertion] = {
+    import qctx.tasty.{_, given}
+
+    // parse and type check a code snippet, generate code to throw TestFailedException if both parse and type check succeeded
+    def checkNotCompile(code: String): Expr[Assertion] =
+      if (/*!typeChecks(code)*/ true) '{ Succeeded } // FIXME
+      else '{
+        val messageExpr = Resources.expectedCompileErrorButGotNone(${ Expr(code) })
+        throw new TestFailedException((_: StackDepthException) => Some(messageExpr), None, $pos)
+      }
+
+    self.unseal.underlyingArgument match {
+
+      case Apply(
+             Apply(
+               Select(_, shouldOrMustTerconvertToStringShouldOrMustWrapperTermName),
+               List(
+                 Literal(Constant(code: String))
+               )
+             ),
+             _
+           ) if shouldOrMustTerconvertToStringShouldOrMustWrapperTermName ==  "convertToString" + shouldOrMust.capitalize + "Wrapper" =>
+        // LHS is a normal string literal, call checkCompile with the extracted code string to generate code
+        checkNotCompile(code)
+
+      case Apply(
+             Apply(
+               Ident(shouldOrMustTerconvertToStringShouldOrMustWrapperTermName),
+               List(
+                 Literal(Constant(code: String))
+               )
+             ),
+             _
+           ) if shouldOrMustTerconvertToStringShouldOrMustWrapperTermName ==  "convertToString" + shouldOrMust.capitalize + "Wrapper" =>
+        checkNotCompile(code)
+
+      case other =>
+        qctx.error("The '" + shouldOrMust + " compile' syntax only works with String literals.")
+        '{???}
+    }
+  }
+
+  // used by shouldNot compile syntax, delegate to assertNotCompileImpl to generate code
+  def shouldNotCompileImpl(self: Expr[Matchers#AnyShouldWrapper[_]], compileWord: Expr[CompileWord])(pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Assertion] =
+    assertNotCompileImpl(self, compileWord, pos)("should")
+
+  // used by mustNot compile syntax, delegate to assertNotCompileImpl to generate code
+  def mustNotCompileImpl(self: Expr[MustMatchers#AnyMustWrapper[_]], compileWord: Expr[CompileWord])(pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Assertion] =
+    assertNotCompileImpl(self, compileWord, pos)("must")
+
+  // check that a code snippet does not compile
+  def assertNotTypeCheckImpl(self: Expr[Matchers#AnyShouldWrapper[_]], typeCheckWord: Expr[TypeCheckWord], pos: Expr[source.Position])(shouldOrMust: String)(implicit qctx: QuoteContext): Expr[Assertion] = {
+    import qctx.tasty.{_, given}
+
+    // parse and type check a code snippet, generate code to throw TestFailedException if both parse and type check succeeded
+    def checkNotTypeCheck(code: String): Expr[Assertion] =
+      if (/*!typeChecks(code)*/ true) '{ Succeeded } // FIXME
+      else '{
+        val messageExpr = Resources.expectedTypeErrorButGotNone(${ Expr(code) })
+        throw new TestFailedException((_: StackDepthException) => Some(messageExpr), None, $pos)
+      }
+
+    val methodName = shouldOrMust + "Not"
+
+    self.unseal.underlyingArgument match {
+      case Apply(
+             Apply(
+               Select(_, shouldOrMustTerconvertToStringShouldOrMustWrapperTermName),
+               List(
+                 Literal(code)
+               )
+             ),
+             _
+           ) if shouldOrMustTerconvertToStringShouldOrMustWrapperTermName ==  "convertToString" + shouldOrMust.capitalize + "Wrapper" =>
+        // LHS is a normal string literal, call checkNotTypeCheck with the extracted code string to generate code
+        checkNotTypeCheck(code.toString)
+
+      case Apply(
+             Apply(
+               Ident(shouldOrMustTerconvertToStringShouldOrMustWrapperTermName),
+               List(
+                 Literal(Constant(code: String))
+               )
+             ),
+             _
+           ) if shouldOrMustTerconvertToStringShouldOrMustWrapperTermName ==  "convertToString" + shouldOrMust.capitalize + "Wrapper" =>
+        // LHS is a normal string literal, call checkNotTypeCheck with the extracted code string to generate code
+        checkNotTypeCheck(code.toString)
+
+      case _ =>
+        qctx.error("The '" + shouldOrMust + "Not typeCheck' syntax only works with String literals.")
+        '{???}
+    }
+  }
+
+  // used by shouldNot typeCheck syntax, delegate to assertNotTypeCheckImpl to generate code
+  def shouldNotTypeCheckImpl(self: Expr[Matchers#AnyShouldWrapper[_]], typeCheckWord: Expr[TypeCheckWord])(pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Assertion] =
+    assertNotTypeCheckImpl(self, typeCheckWord, pos)("should")
+
+  // used by mustNot typeCheck syntax, delegate to assertNotTypeCheckImpl to generate code
+  def mustNotTypeCheckImpl(self: Expr[Matchers#AnyShouldWrapper[_]], typeCheckWord: Expr[TypeCheckWord])(pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Assertion] =
+    assertNotTypeCheckImpl(self, typeCheckWord, pos)("must")
+
+  // check that a code snippet compiles
+  def assertCompileImpl[T](self: Expr[T], compileWord: Expr[CompileWord], pos: Expr[source.Position])(shouldOrMust: String)(implicit qctx: QuoteContext): Expr[Assertion] = {
+    import qctx.tasty.{_, given}
+
+    // parse and type check a code snippet, generate code to throw TestFailedException if both parse and type check succeeded
+    def checkCompile(code: String): Expr[Assertion] =
+      if (/*typeChecks(code)*/ true) '{ Succeeded } // FIXME
+      else '{
+        val messageExpr = Resources.expectedNoErrorButGotTypeError("", ${ Expr(code) })
+        throw new TestFailedException((_: StackDepthException) => Some(messageExpr), None, $pos)
+      }
+
+    self.unseal.underlyingArgument match {
+
+      case Apply(
+             Apply(
+               Select(_, shouldOrMustTerconvertToStringShouldOrMustWrapperTermName),
+               List(
+                 Literal(Constant(code: String))
+               )
+             ),
+             _
+           ) if shouldOrMustTerconvertToStringShouldOrMustWrapperTermName ==  "convertToString" + shouldOrMust.capitalize + "Wrapper" =>
+        // LHS is a normal string literal, call checkCompile with the extracted code string to generate code
+        checkCompile(code.toString)
+
+      case Apply(
+             Apply(
+               Ident(shouldOrMustTerconvertToStringShouldOrMustWrapperTermName),
+               List(
+                 Literal(Constant(code: String))
+               )
+             ),
+             _
+           ) if shouldOrMustTerconvertToStringShouldOrMustWrapperTermName ==  "convertToString" + shouldOrMust.capitalize + "Wrapper" =>
+        // LHS is a normal string literal, call checkCompile with the extracted code string to generate code
+        checkCompile(code.toString)
+
+      case other =>
+        println("###other: " + other)
+        qctx.error("The '" + shouldOrMust + " compile' syntax only works with String literals.")
+        '{???}
+    }
+  }
+
+  // used by should compile syntax, delegate to assertCompileImpl to generate code
+  def shouldCompileImpl(self: Expr[Matchers#AnyShouldWrapper[_]], compileWord: Expr[CompileWord])(pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Assertion] =
+    assertCompileImpl(self, compileWord, pos)("should")
+
+    // used by should compile syntax, delegate to assertCompileImpl to generate code
+  def mustCompileImpl(self: Expr[MustMatchers#AnyMustWrapper[_]], compileWord: Expr[CompileWord])(pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Assertion] =
+    assertCompileImpl(self, compileWord, pos)("must")
 }

scalatest.dotty/src/main/scala/org/scalatest/matchers/Matcher.scala

@@ -17,6 +17,7 @@ package org.scalatest.matchers
 
 import org.scalactic._
 import org.scalatest.enablers._
+import org.scalatest.words._
 import org.scalatest.matchers.dsl._
 import org.scalatest.FailureMessages
 import org.scalatest.matchers.MatchersHelper.andMatchersAndApply

scalatest.dotty/src/main/scala/org/scalatest/matchers/MatchersCompileMacro.scala

@@ -168,6 +168,42 @@ object TypeMatcherMacro {
     '{ ($self).owner.or($rhs) }
   }
 
+  // Do checking on type parameter and generate AST to call TypeMatcherHelper.checkAType, used by 'shouldBe a [type]' syntax
+  def shouldBeATypeImpl(self: Expr[org.scalatest.matchers.should.Matchers#AnyShouldWrapper[_]], aType: Expr[ResultOfATypeInvocation[_]])(implicit qctx: QuoteContext): Expr[org.scalatest.Assertion] = {
+    import qctx.tasty.{_, given}
+    checkTypeParameter(qctx)(aType.unseal, "a")
+    '{
+      TypeMatcherHelper.assertAType(($self).leftSideValue, $aType, ($self).prettifier, ($self).pos)
+    }
+  }
+
+  // Do checking on type parameter and generate AST to call TypeMatcherHelper.checkAType, used by 'mustBe a [type]' syntax
+  def mustBeATypeImpl(self: Expr[org.scalatest.matchers.must.Matchers#AnyMustWrapper[_]], aType: Expr[ResultOfATypeInvocation[_]])(implicit qctx: QuoteContext): Expr[org.scalatest.Assertion] = {
+    import qctx.tasty.{_, given}
+    checkTypeParameter(qctx)(aType.unseal, "a")
+    '{
+      TypeMatcherHelper.assertAType(($self).leftSideValue, $aType, ($self).prettifier, ($self).pos)
+    }
+  }
+
+  // Do checking on type parameter and generate AST to call TypeMatcherHelper.checkAType, used by 'shouldBe an [type]' syntax
+  def shouldBeAnTypeImpl(self: Expr[org.scalatest.matchers.should.Matchers#AnyShouldWrapper[_]], anType: Expr[ResultOfAnTypeInvocation[_]])(implicit qctx: QuoteContext): Expr[org.scalatest.Assertion] = {
+    import qctx.tasty.{_, given}
+    checkTypeParameter(qctx)(anType.unseal, "an")
+    '{
+      TypeMatcherHelper.assertAnType(($self).leftSideValue, $anType, ($self).prettifier, ($self).pos)
+    }
+  }
+
+  // Do checking on type parameter and generate AST to call TypeMatcherHelper.checkAnType, used by 'mustBe an [type]' syntax
+  def mustBeAnTypeImpl(self: Expr[org.scalatest.matchers.must.Matchers#AnyMustWrapper[_]], anType: Expr[ResultOfAnTypeInvocation[_]])(implicit qctx: QuoteContext): Expr[org.scalatest.Assertion] = {
+    import qctx.tasty.{_, given}
+    checkTypeParameter(qctx)(anType.unseal, "an")
+    '{
+      TypeMatcherHelper.assertAnType(($self).leftSideValue, $anType, ($self).prettifier, ($self).pos)
+    }
+  }
+
 //   /*def expectTypeImpl(context: Context)(tree: context.Tree, beMethodName: String, assertMethodName: String): context.Expr[org.scalatest.Fact] = {
 //     import context.universe._