Add test for stricter indentation

Ref lampepfl/dotty 10671

Author: eed3si9n

compiler/test/dotty/tools/DottyTest.scala

@@ -38,6 +38,10 @@ trait DottyTest extends ContextEscapeDetection {
   override def clearCtx() = {
     ctx = null
   }
+  def resetCtx() = {
+    clearCtx()
+    ctx = initialCtx
+  }
 
   protected def initializeCtx(fc: FreshContext): Unit = {
     fc.setSetting(fc.settings.encoding, "UTF8")

compiler/test/dotty/tools/dotc/parsing/DottyScannerTest.scala

@@ -0,0 +1,45 @@
+package dotty.tools
+package dotc
+package parsing
+
+import dotty.tools.io._
+import scala.io.Codec
+import util._
+import Tokens._, Scanners._
+import org.junit.Test
+
+class DottyScannerTest extends ScannerTest {
+
+  val blackList = List(
+      "/scaladoc/scala/tools/nsc/doc/html/page/Index.scala",
+      "/scaladoc/scala/tools/nsc/doc/html/page/Template.scala"
+    )
+
+  def scanDir(path: String): Unit = scanDir(Directory(path))
+
+  def scanDir(dir: Directory): Unit = {
+    if (blackList exists (dir.jpath.toString endsWith _))
+      println(s"blacklisted package: ${dir.toAbsolute.jpath}")
+    else
+      for (f <- dir.files)
+        if (f.name.endsWith(".scala"))
+          if (blackList exists (f.jpath.toString endsWith _))
+            println(s"blacklisted file: ${f.toAbsolute.jpath}")
+          else
+            scan(new PlainFile(f))
+    for (d <- dir.dirs)
+      scanDir(d.path)
+  }
+
+  @Test
+  def scanList() = {
+    println(System.getProperty("user.dir"))
+    scan("compiler/src/dotty/tools/dotc/core/Symbols.scala")
+    scan("compiler/src/dotty/tools/dotc/core/Symbols.scala")
+  }
+
+  @Test
+  def scanDotty() = {
+    scanDir("compiler/src")
+  }
+}

compiler/test/dotty/tools/dotc/parsing/IndentTest.scala

@@ -0,0 +1,34 @@
+package dotty.tools
+package dotc
+package parsing
+
+import ast.untpd._
+import org.junit.Test
+
+class IndentTest extends ScannerTest:
+
+  @Test
+  def parseBraces: Unit =
+    val code = s"""
+      |class A {
+      |  val x = 1
+      |    val y = 2
+      |}""".stripMargin
+    assert(scanTextEither(code).isRight)
+
+  @Test
+  def parseIndents: Unit =
+    val code = s"""
+      |class A:
+      |  val x = 1
+      |""".stripMargin
+    assert(scanTextEither(code).isRight)
+
+  @Test
+  def superfluousIndents: Unit =
+    val code = s"""
+      |class A:
+      |  val x = 1
+      |    val y = 2
+      |""".stripMargin
+    assert(scanTextEither(code).isLeft)

compiler/test/dotty/tools/dotc/parsing/ParserTest.scala

@@ -8,10 +8,12 @@ import core._
 import scala.io.Codec
 import Tokens._, Parsers._
 import ast.untpd._
+import reporting.Diagnostic
 import org.junit.Test
 import scala.collection.mutable.ListBuffer
 
 class ParserTest extends DottyTest {
+  import ParserTest._
 
   def parse(name: String): Tree = parse(new PlainFile(File(name)))
 
@@ -21,17 +23,25 @@ class ParserTest extends DottyTest {
   def reset() = {
     parsed = 0
     parsedTrees.clear()
+    resetCtx()
   }
 
-  def parse(file: PlainFile): Tree = parseSource(new SourceFile(file, Codec.UTF8))
+  def parse(file: PlainFile): Tree = parseSourceEither(new SourceFile(file, Codec.UTF8)).toTry.get
 
-  private def parseSource(source: SourceFile): Tree = {
+  private def parseSourceEither(source: SourceFile): Either[ParserError, Tree] = {
     //println("***** parsing " + source.file)
     val parser = new Parser(source)
     val tree = parser.parse()
-    parsed += 1
-    parsedTrees += tree
-    tree
+    if (getCtx.reporter.hasErrors) {
+      val result = Left(ParserError(getCtx.reporter.allErrors))
+      reset()
+      result
+    }
+    else {
+      parsed += 1
+      parsedTrees += tree
+      Right(tree)
+    }
   }
 
   def parseDir(path: String): Unit = parseDir(Directory(path))
@@ -43,5 +53,12 @@ class ParserTest extends DottyTest {
       parseDir(d.path)
   }
 
-  def parseText(code: String): Tree = parseSource(SourceFile.virtual("<code>", code))
+  def parseText(code: String): Tree = parseTextEither(code).toTry.get
+
+  def parseTextEither(code: String): Either[ParserError, Tree] =
+    parseSourceEither(SourceFile.virtual("<code>", code))
+}
+
+object ParserTest {
+  case class ParserError(errors: List[Diagnostic.Error]) extends RuntimeException
 }

compiler/test/dotty/tools/dotc/parsing/ScannerTest.scala

@@ -6,55 +6,32 @@ import dotty.tools.io._
 import scala.io.Codec
 import util._
 import Tokens._, Scanners._
-import org.junit.Test
+import reporting.Diagnostic
 
-class ScannerTest extends DottyTest {
-
-  val blackList = List(
-      "/scaladoc/scala/tools/nsc/doc/html/page/Index.scala",
-      "/scaladoc/scala/tools/nsc/doc/html/page/Template.scala"
-    )
+trait ScannerTest extends DottyTest:
+  import ParserTest._
 
   def scan(name: String): Unit = scan(new PlainFile(File(name)))
 
-  def scan(file: PlainFile): Unit = {
+  def scan(file: PlainFile): Unit = scanSourceEither(new SourceFile(file, Codec.UTF8)).toTry.get
+
+  def reset() = resetCtx()
+
+  private def scanSourceEither(source: SourceFile): Either[ParserError, Unit] =
     //println("***** scanning " + file)
-    val source = new SourceFile(file, Codec.UTF8)
     val scanner = new Scanner(source)
     var i = 0
-    while (scanner.token != EOF) {
+    while scanner.token != EOF do
 //    print("[" + scanner.token.show +"]")
       scanner.nextToken()
 //      i += 1
 //      if (i % 10 == 0) println()
-    }
-  }
-
-  def scanDir(path: String): Unit = scanDir(Directory(path))
-
-  def scanDir(dir: Directory): Unit = {
-    if (blackList exists (dir.jpath.toString endsWith _))
-      println(s"blacklisted package: ${dir.toAbsolute.jpath}")
-    else
-      for (f <- dir.files)
-        if (f.name.endsWith(".scala"))
-          if (blackList exists (f.jpath.toString endsWith _))
-            println(s"blacklisted file: ${f.toAbsolute.jpath}")
-          else
-            scan(new PlainFile(f))
-    for (d <- dir.dirs)
-      scanDir(d.path)
-  }
-
-  @Test
-  def scanList() = {
-    println(System.getProperty("user.dir"))
-    scan("compiler/src/dotty/tools/dotc/core/Symbols.scala")
-    scan("compiler/src/dotty/tools/dotc/core/Symbols.scala")
-  }
-
-  @Test
-  def scanDotty() = {
-    scanDir("src")
-  }
-}
+
+    if getCtx.reporter.hasErrors || getCtx.reporter.hasWarnings then
+      val result = Left(ParserError(getCtx.reporter.allErrors))
+      reset()
+      result
+    else Right(())
+
+  def scanTextEither(code: String): Either[ParserError, Unit] = scanSourceEither(SourceFile.virtual("<code>", code))
+  def scanText(code: String): Unit = scanTextEither(code).toTry.get