Skip to content

Commit 06316e6

Browse files
oderskyodersky
committed
Rename NameExtractor -> NameKind
1 parent 10ebd17 commit 06316e6

34 files changed

+121
-122
lines changed

‎compiler/src/dotty/tools/dotc/ast/Desugar.scala‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ import core._
66
import util.Positions._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
77
import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
88
import Decorators._
9-
import NameExtractors.{UniqueName, EvidenceParamName}
9+
import NameKinds.{UniqueName, EvidenceParamName}
1010
import language.higherKinds
1111
import typer.FrontEnd
1212
import collection.mutable.ListBuffer

‎compiler/src/dotty/tools/dotc/ast/tpd.scala‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ import Denotations._, Decorators._, DenotTransformers._
1212
import collection.mutable
1313
import util.{Property, SourceFile, NoSource}
1414
import typer.ErrorReporting._
15-
import NameExtractors.TempResultName
15+
import NameKinds.TempResultName
1616

1717
import scala.annotation.tailrec
1818
import scala.io.Codec

‎compiler/src/dotty/tools/dotc/core/Denotations.scala‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ import SymDenotations.{ SymDenotation, ClassDenotation, NoDenotation }
66
import Contexts.{Context, ContextBase}
77
import Names._
88
import NameOps._
9-
import NameExtractors._
9+
import NameKinds._
1010
import StdNames._
1111
import Symbols.NoSymbol
1212
import Symbols._

‎compiler/src/dotty/tools/dotc/core/NameExtractors.scala‎

Lines changed: 65 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -11,22 +11,22 @@ import Decorators._
1111
import Contexts.Context
1212
import collection.mutable
1313

14-
object NameExtractors {
14+
object NameKinds {
1515

16-
@sharable private val simpleExtractors = new mutable.HashMap[Int, ClassifiedNameExtractor]
17-
@sharable private val uniqueExtractors = new mutable.HashMap[String, UniqueNameExtractor]
18-
@sharable private val qualifiedExtractors = new mutable.HashMap[String, QualifiedNameExtractor]
16+
@sharable private val simpleNameKinds = new mutable.HashMap[Int, ClassifiedNameKind]
17+
@sharable private val uniqueNameKinds = new mutable.HashMap[String, UniqueNameKind]
18+
@sharable private val qualifiedNameKinds = new mutable.HashMap[String, QualifiedNameKind]
1919

2020
abstract class NameInfo extends DotClass {
21-
def extractor: NameExtractor
21+
def kind: NameKind
2222
def mkString(underlying: TermName): String
2323
def map(f: SimpleTermName => SimpleTermName): NameInfo = this
2424
}
2525

26-
abstract class NameExtractor(val tag: Int) extends DotClass { self =>
26+
abstract class NameKind(val tag: Int) extends DotClass { self =>
2727
type ThisInfo <: Info
2828
class Info extends NameInfo { this: ThisInfo =>
29-
def extractor = self
29+
def kind = self
3030
def mkString(underlying: TermName) = self.mkString(underlying, this)
3131
override def toString = infoString
3232
}
@@ -35,14 +35,14 @@ object NameExtractors {
3535
def infoString: String
3636
}
3737

38-
object SimpleTermNameExtractor extends NameExtractor(UTF8) { self =>
38+
object SimpleTermNameKind extends NameKind(UTF8) { self =>
3939
type ThisInfo = Info
4040
val info = new Info
4141
def mkString(underlying: TermName, info: ThisInfo) = unsupported("mkString")
4242
def infoString = unsupported("infoString")
4343
}
4444

45-
abstract class ClassifiedNameExtractor(tag: Int, val infoString: String) extends NameExtractor(tag) {
45+
abstract class ClassifiedNameKind(tag: Int, val infoString: String) extends NameKind(tag) {
4646
type ThisInfo = Info
4747
val info = new Info
4848
def apply(qual: TermName) =
@@ -51,26 +51,26 @@ object NameExtractors {
5151
case DerivedTermName(underlying, `info`) => Some(underlying)
5252
case _ => None
5353
}
54-
simpleExtractors(tag) = this
54+
simpleNameKinds(tag) = this
5555
}
5656

57-
class PrefixNameExtractor(tag: Int, prefix: String, optInfoString: String = "")
58-
extends ClassifiedNameExtractor(tag, if (optInfoString.isEmpty) s"Prefix $prefix" else optInfoString) {
57+
class PrefixNameKind(tag: Int, prefix: String, optInfoString: String = "")
58+
extends ClassifiedNameKind(tag, if (optInfoString.isEmpty) s"Prefix $prefix" else optInfoString) {
5959
def mkString(underlying: TermName, info: ThisInfo) =
6060
underlying.mapLast(n => termName(prefix + n.toString)).toString
6161
}
6262

63-
class SuffixNameExtractor(tag: Int, suffix: String, optInfoString: String = "")
64-
extends ClassifiedNameExtractor(tag, if (optInfoString.isEmpty) s"Suffix $suffix" else optInfoString) {
63+
class SuffixNameKind(tag: Int, suffix: String, optInfoString: String = "")
64+
extends ClassifiedNameKind(tag, if (optInfoString.isEmpty) s"Suffix $suffix" else optInfoString) {
6565
def mkString(underlying: TermName, info: ThisInfo) = underlying.toString ++ suffix
6666
}
6767

6868
trait QualifiedInfo extends NameInfo {
6969
val name: SimpleTermName
7070
}
7171

72-
class QualifiedNameExtractor(tag: Int, val separator: String)
73-
extends NameExtractor(tag) {
72+
class QualifiedNameKind(tag: Int, val separator: String)
73+
extends NameKind(tag) {
7474
type ThisInfo = QualInfo
7575
case class QualInfo(val name: SimpleTermName) extends Info with QualifiedInfo {
7676
override def map(f: SimpleTermName => SimpleTermName): NameInfo = new QualInfo(f(name))
@@ -89,7 +89,7 @@ object NameExtractors {
8989
s"$underlying$separator${info.name}"
9090
def infoString = s"Qualified $separator"
9191

92-
qualifiedExtractors(separator) = this
92+
qualifiedNameKinds(separator) = this
9393
}
9494

9595
object AnyQualifiedName {
@@ -100,14 +100,13 @@ object NameExtractors {
100100
}
101101
}
102102

103-
trait NumberedInfo {
103+
trait NumberedInfo extends NameInfo {
104104
def num: Int
105-
def extractor: NameExtractor
106105
}
107106

108-
abstract class NumberedNameExtractor(tag: Int, val infoString: String) extends NameExtractor(tag) { self =>
107+
abstract class NumberedNameKind(tag: Int, val infoString: String) extends NameKind(tag) { self =>
109108
type ThisInfo = NumberedInfo
110-
case class NumberedInfo(val num: Int) extends Info with NameExtractors.NumberedInfo {
109+
case class NumberedInfo(val num: Int) extends Info with NameKinds.NumberedInfo {
111110
override def toString = s"$infoString $num"
112111
}
113112
def apply(qual: TermName, num: Int) =
@@ -118,8 +117,8 @@ object NameExtractors {
118117
}
119118
}
120119

121-
case class UniqueNameExtractor(val separator: String)
122-
extends NumberedNameExtractor(UNIQUE, s"Unique $separator") {
120+
case class UniqueNameKind(val separator: String)
121+
extends NumberedNameKind(UNIQUE, s"Unique $separator") {
123122
override def definesNewName = true
124123
def mkString(underlying: TermName, info: ThisInfo) = {
125124
val safePrefix = str.sanitize(underlying.toString + separator)
@@ -129,76 +128,76 @@ object NameExtractors {
129128
def fresh(prefix: TermName = EmptyTermName)(implicit ctx: Context): TermName =
130129
ctx.freshNames.newName(prefix, this)
131130

132-
uniqueExtractors(separator) = this
131+
uniqueNameKinds(separator) = this
133132
}
134133

135134
object AnyUniqueName {
136135
def unapply(name: DerivedTermName): Option[(TermName, String, Int)] = name match {
137136
case DerivedTermName(qual, info: NumberedInfo) =>
138-
info.extractor match {
139-
case unique: UniqueNameExtractor => Some((qual, unique.separator, info.num))
137+
info.kind match {
138+
case unique: UniqueNameKind => Some((qual, unique.separator, info.num))
140139
case _ => None
141140
}
142141
case _ => None
143142
}
144143
}
145144

146-
val QualifiedName = new QualifiedNameExtractor(QUALIFIED, ".")
147-
val FlattenedName = new QualifiedNameExtractor(FLATTENED, "$")
148-
val ExpandedName = new QualifiedNameExtractor(EXPANDED, str.EXPAND_SEPARATOR)
149-
val TraitSetterName = new QualifiedNameExtractor(TRAITSETTER, str.TRAIT_SETTER_SEPARATOR)
145+
val QualifiedName = new QualifiedNameKind(QUALIFIED, ".")
146+
val FlattenedName = new QualifiedNameKind(FLATTENED, "$")
147+
val ExpandedName = new QualifiedNameKind(EXPANDED, str.EXPAND_SEPARATOR)
148+
val TraitSetterName = new QualifiedNameKind(TRAITSETTER, str.TRAIT_SETTER_SEPARATOR)
150149

151-
val UniqueName = new UniqueNameExtractor("$") {
150+
val UniqueName = new UniqueNameKind("$") {
152151
override def mkString(underlying: TermName, info: ThisInfo) =
153152
if (underlying.isEmpty) "$" + info.num + "$" else super.mkString(underlying, info)
154153
}
155154

156-
val InlineAccessorName = new UniqueNameExtractor("$_inlineAccessor_$")
157-
val TempResultName = new UniqueNameExtractor("ev$")
158-
val EvidenceParamName = new UniqueNameExtractor("evidence$")
159-
val DepParamName = new UniqueNameExtractor("<param>")
160-
val LazyImplicitName = new UniqueNameExtractor("$_lazy_implicit_$")
161-
val LazyLocalName = new UniqueNameExtractor("$lzy")
162-
val LazyLocalInitName = new UniqueNameExtractor("$lzyINIT")
163-
val LazyFieldOffsetName = new UniqueNameExtractor("$OFFSET")
164-
val LazyBitMapName = new UniqueNameExtractor(nme.BITMAP_PREFIX.toString)
165-
val NonLocalReturnKeyName = new UniqueNameExtractor("nonLocalReturnKey")
166-
val WildcardParamName = new UniqueNameExtractor("_$")
167-
val TailLabelName = new UniqueNameExtractor("tailLabel")
168-
val ExceptionBinderName = new UniqueNameExtractor("ex")
169-
val SkolemName = new UniqueNameExtractor("?")
170-
val LiftedTreeName = new UniqueNameExtractor("liftedTree")
171-
172-
val PatMatStdBinderName = new UniqueNameExtractor("x")
173-
val PatMatPiName = new UniqueNameExtractor("pi") // FIXME: explain what this is
174-
val PatMatPName = new UniqueNameExtractor("p") // FIXME: explain what this is
175-
val PatMatOName = new UniqueNameExtractor("o") // FIXME: explain what this is
176-
val PatMatCaseName = new UniqueNameExtractor("case")
177-
val PatMatMatchFailName = new UniqueNameExtractor("matchFail")
178-
val PatMatSelectorName = new UniqueNameExtractor("selector")
179-
180-
object DefaultGetterName extends NumberedNameExtractor(DEFAULTGETTER, "DefaultGetter") {
155+
val InlineAccessorName = new UniqueNameKind("$_inlineAccessor_$")
156+
val TempResultName = new UniqueNameKind("ev$")
157+
val EvidenceParamName = new UniqueNameKind("evidence$")
158+
val DepParamName = new UniqueNameKind("<param>")
159+
val LazyImplicitName = new UniqueNameKind("$_lazy_implicit_$")
160+
val LazyLocalName = new UniqueNameKind("$lzy")
161+
val LazyLocalInitName = new UniqueNameKind("$lzyINIT")
162+
val LazyFieldOffsetName = new UniqueNameKind("$OFFSET")
163+
val LazyBitMapName = new UniqueNameKind(nme.BITMAP_PREFIX.toString)
164+
val NonLocalReturnKeyName = new UniqueNameKind("nonLocalReturnKey")
165+
val WildcardParamName = new UniqueNameKind("_$")
166+
val TailLabelName = new UniqueNameKind("tailLabel")
167+
val ExceptionBinderName = new UniqueNameKind("ex")
168+
val SkolemName = new UniqueNameKind("?")
169+
val LiftedTreeName = new UniqueNameKind("liftedTree")
170+
171+
val PatMatStdBinderName = new UniqueNameKind("x")
172+
val PatMatPiName = new UniqueNameKind("pi") // FIXME: explain what this is
173+
val PatMatPName = new UniqueNameKind("p") // FIXME: explain what this is
174+
val PatMatOName = new UniqueNameKind("o") // FIXME: explain what this is
175+
val PatMatCaseName = new UniqueNameKind("case")
176+
val PatMatMatchFailName = new UniqueNameKind("matchFail")
177+
val PatMatSelectorName = new UniqueNameKind("selector")
178+
179+
object DefaultGetterName extends NumberedNameKind(DEFAULTGETTER, "DefaultGetter") {
181180
def mkString(underlying: TermName, info: ThisInfo) = {
182181
val prefix = if (underlying.isConstructorName) nme.DEFAULT_GETTER_INIT else underlying
183182
prefix.toString + nme.DEFAULT_GETTER + (info.num + 1)
184183
}
185184
}
186185

187-
object VariantName extends NumberedNameExtractor(VARIANT, "Variant") {
186+
object VariantName extends NumberedNameKind(VARIANT, "Variant") {
188187
val varianceToPrefix = Map(-1 -> '-', 0 -> '=', 1 -> '+')
189188
val prefixToVariance = Map('-' -> -1, '=' -> 0, '+' -> 1)
190189
def mkString(underlying: TermName, info: ThisInfo) = {
191190
varianceToPrefix(info.num).toString + underlying
192191
}
193192
}
194193

195-
val SuperAccessorName = new PrefixNameExtractor(SUPERACCESSOR, "super$")
196-
val InitializerName = new PrefixNameExtractor(INITIALIZER, "initial$")
197-
val ShadowedName = new PrefixNameExtractor(SHADOWED, "(shadowed)")
198-
val AvoidClashName = new SuffixNameExtractor(AVOIDCLASH, "$_avoid_name_clash_$")
199-
val ModuleClassName = new SuffixNameExtractor(OBJECTCLASS, "$", optInfoString = "ModuleClass")
194+
val SuperAccessorName = new PrefixNameKind(SUPERACCESSOR, "super$")
195+
val InitializerName = new PrefixNameKind(INITIALIZER, "initial$")
196+
val ShadowedName = new PrefixNameKind(SHADOWED, "(shadowed)")
197+
val AvoidClashName = new SuffixNameKind(AVOIDCLASH, "$_avoid_name_clash_$")
198+
val ModuleClassName = new SuffixNameKind(OBJECTCLASS, "$", optInfoString = "ModuleClass")
200199

201-
object SignedName extends NameExtractor(63) {
200+
object SignedName extends NameKind(63) {
202201

203202
/** @param parts resultSig followed by paramsSig */
204203
case class SignedInfo(sig: Signature) extends Info {
@@ -217,7 +216,7 @@ object NameExtractors {
217216
def infoString: String = "Signed"
218217
}
219218

220-
def simpleExtractorOfTag : collection.Map[Int, ClassifiedNameExtractor] = simpleExtractors
221-
def qualifiedExtractorOfSeparator: collection.Map[String, QualifiedNameExtractor] = qualifiedExtractors
222-
def uniqueExtractorOfSeparator : collection.Map[String, UniqueNameExtractor] = uniqueExtractors
219+
def simpleNameKindOfTag : collection.Map[Int, ClassifiedNameKind] = simpleNameKinds
220+
def qualifiedNameKindOfSeparator: collection.Map[String, QualifiedNameKind] = qualifiedNameKinds
221+
def uniqueNameKindOfSeparator : collection.Map[String, UniqueNameKind] = uniqueNameKinds
223222
}

‎compiler/src/dotty/tools/dotc/core/NameOps.scala‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ package core
44
import java.security.MessageDigest
55
import scala.annotation.switch
66
import scala.io.Codec
7-
import Names._, StdNames._, Contexts._, Symbols._, Flags._, NameExtractors._
7+
import Names._, StdNames._, Contexts._, Symbols._, Flags._, NameKinds._
88
import Decorators.PreNamedString
99
import util.{Chars, NameTransformer}
1010
import Chars.isOperatorPart
@@ -136,7 +136,7 @@ object NameOps {
136136
def expandedName(prefix: Name, separator: Name = nme.EXPAND_SEPARATOR): N =
137137
likeTyped {
138138
def qualify(name: SimpleTermName) =
139-
qualifiedExtractorOfSeparator(separator.toString)(prefix.toTermName, name)
139+
qualifiedNameKindOfSeparator(separator.toString)(prefix.toTermName, name)
140140
name rewrite {
141141
case name: SimpleTermName =>
142142
qualify(name)

‎compiler/src/dotty/tools/dotc/core/Names.scala‎

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ import java.util.HashMap
1919
//import annotation.volatile
2020

2121
object Names {
22-
import NameExtractors._
22+
import NameKinds._
2323

2424
/** A common class for things that can be turned into names.
2525
* Instances are both names and strings, the latter via a decorator.
@@ -75,9 +75,9 @@ object Names {
7575
def likeKinded(name: Name): ThisName
7676

7777
def derived(info: NameInfo): ThisName
78-
def derived(kind: ClassifiedNameExtractor): ThisName = derived(kind.info)
79-
def exclude(kind: NameExtractor): ThisName
80-
def is(kind: NameExtractor): Boolean
78+
def derived(kind: ClassifiedNameKind): ThisName = derived(kind.info)
79+
def exclude(kind: NameKind): ThisName
80+
def is(kind: NameKind): Boolean
8181
def debugString: String
8282

8383
def toText(printer: Printer): Text = printer.toText(this)
@@ -130,7 +130,7 @@ object Names {
130130

131131
def likeKinded(name: Name): TermName = name.toTermName
132132

133-
def info: NameInfo = SimpleTermNameExtractor.info
133+
def info: NameInfo = SimpleTermNameKind.info
134134
def underlying: TermName = unsupported("underlying")
135135

136136
@sharable private var derivedNames: AnyRef /* SimpleMap | j.u.HashMap */ =
@@ -174,8 +174,8 @@ object Names {
174174
* name as underlying name.
175175
*/
176176
def derived(info: NameInfo): TermName = {
177-
val thisKind = this.info.extractor
178-
val thatKind = info.extractor
177+
val thisKind = this.info.kind
178+
val thatKind = info.kind
179179
if (thisKind.tag < thatKind.tag || thatKind.definesNewName) add(info)
180180
else if (thisKind.tag > thatKind.tag) rewrap(underlying.derived(info))
181181
else {
@@ -184,15 +184,15 @@ object Names {
184184
}
185185
}
186186

187-
def exclude(kind: NameExtractor): TermName = {
188-
val thisKind = this.info.extractor
187+
def exclude(kind: NameKind): TermName = {
188+
val thisKind = this.info.kind
189189
if (thisKind.tag < kind.tag || thisKind.definesNewName) this
190190
else if (thisKind.tag > kind.tag) rewrap(underlying.exclude(kind))
191191
else underlying
192192
}
193193

194-
def is(kind: NameExtractor): Boolean = {
195-
val thisKind = this.info.extractor
194+
def is(kind: NameKind): Boolean = {
195+
val thisKind = this.info.kind
196196
thisKind == kind ||
197197
!thisKind.definesNewName && thisKind.tag > kind.tag && underlying.is(kind)
198198
}
@@ -295,8 +295,8 @@ object Names {
295295
def likeKinded(name: Name): TypeName = name.toTypeName
296296

297297
def derived(info: NameInfo): TypeName = toTermName.derived(info).toTypeName
298-
def exclude(kind: NameExtractor): TypeName = toTermName.exclude(kind).toTypeName
299-
def is(kind: NameExtractor) = toTermName.is(kind)
298+
def exclude(kind: NameKind): TypeName = toTermName.exclude(kind).toTypeName
299+
def is(kind: NameKind) = toTermName.is(kind)
300300

301301
override def toString = toTermName.toString
302302
override def debugString = toTermName.debugString + "/T"
@@ -512,7 +512,7 @@ object Names {
512512

513513
implicit val NameOrdering: Ordering[Name] = new Ordering[Name] {
514514
private def compareInfos(x: NameInfo, y: NameInfo): Int =
515-
if (x.extractor.tag != y.extractor.tag) x.extractor.tag - y.extractor.tag
515+
if (x.kind.tag != y.kind.tag) x.kind.tag - y.kind.tag
516516
else x match {
517517
case x: QualifiedInfo =>
518518
y match {

0 commit comments

Comments
 (0)