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
|
/* NSC -- new Scala compiler
* Copyright 2005-2011 LAMP/EPFL
* @author Gilles Dubochet
*/
package scala.reflect.makro
package runtime
trait Reifiers {
self: Context =>
import mirror._
lazy val reflectMirrorPrefix: Tree = {
// [Eugene] how do I typecheck this without undergoing this tiresome (and, in general, incorrect) procedure?
val prefix: Tree = Select(Select(Ident(definitions.ScalaPackage), newTermName("reflect")), newTermName("mirror"))
val prefixTpe = typeCheck(TypeApply(Select(prefix, newTermName("asInstanceOf")), List(SingletonTypeTree(prefix)))).tpe
typeCheck(prefix) setType prefixTpe
}
def reifyTree(prefix: Tree, tree: Tree): Tree =
reifyTopLevel(prefix, tree)
def reifyType(prefix: Tree, tpe: Type, dontSpliceAtTopLevel: Boolean = false, noTypeVariablesInResult: Boolean = false): Tree =
reifyTopLevel(prefix, tpe, dontSpliceAtTopLevel, noTypeVariablesInResult)
def unreifyTree(tree: Tree): Tree =
Select(tree, definitions.ExprEval)
def reifyTopLevel(prefix: Tree, reifee: Any, dontSpliceAtTopLevel: Boolean = false, requireGroundTypeTag: Boolean = false): Tree = {
// [Eugene] the plumbing is not very pretty, but anyways factoring out the reifier seems like a necessary step to me
import scala.reflect.reify._
val reifier = mkReifier(mirror)(callsiteTyper, prefix, reifee, dontSpliceAtTopLevel, requireGroundTypeTag)
try {
val result = reifier.reified
logFreeVars(expandee.pos, result)
result
} catch {
case ex: reifier.ReificationError =>
// // this is a "soft" exception - it will normally be caught by the macro
// // consequently, we need to log the stack trace here, so that it doesn't get lost
// if (settings.Yreifydebug.value) {
// val message = new java.io.StringWriter()
// ex.printStackTrace(new java.io.PrintWriter(message))
// println(scala.compat.Platform.EOL + message)
// }
val xlated = new ReificationError(ex.pos, ex.msg)
xlated.setStackTrace(ex.getStackTrace)
throw xlated
case ex: reifier.UnexpectedReificationError =>
val xlated = new UnexpectedReificationError(ex.pos, ex.msg, ex.cause)
xlated.setStackTrace(ex.getStackTrace)
throw xlated
}
}
class ReificationError(var pos: Position, val msg: String) extends Throwable(msg)
object ReificationError extends ReificationErrorExtractor {
def unapply(error: ReificationError): Option[(Position, String)] = Some((error.pos, error.msg))
}
class UnexpectedReificationError(val pos: Position, val msg: String, val cause: Throwable = null) extends Throwable(msg, cause)
object UnexpectedReificationError extends UnexpectedReificationErrorExtractor {
def unapply(error: UnexpectedReificationError): Option[(Position, String, Throwable)] = Some((error.pos, error.msg, error.cause))
}
}
|
