Skip to content

Commit 93d736b

Browse files
committed
More modifier lock down in Trees.
This commit exposes a number of inexhaustive matches: [warn] /Users/jason/code/dotty/src/dotty/tools/dotc/core/Trees.scala:716: match may not be exhaustive. [warn] It would fail on the following inputs: Function(_, _), GenericApply(), ModuleDef(_, _, _), TypedSplice() [warn] def transform(tree: Tree[T], c: C): Tree[T] = tree match { [warn] ^ [warn] /Users/jason/code/dotty/src/dotty/tools/dotc/core/Trees.scala:870: match may not be exhaustive. [warn] It would fail on the following inputs: Function(_, _), GenericApply(), ModuleDef(_, _, _), TypedSplice() [warn] def foldOver(x: T, tree: Tree[U]): T = tree match { [warn] ^ [warn] two warnings found [info] Compiling 52 Scala sources to /Users/jason/code/dotty/target/scala-2.10/classes... [warn] /Users/jason/code/dotty/src/dotty/tools/dotc/core/PluggableTransformers.scala:80: match may not be exhaustive. [warn] It would fail on the following inputs: Alternative(_), AndTypeTree(_, _), Annotated(_, _), AppliedTypeTree(_, _), Assign(_, _), Bind(_, _), Block(_, _), CaseDef(_, _, _), ClassDef(_, _, _, _), DefDef(_, _, _, _, _, _), EmptyTree(), EmptyValDef(), Function(_, _), GenericApply(), If(_, _, _), Import(_, _), Literal(_), Match(_, _), ModuleDef(_, _, _), NamedArg(_, _), New(_), OrTypeTree(_, _), PackageDef(_, _), Pair(_, _), RefineTypeTree(_, _), Return(_, _), SelectFromTypeTree(_, _), SeqLiteral(_, _), Shared(_), SingletonTypeTree(_), Super(_, _), Template(_, _, _), This(_), Throw(_), Tree(), Try(_, _, _), TypeBoundsTree(_, _), TypeDef(_, _, _), TypeTree(_), Typed(_, _), TypedSplice(), UnApply(_, _) [warn] protected def postProcess(tree: Tree[T], old: Tree[T], c: Context, plugins: Plugins): Tree[T] = tree match { [warn] ^ [warn] /Users/jason/code/dotty/src/dotty/tools/dotc/core/Trees.scala:716: match may not be exhaustive. [warn] It would fail on the following inputs: Function(_, _), GenericApply(), ModuleDef(_, _, _), TypedSplice() [warn] def transform(tree: Tree[T], c: C): Tree[T] = tree match { [warn] ^ [warn] /Users/jason/code/dotty/src/dotty/tools/dotc/core/Trees.scala:870: match may not be exhaustive. [warn] It would fail on the following inputs: Function(_, _), GenericApply(), ModuleDef(_, _, _), TypedSplice() [warn] def foldOver(x: T, tree: Tree[U]): T = tree match { [warn] ^ [warn] /Users/jason/code/dotty/src/dotty/tools/dotc/core/TypedTrees.scala:359: match may not be exhaustive. [warn] It would fail on the following inputs: EmptyTree(), GenericApply(), Try(_, _, _) [warn] def checkType(tree: tpd.Tree)(implicit ctx: Context): Unit = tree match { [warn]
1 parent a0e343a commit 93d736b

File tree

1 file changed

+22
-22
lines changed

1 file changed

+22
-22
lines changed

src/dotty/tools/dotc/core/Trees.scala

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ object Trees {
3030
* - Type checking an untyped tree will remove all embedded `TypedSplice`
3131
* nodes.
3232
*/
33-
abstract class Tree[T] extends DotClass {
33+
sealed abstract class Tree[T] extends DotClass {
3434

3535
/** The tree's position. Except
3636
* for Shared nodes, it is always ensured that a tree's position
@@ -54,7 +54,7 @@ object Trees {
5454
/** Copy `tpe` attribute from tree `from` into this tree, independently
5555
* whether it is null or not.
5656
*/
57-
def copyAttr(from: Tree[T]): ThisTree[T] = {
57+
final def copyAttr(from: Tree[T]): ThisTree[T] = {
5858
_tpe = from._tpe
5959
this.asInstanceOf[ThisTree[T]]
6060
}
@@ -92,11 +92,11 @@ object Trees {
9292
/** Is this tree either the empty tree or the empty ValDef? */
9393
def isEmpty: Boolean = false
9494

95-
override def hashCode(): Int = System.identityHashCode(this)
96-
override def equals(that: Any) = this eq that.asInstanceOf[AnyRef]
95+
override final def hashCode(): Int = System.identityHashCode(this)
96+
override final def equals(that: Any) = this eq that.asInstanceOf[AnyRef]
9797
}
9898

99-
class UnAssignedTypeException[T](tree: Tree[T]) extends RuntimeException {
99+
final class UnAssignedTypeException[T](tree: Tree[T]) extends RuntimeException {
100100
override def getMessage: String = s"type of $tree is not assigned"
101101
}
102102

@@ -108,35 +108,35 @@ object Trees {
108108
/** Instances of this class are trees for which isType is definitely true.
109109
* Note that some trees have isType = true without being TypTrees (e.g. Ident, AnnotatedTree)
110110
*/
111-
trait TypTree[T] extends Tree[T] {
111+
sealed trait TypTree[T] extends Tree[T] {
112112
type ThisTree[T] <: TypTree[T]
113113
override def isType = true
114114
}
115115

116116
/** Instances of this class are trees for which isTerm is definitely true.
117117
* Note that some trees have isTerm = true without being TermTrees (e.g. Ident, AnnotatedTree)
118118
*/
119-
trait TermTree[T] extends Tree[T] {
119+
sealed trait TermTree[T] extends Tree[T] {
120120
type ThisTree[T] <: TermTree[T]
121121
override def isTerm = true
122122
}
123123

124124
/** Instances of this class are trees which are not terms but are legal
125125
* parts of patterns.
126126
*/
127-
trait PatternTree[T] extends Tree[T] {
127+
sealed trait PatternTree[T] extends Tree[T] {
128128
type ThisTree[T] <: PatternTree[T]
129129
override def isPattern = true
130130
}
131131

132132
/** Tree's symbol can be derived from its type */
133-
abstract class SymTree[T] extends Tree[T] {
133+
sealed abstract class SymTree[T] extends Tree[T] {
134134
type ThisTree[T] <: SymTree[T]
135-
override def denot(implicit ctx: Context) = tpe match {
135+
override final def denot(implicit ctx: Context) = tpe match {
136136
case tpe: NamedType => tpe.denot
137137
case _ => NoDenotation
138138
}
139-
override def symbol(implicit ctx: Context): Symbol = tpe match {
139+
override final def symbol(implicit ctx: Context): Symbol = tpe match {
140140
case tpe: Type => if (isType) tpe.typeSymbol else tpe.termSymbol
141141
case _ => NoSymbol
142142
}
@@ -145,33 +145,33 @@ object Trees {
145145
/** Tree's symbol/isType/isTerm properties come from a subtree identified
146146
* by `forwardTo`.
147147
*/
148-
abstract class ProxyTree[T] extends Tree[T] {
148+
sealed abstract class ProxyTree[T] extends Tree[T] {
149149
type ThisTree[T] <: ProxyTree[T]
150150
def forwardTo: Tree[T]
151-
override def denot(implicit ctx: Context): Denotation = forwardTo.denot
152-
override def symbol(implicit ctx: Context): Symbol = forwardTo.symbol
151+
override final def denot(implicit ctx: Context): Denotation = forwardTo.denot
152+
override final def symbol(implicit ctx: Context): Symbol = forwardTo.symbol
153153
override def isTerm = forwardTo.isTerm
154154
override def isType = forwardTo.isType
155155
}
156156

157157
/** Tree has a name */
158-
abstract class NameTree[T] extends SymTree[T] {
158+
sealed abstract class NameTree[T] extends SymTree[T] {
159159
type ThisTree[T] <: NameTree[T]
160160
def name: Name
161161
}
162162

163163
/** Tree refers by name to a denotation */
164-
abstract class RefTree[T] extends NameTree[T] {
164+
sealed abstract class RefTree[T] extends NameTree[T] {
165165
type ThisTree[T] <: RefTree[T]
166166
def qualifier: Tree[T]
167167
override def isType = name.isTypeName
168168
override def isTerm = name.isTermName
169169
}
170170

171171
/** Tree represents a definition */
172-
abstract class DefTree[T] extends NameTree[T] {
172+
sealed abstract class DefTree[T] extends NameTree[T] {
173173
type ThisTree[T] <: DefTree[T]
174-
override def isDef = true
174+
override final def isDef = true
175175
}
176176

177177
// ----------- Tree case classes ------------------------------------
@@ -477,7 +477,7 @@ object Trees {
477477
def forwardTo = arg
478478
}
479479

480-
trait AlwaysEmpty[T] extends Tree[T] {
480+
sealed trait AlwaysEmpty[T] extends Tree[T] {
481481
override val pos = NoPosition
482482
override def tpe = unsupported("tpe")
483483
override def withType(tpe: Type) = unsupported("withType")
@@ -519,7 +519,7 @@ object Trees {
519519
// ----- Tree cases that exist in untyped form only ------------------
520520

521521
/** A typed subtree of an untyped tree needs to be wrapped in a TypedSlice */
522-
class TypedSplice(tree: TypedTree) extends UntypedTree {
522+
final class TypedSplice(tree: TypedTree) extends UntypedTree {
523523
val pos = tree.pos
524524
}
525525

@@ -707,7 +707,7 @@ object Trees {
707707
}
708708

709709
abstract class TreeTransformer[T, C] {
710-
var sharedMemo: Map[Shared[T], Shared[T]] = Map()
710+
final var sharedMemo: Map[Shared[T], Shared[T]] = Map()
711711

712712
def transform(tree: Tree[T], c: C): Tree[T] = tree match {
713713
case Ident(name) =>
@@ -856,7 +856,7 @@ object Trees {
856856
}
857857

858858
abstract class TreeAccumulator[T, U] extends ((T, Tree[U]) => T) {
859-
var sharedMemo: Map[Shared[U], T] = Map()
859+
final var sharedMemo: Map[Shared[U], T] = Map()
860860
def apply(x: T, tree: Tree[U]): T
861861
def apply(x: T, trees: List[Tree[U]]): T = (x /: trees)(apply)
862862
def foldOver(x: T, tree: Tree[U]): T = tree match {

0 commit comments

Comments
 (0)