From c599f7a693dbc363962d3f17f5eab5222136857f Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Mon, 27 Mar 2017 17:09:42 +0200 Subject: Drop Config.semanticNames option We now handle only semantic names. Also, name extractor tags and TASTY name tags are now aligned. --- compiler/src/dotty/tools/dotc/config/Config.scala | 2 - .../src/dotty/tools/dotc/core/NameExtractors.scala | 23 ++-- compiler/src/dotty/tools/dotc/core/NameOps.scala | 145 ++++++--------------- .../src/dotty/tools/dotc/core/SymDenotations.scala | 4 +- .../dotc/core/classfile/ClassfileParser.scala | 3 +- .../dotty/tools/dotc/core/tasty/NameBuffer.scala | 63 ++++----- .../dotty/tools/dotc/core/tasty/TastyFormat.scala | 15 ++- .../dotty/tools/dotc/core/tasty/TreePickler.scala | 12 +- .../src/dotty/tools/dotc/transform/Mixin.scala | 1 + .../dotty/tools/dotc/transform/ResolveSuper.scala | 11 +- compiler/src/dotty/tools/dotc/typer/Typer.scala | 3 +- 11 files changed, 97 insertions(+), 185 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/config/Config.scala b/compiler/src/dotty/tools/dotc/config/Config.scala index a225b3019..46b1896f1 100644 --- a/compiler/src/dotty/tools/dotc/config/Config.scala +++ b/compiler/src/dotty/tools/dotc/config/Config.scala @@ -10,8 +10,6 @@ object Config { final val checkCacheMembersNamed = false - final val semanticNames = true - /** When updating a constraint bound, check that the constrained parameter * does not appear at the top-level of either of its bounds. */ diff --git a/compiler/src/dotty/tools/dotc/core/NameExtractors.scala b/compiler/src/dotty/tools/dotc/core/NameExtractors.scala index 2ffbf51e1..ec7f00d32 100644 --- a/compiler/src/dotty/tools/dotc/core/NameExtractors.scala +++ b/compiler/src/dotty/tools/dotc/core/NameExtractors.scala @@ -5,6 +5,7 @@ import Names._ import NameOps._ import StdNames._ import util.DotClass +import tasty.TastyFormat._ object NameExtractors { @@ -15,7 +16,7 @@ object NameExtractors { } val simpleTermNameInfo = new NameInfo { - def tag = 0 + def tag = UTF8 def mkString(underlying: TermName): String = unsupported("mkString") } @@ -94,19 +95,19 @@ object NameExtractors { } } - object QualifiedName extends QualifiedNameExtractor(1, ".", "Qualified") - object FlattenedName extends QualifiedNameExtractor(2, "$", "Flattened") - object XpandedName extends QualifiedNameExtractor(3, str.EXPAND_SEPARATOR, "Expanded") - object TraitSetterName extends QualifiedNameExtractor(4, str.TRAIT_SETTER_SEPARATOR, "TraitSetter") + object QualifiedName extends QualifiedNameExtractor(QUALIFIED, ".", "Qualified") + object FlattenedName extends QualifiedNameExtractor(FLATTENED, "$", "Flattened") + object XpandedName extends QualifiedNameExtractor(EXPANDED, str.EXPAND_SEPARATOR, "Expanded") + object TraitSetterName extends QualifiedNameExtractor(TRAITSETTER, str.TRAIT_SETTER_SEPARATOR, "TraitSetter") - object DefaultGetterName extends NumberedNameExtractor(5, "DefaultGetter") { + object DefaultGetterName extends NumberedNameExtractor(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(6, "Variant") { + object VariantName extends NumberedNameExtractor(VARIANT, "Variant") { val varianceToPrefix = Map(-1 -> '-', 0 -> '=', 1 -> '+') val prefixToVariance = Map('-' -> -1, '=' -> 0, '+' -> 1) def mkString(underlying: TermName, info: ThisInfo) = { @@ -114,10 +115,10 @@ object NameExtractors { } } - val SuperAccessorName = new PrefixNameExtractor(7, str.SUPER_PREFIX, "SuperAccessor") - val InitializerName = new PrefixNameExtractor(8, str.INITIALIZER_PREFIX, "Initializer") - val ShadowedName = new PrefixNameExtractor(9, str.SHADOWED_PREFIX, "Shadowed") - val ModuleClassName = new SuffixNameExtractor(10, "$", "ModuleClass") + val SuperAccessorName = new PrefixNameExtractor(SUPERACCESSOR, str.SUPER_PREFIX, "SuperAccessor") + val InitializerName = new PrefixNameExtractor(INITIALIZER, str.INITIALIZER_PREFIX, "Initializer") + val ShadowedName = new PrefixNameExtractor(SHADOWED, str.SHADOWED_PREFIX, "Shadowed") + val ModuleClassName = new SuffixNameExtractor(OBJECTCLASS, "$", "ModuleClass") object SignedName extends NameExtractor(63) { diff --git a/compiler/src/dotty/tools/dotc/core/NameOps.scala b/compiler/src/dotty/tools/dotc/core/NameOps.scala index b51955d9d..c837bc25c 100644 --- a/compiler/src/dotty/tools/dotc/core/NameOps.scala +++ b/compiler/src/dotty/tools/dotc/core/NameOps.scala @@ -49,26 +49,6 @@ object NameOps { } } - class PrefixNameExtractor(pre: TermName, bldr: NameExtractors.PrefixNameExtractor) { - def apply(name: TermName): TermName = - if (Config.semanticNames) bldr(name) else pre ++ name - - def unapply(name: TermName): Option[TermName] = - if (Config.semanticNames) - name match { - case bldr(original) => Some(original) - case _ => None - } - else tryUnmangle(name) - - def tryUnmangle(name: TermName): Option[TermName] = - if (name startsWith pre) Some(name.drop(pre.length).asTermName) - else None - } - - object SuperAccessorName extends PrefixNameExtractor(nme.SUPER_PREFIX, NameExtractors.SuperAccessorName) - object InitializerName extends PrefixNameExtractor(nme.INITIALIZER_PREFIX, NameExtractors.InitializerName) - implicit class NameDecorator[N <: Name](val name: N) extends AnyVal { import nme._ @@ -82,14 +62,8 @@ object NameOps { def isLoopHeaderLabel = (name startsWith WHILE_PREFIX) || (name startsWith DO_WHILE_PREFIX) def isProtectedAccessorName = name startsWith PROTECTED_PREFIX def isReplWrapperName = name.toSimpleName containsSlice INTERPRETER_IMPORT_WRAPPER - def isTraitSetterName = - if (Config.semanticNames) name.is(TraitSetterName) - else name containsSlice TRAIT_SETTER_SEPARATOR def isSetterName = name endsWith SETTER_SUFFIX def isSingletonName = name endsWith SINGLETON_SUFFIX - def isModuleClassName = - if (Config.semanticNames) name.is(ModuleClassName) - else name endsWith MODULE_SUFFIX def isAvoidClashName = name endsWith AVOID_CLASH_SUFFIX def isImportName = name startsWith IMPORT def isFieldName = name endsWith LOCAL_SUFFIX @@ -137,19 +111,13 @@ object NameOps { } /** Convert this module name to corresponding module class name */ - def moduleClassName: TypeName = - if (Config.semanticNames) name.derived(ModuleClassName).toTypeName - else (name ++ tpnme.MODULE_SUFFIX).toTypeName + def moduleClassName: TypeName = name.derived(ModuleClassName).toTypeName /** Convert this module class name to corresponding source module name */ def sourceModuleName: TermName = stripModuleClassSuffix.toTermName /** If name ends in module class suffix, drop it */ - def stripModuleClassSuffix: Name = - if (isModuleClassName) - if (Config.semanticNames) name.exclude(ModuleClassName) - else name dropRight MODULE_SUFFIX.length - else name + def stripModuleClassSuffix: Name = name.exclude(ModuleClassName) /** Append a suffix so that this name does not clash with another name in the same scope */ def avoidClashName: TermName = (name ++ AVOID_CLASH_SUFFIX).toTermName @@ -165,9 +133,7 @@ object NameOps { }.asInstanceOf[N] /** The superaccessor for method with given name */ - def superName: TermName = - if (Config.semanticNames) SuperAccessorName(name.toTermName) - else (nme.SUPER_PREFIX ++ name).toTermName + def superName: TermName = SuperAccessorName(name.toTermName) /** The expanded name of `name` relative to given class `base`. */ @@ -179,34 +145,24 @@ object NameOps { /** The expanded name of `name` relative to `basename` with given `separator` */ def expandedName(prefix: Name, separator: Name = nme.EXPAND_SEPARATOR): N = - likeTyped( - if (Config.semanticNames) { - def qualify(name: SimpleTermName) = - separatorToQualified(separator.toString)(prefix.toTermName, name) - name rewrite { - case name: SimpleTermName => - qualify(name) - case AnyQualifiedName(_, _) => - // Note: an expanded name may itself be expanded. For example, look at javap of scala.App.initCode - qualify(name.toSimpleName) - } + likeTyped { + def qualify(name: SimpleTermName) = + separatorToQualified(separator.toString)(prefix.toTermName, name) + name rewrite { + case name: SimpleTermName => + qualify(name) + case AnyQualifiedName(_, _) => + // Note: an expanded name may itself be expanded. For example, look at javap of scala.App.initCode + qualify(name.toSimpleName) } - else prefix ++ separator ++ name) + } def expandedName(prefix: Name): N = expandedName(prefix, nme.EXPAND_SEPARATOR) - /** Revert the expanded name. - * Note: This currently gives incorrect results - * if the normal name contains `nme.EXPAND_SEPARATOR`, i.e. two consecutive '$' - * signs. This can happen for instance if a super accessor is paired with - * an encoded name, e.g. super$$plus$eq. See #765. - */ - def unexpandedName: N = - if (Config.semanticNames) - likeTyped { - name.rewrite { case XpandedName(_, unexp) => unexp } - } - else unexpandedNameOfMangled + /** Revert the expanded name. */ + def unexpandedName: N = likeTyped { + name.rewrite { case XpandedName(_, unexp) => unexp } + } def unexpandedNameOfMangled: N = likeTyped { var idx = name.lastIndexOfSlice(nme.EXPAND_SEPARATOR) @@ -219,13 +175,8 @@ object NameOps { if (idx < 0) name else (name drop (idx + nme.EXPAND_SEPARATOR.length)) } - def expandedPrefix: N = - if (Config.semanticNames) - likeTyped { - name.rewrite { case XpandedName(prefix, _) => prefix } - } - else expandedPrefixOfMangled - + def expandedPrefix: N = likeTyped { name.exclude(XpandedName) } + def expandedPrefixOfMangled: N = { val idx = name.lastIndexOfSlice(nme.EXPAND_SEPARATOR) assert(idx >= 0) @@ -233,11 +184,11 @@ object NameOps { } def unmangleExpandedName: N = - if (Config.semanticNames && name.isSimple) { + if (name.isSimple) { val unmangled = unexpandedNameOfMangled if (name eq unmangled) name else likeTyped( - XpandedName(expandedPrefixOfMangled.toTermName, unmangled.asSimpleName)) + XpandedName(expandedPrefixOfMangled.toTermName, unmangled.asSimpleName)) } else name @@ -253,7 +204,7 @@ object NameOps { def freshened(implicit ctx: Context): N = likeTyped( - if (name.isModuleClassName) name.stripModuleClassSuffix.freshened.moduleClassName + if (name.is(ModuleClassName)) name.stripModuleClassSuffix.freshened.moduleClassName else likeTyped(ctx.freshName(name ++ NameTransformer.NAME_JOIN_STRING))) /* /** Name with variance prefix: `+` for covariant, `-` for contravariant */ @@ -283,7 +234,7 @@ object NameOps { */ def unmangleClassName: N = - if (Config.semanticNames && name.isSimple && name.isTypeName) + if (name.isSimple && name.isTypeName) if (name.endsWith(MODULE_SUFFIX) && !tpnme.falseModuleClassNames.contains(name.asTypeName)) likeTyped(name.dropRight(MODULE_SUFFIX.length).moduleClassName) else name @@ -439,18 +390,11 @@ object NameOps { def fieldName: TermName = if (name.isSetterName) { - if (name.isTraitSetterName) { - if (Config.semanticNames) { - val TraitSetterName(_, original) = name - original.fieldName - } - else { - // has form <$-separated-trait-name>$_setter_$ `name`_$eq - val start = name.indexOfSlice(TRAIT_SETTER_SEPARATOR) + TRAIT_SETTER_SEPARATOR.length - val end = name.indexOfSlice(SETTER_SUFFIX) - (name.slice(start, end) ++ LOCAL_SUFFIX).asTermName - } - } else getterName.fieldName + if (name.is(TraitSetterName)) { + val TraitSetterName(_, original) = name + original.fieldName + } + else getterName.fieldName } else name.mapLast(n => (n ++ LOCAL_SUFFIX).asSimpleName) @@ -469,19 +413,13 @@ object NameOps { * @note Default getter name suffixes start at 1, so `pos` has to be adjusted by +1 */ def defaultGetterName(pos: Int): TermName = - if (Config.semanticNames) DefaultGetterName(name, pos) - else { - val prefix = if (name.isConstructorName) DEFAULT_GETTER_INIT else name - prefix ++ DEFAULT_GETTER ++ (pos + 1).toString - } + DefaultGetterName(name, pos) /** Nominally, name from name$default$N, CONSTRUCTOR for */ def defaultGetterToMethod: TermName = - if (Config.semanticNames) - name rewrite { - case DefaultGetterName(methName, _) => methName - } - else defaultGetterToMethodOfMangled + name rewrite { + case DefaultGetterName(methName, _) => methName + } def defaultGetterToMethodOfMangled: TermName = { val p = name.indexOfSlice(DEFAULT_GETTER) @@ -494,11 +432,9 @@ object NameOps { /** If this is a default getter, its index (starting from 0), else -1 */ def defaultGetterIndex: Int = - if (Config.semanticNames) - name collect { - case DefaultGetterName(_, num) => num - } getOrElse -1 - else defaultGetterIndexOfMangled + name collect { + case DefaultGetterName(_, num) => num + } getOrElse -1 def defaultGetterIndexOfMangled: Int = { var i = name.length @@ -590,7 +526,7 @@ object NameOps { def inlineAccessorName = nme.INLINE_ACCESSOR_PREFIX ++ name ++ "$" def unmangleMethodName: TermName = - if (Config.semanticNames && name.isSimple) { + if (name.isSimple) { val idx = name.defaultGetterIndexOfMangled if (idx >= 0) name.defaultGetterToMethodOfMangled.defaultGetterName(idx) else name @@ -598,13 +534,8 @@ object NameOps { else name def unmangleSuperName: TermName = - if (Config.semanticNames && name.isSimple) - SuperAccessorName.tryUnmangle(name.lastPart) match { - case scala.Some(original) => - SuperAccessorName(name.mapLast(_ => original.asSimpleName)) - case None => - name - } + if (name.isSimple && name.startsWith(str.SUPER_PREFIX)) + SuperAccessorName(name.drop(str.SUPER_PREFIX.length).asTermName) else name } diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala index fa39c9782..4e40d1e05 100644 --- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala +++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala @@ -406,7 +406,7 @@ object SymDenotations { } var prefix = encl.fullNameSeparated(separator) val fn = - if (Config.semanticNames && separatorToQualified.contains(sep)) { + if (separatorToQualified.contains(sep)) { if (sep == "$") // duplicate scalac's behavior: don't write a double '$$' for module class members. prefix = prefix.exclude(ModuleClassName) @@ -1233,7 +1233,7 @@ object SymDenotations { // ----- denotation fields and accessors ------------------------------ if (initFlags is (Module, butNot = Package)) - assert(name.isModuleClassName, s"module naming inconsistency: ${name.debugString}") + assert(name.is(ModuleClassName), s"module naming inconsistency: ${name.debugString}") /** The symbol asserted to have type ClassSymbol */ def classSymbol: ClassSymbol = symbol.asInstanceOf[ClassSymbol] diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala index 131c9cf9b..c5194fb93 100644 --- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala +++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala @@ -5,6 +5,7 @@ package classfile import Contexts._, Symbols._, Types._, Names._, StdNames._, NameOps._, Scopes._, Decorators._ import SymDenotations._, unpickleScala2.Scala2Unpickler._, Constants._, Annotations._, util.Positions._ +import NameExtractors.ModuleClassName import ast.tpd._ import java.io.{ File, IOException } import java.lang.Integer.toHexString @@ -950,7 +951,7 @@ class ClassfileParser( val start = starts(index) if (in.buf(start).toInt != CONSTANT_CLASS) errorBadTag(start) val name = getExternalName(in.getChar(start + 1)) - if (name.isModuleClassName && (name ne nme.nothingRuntimeClass) && (name ne nme.nullRuntimeClass)) + if (name.is(ModuleClassName) && (name ne nme.nothingRuntimeClass) && (name ne nme.nullRuntimeClass)) // Null$ and Nothing$ ARE classes c = ctx.requiredModule(name.sourceModuleName) else c = classNameToSymbol(name) diff --git a/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala b/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala index 0101ff25d..74c4265f2 100644 --- a/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala +++ b/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala @@ -49,43 +49,36 @@ class NameBuffer extends TastyBuffer(10000) { def writeNameRef(ref: NameRef): Unit = writeNat(ref.index) def writeNameRef(name: Name): Unit = writeNameRef(nameRefs(name.toTermName)) - def pickleNameContents(name: Name): Unit = name.toTermName match { - case name: SimpleTermName => - val bytes = - if (name.length == 0) new Array[Byte](0) - else Codec.toUTF8(chrs, name.start, name.length) - writeByte(UTF8) - writeNat(bytes.length) - writeBytes(bytes, bytes.length) - case QualifiedName(qualified, selector) => - writeByte(QUALIFIED) - withLength { writeNameRef(qualified); writeNameRef(selector) } - case FlattenedName(qualified, selector) => - writeByte(FLATTENED) - withLength { writeNameRef(qualified); writeNameRef(selector) } - case XpandedName(prefix, original) => - writeByte(EXPANDED) - withLength { writeNameRef(prefix); writeNameRef(original) } - case SignedName(original, Signature(params, result)) => - writeByte(SIGNED) - withLength( + def pickleNameContents(name: Name): Unit = { + writeByte(name.toTermName.info.tag) + name.toTermName match { + case name: SimpleTermName => + val bytes = + if (name.length == 0) new Array[Byte](0) + else Codec.toUTF8(chrs, name.start, name.length) + writeNat(bytes.length) + writeBytes(bytes, bytes.length) + case QualifiedName(qualified, selector) => + withLength { writeNameRef(qualified); writeNameRef(selector) } + case FlattenedName(qualified, selector) => + withLength { writeNameRef(qualified); writeNameRef(selector) } + case XpandedName(prefix, original) => + withLength { writeNameRef(prefix); writeNameRef(original) } + case SignedName(original, Signature(params, result)) => + withLength( { writeNameRef(original); writeNameRef(result); params.foreach(writeNameRef) }, if ((params.length + 2) * maxIndexWidth <= maxNumInByte) 1 else 2) - case ModuleClassName(module) => - writeByte(OBJECTCLASS) - withLength { writeNameRef(module) } - case SuperAccessorName(accessed) => - writeByte(SUPERACCESSOR) - withLength { writeNameRef(accessed) } - case DefaultGetterName(method, paramNumber) => - writeByte(DEFAULTGETTER) - withLength { writeNameRef(method); writeNat(paramNumber) } - case ShadowedName(original) => - writeByte(SHADOWED) - withLength { writeNameRef(original) } - case VariantName(original, sign) => - writeByte(VARIANT) - withLength { writeNameRef(original); writeNat(sign + 1) } + case ModuleClassName(module) => + withLength { writeNameRef(module) } + case SuperAccessorName(accessed) => + withLength { writeNameRef(accessed) } + case DefaultGetterName(method, paramNumber) => + withLength { writeNameRef(method); writeNat(paramNumber) } + case ShadowedName(original) => + withLength { writeNameRef(original) } + case VariantName(original, sign) => + withLength { writeNameRef(original); writeNat(sign + 1) } + } } override def assemble(): Unit = { diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala index d4f6782fb..de70c04f3 100644 --- a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala +++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala @@ -224,12 +224,15 @@ object TastyFormat { final val QUALIFIED = 2 final val FLATTENED = 3 final val EXPANDED = 4 - final val SIGNED = 5 - final val OBJECTCLASS = 6 - final val SUPERACCESSOR = 7 - final val DEFAULTGETTER = 8 - final val SHADOWED = 9 - final val VARIANT = 10 + final val TRAITSETTER = 5 + final val DEFAULTGETTER = 10 + final val VARIANT = 11 + final val SUPERACCESSOR = 20 + final val INITIALIZER = 21 + final val SHADOWED = 22 + final val OBJECTCLASS = 29 + + final val SIGNED = 63 // AST tags diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala index d1f2a3766..2da638291 100644 --- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala +++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala @@ -56,16 +56,6 @@ class TreePickler(pickler: TastyPickler) { private def pickleNameAndSig(name: Name, sig: Signature) = pickleName(SignedName(name.toTermName, sig)) - private def pickleName(sym: Symbol)(implicit ctx: Context): Unit = { - val nameRef = - if (Config.semanticNames) { - if (sym is Flags.ExpandedName) assert(sym.name.is(XpandedName)) - nameIndex(sym.name) - } - else ??? - writeNat(nameRef.index) - } - private def pickleSymRef(sym: Symbol)(implicit ctx: Context) = symRefs.get(sym) match { case Some(label) => if (label != NoAddr) writeRef(label) else pickleForwardSymRef(sym) @@ -303,7 +293,7 @@ class TreePickler(pickler: TastyPickler) { registerDef(sym) writeByte(tag) withLength { - pickleName(sym) + pickleName(sym.name) pickleParams tpt match { case templ: Template => pickleTree(tpt) diff --git a/compiler/src/dotty/tools/dotc/transform/Mixin.scala b/compiler/src/dotty/tools/dotc/transform/Mixin.scala index fd4370d3e..e9ec4890c 100644 --- a/compiler/src/dotty/tools/dotc/transform/Mixin.scala +++ b/compiler/src/dotty/tools/dotc/transform/Mixin.scala @@ -13,6 +13,7 @@ import Decorators._ import DenotTransformers._ import StdNames._ import NameOps._ +import NameExtractors._ import Phases._ import ast.untpd import ast.Trees._ diff --git a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala index b6c28f570..9e22a6b46 100644 --- a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala +++ b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala @@ -13,6 +13,7 @@ import Decorators._ import DenotTransformers._ import StdNames._ import NameOps._ +import NameExtractors._ import ast.Trees._ import util.Positions._ import Names._ @@ -95,15 +96,7 @@ object ResolveSuper { def rebindSuper(base: Symbol, acc: Symbol)(implicit ctx: Context): Symbol = { var bcs = base.info.baseClasses.dropWhile(acc.owner != _).tail var sym: Symbol = NoSymbol - val unexpandedAccName = - if (acc.is(ExpandedName)) - if (Config.semanticNames) acc.name.unexpandedName - else // Cannot use unexpandedName because of #765. t2183.scala would fail if we did. - acc.name - .drop(acc.name.indexOfSlice(nme.EXPAND_SEPARATOR ++ nme.SUPER_PREFIX)) - .drop(nme.EXPAND_SEPARATOR.length) - else acc.name - val SuperAccessorName(memberName) = unexpandedAccName: Name // dotty deviation: ": Name" needed otherwise pattern type is neither a subtype nor a supertype of selector type + val SuperAccessorName(memberName) = acc.name.unexpandedName // dotty deviation: ": Name" needed otherwise pattern type is neither a subtype nor a supertype of selector type ctx.debuglog(i"starting rebindsuper from $base of ${acc.showLocated}: ${acc.info} in $bcs, name = $memberName") while (bcs.nonEmpty && sym == NoSymbol) { val other = bcs.head.info.nonPrivateDecl(memberName) diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala index a7b8200b5..8674c8fbd 100644 --- a/compiler/src/dotty/tools/dotc/typer/Typer.scala +++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala @@ -18,6 +18,7 @@ import SymDenotations._ import Annotations._ import Names._ import NameOps._ +import NameExtractors._ import Flags._ import Decorators._ import ErrorReporting._ @@ -572,7 +573,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit def canAssign(sym: Symbol) = // allow assignments from the primary constructor to class fields sym.is(Mutable, butNot = Accessor) || ctx.owner.isPrimaryConstructor && !sym.is(Method) && sym.owner == ctx.owner.owner || - ctx.owner.name.isTraitSetterName || ctx.owner.isStaticConstructor + ctx.owner.name.is(TraitSetterName) || ctx.owner.isStaticConstructor lhsCore.tpe match { case ref: TermRef if canAssign(ref.symbol) => assignType(cpy.Assign(tree)(lhs1, typed(tree.rhs, ref.info))) -- cgit v1.2.3