diff options
Diffstat (limited to 'compiler/src/dotty/tools/dotc/core/NameExtractors.scala')
| -rw-r--r-- | compiler/src/dotty/tools/dotc/core/NameExtractors.scala | 131 |
1 files changed, 65 insertions, 66 deletions
diff --git a/compiler/src/dotty/tools/dotc/core/NameExtractors.scala b/compiler/src/dotty/tools/dotc/core/NameExtractors.scala index 1439ce002..7350087a5 100644 --- a/compiler/src/dotty/tools/dotc/core/NameExtractors.scala +++ b/compiler/src/dotty/tools/dotc/core/NameExtractors.scala @@ -11,22 +11,22 @@ import Decorators._ import Contexts.Context import collection.mutable -object NameExtractors { +object NameKinds { - @sharable private val simpleExtractors = new mutable.HashMap[Int, ClassifiedNameExtractor] - @sharable private val uniqueExtractors = new mutable.HashMap[String, UniqueNameExtractor] - @sharable private val qualifiedExtractors = new mutable.HashMap[String, QualifiedNameExtractor] + @sharable private val simpleNameKinds = new mutable.HashMap[Int, ClassifiedNameKind] + @sharable private val uniqueNameKinds = new mutable.HashMap[String, UniqueNameKind] + @sharable private val qualifiedNameKinds = new mutable.HashMap[String, QualifiedNameKind] abstract class NameInfo extends DotClass { - def extractor: NameExtractor + def kind: NameKind def mkString(underlying: TermName): String def map(f: SimpleTermName => SimpleTermName): NameInfo = this } - abstract class NameExtractor(val tag: Int) extends DotClass { self => + abstract class NameKind(val tag: Int) extends DotClass { self => type ThisInfo <: Info class Info extends NameInfo { this: ThisInfo => - def extractor = self + def kind = self def mkString(underlying: TermName) = self.mkString(underlying, this) override def toString = infoString } @@ -35,14 +35,14 @@ object NameExtractors { def infoString: String } - object SimpleTermNameExtractor extends NameExtractor(UTF8) { self => + object SimpleTermNameKind extends NameKind(UTF8) { self => type ThisInfo = Info val info = new Info def mkString(underlying: TermName, info: ThisInfo) = unsupported("mkString") def infoString = unsupported("infoString") } - abstract class ClassifiedNameExtractor(tag: Int, val infoString: String) extends NameExtractor(tag) { + abstract class ClassifiedNameKind(tag: Int, val infoString: String) extends NameKind(tag) { type ThisInfo = Info val info = new Info def apply(qual: TermName) = @@ -51,17 +51,17 @@ object NameExtractors { case DerivedTermName(underlying, `info`) => Some(underlying) case _ => None } - simpleExtractors(tag) = this + simpleNameKinds(tag) = this } - class PrefixNameExtractor(tag: Int, prefix: String, optInfoString: String = "") - extends ClassifiedNameExtractor(tag, if (optInfoString.isEmpty) s"Prefix $prefix" else optInfoString) { + class PrefixNameKind(tag: Int, prefix: String, optInfoString: String = "") + extends ClassifiedNameKind(tag, if (optInfoString.isEmpty) s"Prefix $prefix" else optInfoString) { def mkString(underlying: TermName, info: ThisInfo) = underlying.mapLast(n => termName(prefix + n.toString)).toString } - class SuffixNameExtractor(tag: Int, suffix: String, optInfoString: String = "") - extends ClassifiedNameExtractor(tag, if (optInfoString.isEmpty) s"Suffix $suffix" else optInfoString) { + class SuffixNameKind(tag: Int, suffix: String, optInfoString: String = "") + extends ClassifiedNameKind(tag, if (optInfoString.isEmpty) s"Suffix $suffix" else optInfoString) { def mkString(underlying: TermName, info: ThisInfo) = underlying.toString ++ suffix } @@ -69,8 +69,8 @@ object NameExtractors { val name: SimpleTermName } - class QualifiedNameExtractor(tag: Int, val separator: String) - extends NameExtractor(tag) { + class QualifiedNameKind(tag: Int, val separator: String) + extends NameKind(tag) { type ThisInfo = QualInfo case class QualInfo(val name: SimpleTermName) extends Info with QualifiedInfo { override def map(f: SimpleTermName => SimpleTermName): NameInfo = new QualInfo(f(name)) @@ -89,7 +89,7 @@ object NameExtractors { s"$underlying$separator${info.name}" def infoString = s"Qualified $separator" - qualifiedExtractors(separator) = this + qualifiedNameKinds(separator) = this } object AnyQualifiedName { @@ -100,14 +100,13 @@ object NameExtractors { } } - trait NumberedInfo { + trait NumberedInfo extends NameInfo { def num: Int - def extractor: NameExtractor } - abstract class NumberedNameExtractor(tag: Int, val infoString: String) extends NameExtractor(tag) { self => + abstract class NumberedNameKind(tag: Int, val infoString: String) extends NameKind(tag) { self => type ThisInfo = NumberedInfo - case class NumberedInfo(val num: Int) extends Info with NameExtractors.NumberedInfo { + case class NumberedInfo(val num: Int) extends Info with NameKinds.NumberedInfo { override def toString = s"$infoString $num" } def apply(qual: TermName, num: Int) = @@ -118,8 +117,8 @@ object NameExtractors { } } - case class UniqueNameExtractor(val separator: String) - extends NumberedNameExtractor(UNIQUE, s"Unique $separator") { + case class UniqueNameKind(val separator: String) + extends NumberedNameKind(UNIQUE, s"Unique $separator") { override def definesNewName = true def mkString(underlying: TermName, info: ThisInfo) = { val safePrefix = str.sanitize(underlying.toString + separator) @@ -129,62 +128,62 @@ object NameExtractors { def fresh(prefix: TermName = EmptyTermName)(implicit ctx: Context): TermName = ctx.freshNames.newName(prefix, this) - uniqueExtractors(separator) = this + uniqueNameKinds(separator) = this } object AnyUniqueName { def unapply(name: DerivedTermName): Option[(TermName, String, Int)] = name match { case DerivedTermName(qual, info: NumberedInfo) => - info.extractor match { - case unique: UniqueNameExtractor => Some((qual, unique.separator, info.num)) + info.kind match { + case unique: UniqueNameKind => Some((qual, unique.separator, info.num)) case _ => None } case _ => None } } - val QualifiedName = new QualifiedNameExtractor(QUALIFIED, ".") - val FlattenedName = new QualifiedNameExtractor(FLATTENED, "$") - val ExpandedName = new QualifiedNameExtractor(EXPANDED, str.EXPAND_SEPARATOR) - val TraitSetterName = new QualifiedNameExtractor(TRAITSETTER, str.TRAIT_SETTER_SEPARATOR) + val QualifiedName = new QualifiedNameKind(QUALIFIED, ".") + val FlattenedName = new QualifiedNameKind(FLATTENED, "$") + val ExpandedName = new QualifiedNameKind(EXPANDED, str.EXPAND_SEPARATOR) + val TraitSetterName = new QualifiedNameKind(TRAITSETTER, str.TRAIT_SETTER_SEPARATOR) - val UniqueName = new UniqueNameExtractor("$") { + val UniqueName = new UniqueNameKind("$") { override def mkString(underlying: TermName, info: ThisInfo) = if (underlying.isEmpty) "$" + info.num + "$" else super.mkString(underlying, info) } - val InlineAccessorName = new UniqueNameExtractor("$_inlineAccessor_$") - val TempResultName = new UniqueNameExtractor("ev$") - val EvidenceParamName = new UniqueNameExtractor("evidence$") - val DepParamName = new UniqueNameExtractor("<param>") - val LazyImplicitName = new UniqueNameExtractor("$_lazy_implicit_$") - val LazyLocalName = new UniqueNameExtractor("$lzy") - val LazyLocalInitName = new UniqueNameExtractor("$lzyINIT") - val LazyFieldOffsetName = new UniqueNameExtractor("$OFFSET") - val LazyBitMapName = new UniqueNameExtractor(nme.BITMAP_PREFIX.toString) - val NonLocalReturnKeyName = new UniqueNameExtractor("nonLocalReturnKey") - val WildcardParamName = new UniqueNameExtractor("_$") - val TailLabelName = new UniqueNameExtractor("tailLabel") - val ExceptionBinderName = new UniqueNameExtractor("ex") - val SkolemName = new UniqueNameExtractor("?") - val LiftedTreeName = new UniqueNameExtractor("liftedTree") - - val PatMatStdBinderName = new UniqueNameExtractor("x") - val PatMatPiName = new UniqueNameExtractor("pi") // FIXME: explain what this is - val PatMatPName = new UniqueNameExtractor("p") // FIXME: explain what this is - val PatMatOName = new UniqueNameExtractor("o") // FIXME: explain what this is - val PatMatCaseName = new UniqueNameExtractor("case") - val PatMatMatchFailName = new UniqueNameExtractor("matchFail") - val PatMatSelectorName = new UniqueNameExtractor("selector") - - object DefaultGetterName extends NumberedNameExtractor(DEFAULTGETTER, "DefaultGetter") { + val InlineAccessorName = new UniqueNameKind("$_inlineAccessor_$") + val TempResultName = new UniqueNameKind("ev$") + val EvidenceParamName = new UniqueNameKind("evidence$") + val DepParamName = new UniqueNameKind("<param>") + val LazyImplicitName = new UniqueNameKind("$_lazy_implicit_$") + val LazyLocalName = new UniqueNameKind("$lzy") + val LazyLocalInitName = new UniqueNameKind("$lzyINIT") + val LazyFieldOffsetName = new UniqueNameKind("$OFFSET") + val LazyBitMapName = new UniqueNameKind(nme.BITMAP_PREFIX.toString) + val NonLocalReturnKeyName = new UniqueNameKind("nonLocalReturnKey") + val WildcardParamName = new UniqueNameKind("_$") + val TailLabelName = new UniqueNameKind("tailLabel") + val ExceptionBinderName = new UniqueNameKind("ex") + val SkolemName = new UniqueNameKind("?") + val LiftedTreeName = new UniqueNameKind("liftedTree") + + val PatMatStdBinderName = new UniqueNameKind("x") + val PatMatPiName = new UniqueNameKind("pi") // FIXME: explain what this is + val PatMatPName = new UniqueNameKind("p") // FIXME: explain what this is + val PatMatOName = new UniqueNameKind("o") // FIXME: explain what this is + val PatMatCaseName = new UniqueNameKind("case") + val PatMatMatchFailName = new UniqueNameKind("matchFail") + val PatMatSelectorName = new UniqueNameKind("selector") + + object DefaultGetterName extends NumberedNameKind(DEFAULTGETTER, "DefaultGetter") { def mkString(underlying: TermName, info: ThisInfo) = { val prefix = if (underlying.isConstructorName) nme.DEFAULT_GETTER_INIT else underlying prefix.toString + nme.DEFAULT_GETTER + (info.num + 1) } } - object VariantName extends NumberedNameExtractor(VARIANT, "Variant") { + object VariantName extends NumberedNameKind(VARIANT, "Variant") { val varianceToPrefix = Map(-1 -> '-', 0 -> '=', 1 -> '+') val prefixToVariance = Map('-' -> -1, '=' -> 0, '+' -> 1) def mkString(underlying: TermName, info: ThisInfo) = { @@ -192,13 +191,13 @@ object NameExtractors { } } - val SuperAccessorName = new PrefixNameExtractor(SUPERACCESSOR, "super$") - val InitializerName = new PrefixNameExtractor(INITIALIZER, "initial$") - val ShadowedName = new PrefixNameExtractor(SHADOWED, "(shadowed)") - val AvoidClashName = new SuffixNameExtractor(AVOIDCLASH, "$_avoid_name_clash_$") - val ModuleClassName = new SuffixNameExtractor(OBJECTCLASS, "$", optInfoString = "ModuleClass") + val SuperAccessorName = new PrefixNameKind(SUPERACCESSOR, "super$") + val InitializerName = new PrefixNameKind(INITIALIZER, "initial$") + val ShadowedName = new PrefixNameKind(SHADOWED, "(shadowed)") + val AvoidClashName = new SuffixNameKind(AVOIDCLASH, "$_avoid_name_clash_$") + val ModuleClassName = new SuffixNameKind(OBJECTCLASS, "$", optInfoString = "ModuleClass") - object SignedName extends NameExtractor(63) { + object SignedName extends NameKind(63) { /** @param parts resultSig followed by paramsSig */ case class SignedInfo(sig: Signature) extends Info { @@ -217,7 +216,7 @@ object NameExtractors { def infoString: String = "Signed" } - def simpleExtractorOfTag : collection.Map[Int, ClassifiedNameExtractor] = simpleExtractors - def qualifiedExtractorOfSeparator: collection.Map[String, QualifiedNameExtractor] = qualifiedExtractors - def uniqueExtractorOfSeparator : collection.Map[String, UniqueNameExtractor] = uniqueExtractors + def simpleNameKindOfTag : collection.Map[Int, ClassifiedNameKind] = simpleNameKinds + def qualifiedNameKindOfSeparator: collection.Map[String, QualifiedNameKind] = qualifiedNameKinds + def uniqueNameKindOfSeparator : collection.Map[String, UniqueNameKind] = uniqueNameKinds }
\ No newline at end of file |