1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
package dotty.tools
package dottydoc
import dotc.core.Contexts.{ Context, ContextBase, FreshContext }
import dotc.core.Comments.{ ContextDoc, ContextDocstrings }
import dotc.util.SourceFile
import dotc.core.Phases.Phase
import dotc.typer.FrontEnd
import dottydoc.core.{ DocASTPhase, ContextDottydoc }
import model.Package
import dotty.tools.dottydoc.util.syntax._
import dotc.reporting.{ StoreReporter, MessageRendering }
import dotc.interfaces.Diagnostic.ERROR
import org.junit.Assert.fail
import java.io.{ BufferedWriter, OutputStreamWriter }
trait DottyDocTest extends MessageRendering {
dotty.tools.dotc.parsing.Scanners // initialize keywords
implicit val ctx: FreshContext = {
val base = new ContextBase
import base.settings._
val ctx = base.initialCtx.fresh
ctx.setSetting(ctx.settings.language, List("Scala2"))
ctx.setSetting(ctx.settings.YkeepComments, true)
ctx.setSetting(ctx.settings.YnoInline, true)
ctx.setSetting(ctx.settings.wikiSyntax, true)
ctx.setProperty(ContextDoc, new ContextDottydoc)
ctx.setSetting(
ctx.settings.classpath,
dotty.Jars.dottyLib
)
ctx.setReporter(new StoreReporter(ctx.reporter))
base.initialize()(ctx)
ctx
}
private def compilerWithChecker(assertion: Map[String, Package] => Unit) = new DocCompiler {
private[this] val assertionPhase: List[List[Phase]] =
List(new Phase {
def phaseName = "assertionPhase"
override def run(implicit ctx: Context): Unit =
assertion(ctx.docbase.packages)
if (ctx.reporter.hasErrors) {
System.err.println("reporter had errors:")
ctx.reporter.removeBufferedMessages.foreach { msg =>
System.err.println {
messageAndPos(msg.contained, msg.pos, diagnosticLevel(msg))
}
}
}
}) :: Nil
override def phases =
super.phases ++ assertionPhase
}
private def callingMethod: String =
Thread.currentThread.getStackTrace.find {
_.getMethodName match {
case "checkSource" | "callingMethod" | "getStackTrace" | "currentThread" =>
false
case _ =>
true
}
}
.map(_.getMethodName)
.getOrElse {
throw new IllegalStateException("couldn't get calling method via reflection")
}
private def sourceFileFromString(name: String, contents: String): SourceFile = {
val virtualFile = new scala.reflect.io.VirtualFile(name)
val writer = new BufferedWriter(new OutputStreamWriter(virtualFile.output, "UTF-8"))
writer.write(contents)
writer.close()
new SourceFile(virtualFile, scala.io.Codec.UTF8)
}
def checkSource(source: String)(assertion: Map[String, Package] => Unit): Unit = {
val c = compilerWithChecker(assertion)
c.rootContext(ctx)
val run = c.newRun
run.compileSources(sourceFileFromString(callingMethod, source) :: Nil)
}
def checkFiles(sources: List[String])(assertion: Map[String, Package] => Unit): Unit = {
val c = compilerWithChecker(assertion)
c.rootContext(ctx)
val run = c.newRun
run.compile(sources)
}
def checkSources(sourceFiles: List[SourceFile])(assertion: Map[String, Package] => Unit): Unit = {
val c = compilerWithChecker(assertion)
c.rootContext(ctx)
val run = c.newRun
run.compileSources(sourceFiles)
}
}
|