Avoid redundant field in TermName, reducing size 40->32 bytes

[retronym]

Before:

➜  scala git:(topic/name-waste) ✗ java -Djdk.attach.allowAttachSelf=true -cp $(coursier fetch -q -p 'org.openjdk.jol:jol-cli:0.9') org.openjdk.jol.Main internals -cp $(scala-classpath $(scala-ref-version 2.13.x)) 'scala.reflect.internal.Names$TermName'

Failed to find matching constructor, falling back to class-only introspection.

scala.reflect.internal.Names$TermName object internals:
 OFFSET  SIZE                                    TYPE DESCRIPTION                               VALUE
      0    12                                         (object header)                           N/A
     12     4                 scala.reflect.api.Names NameApi.$outer                            N/A
     16     4                                     int Name.index                                N/A
     20     4                                     int Name.len                                  N/A
     24     4                        java.lang.String Name.cachedString                         N/A
     28     4   scala.reflect.internal.Names.TermName TermName.next                             N/A
     32     4                        java.lang.String TermName.cachedString                     N/A
     36     4                                         (loss due to the next object alignment)
Instance size: 40 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

After:

➜  scala git:(topic/name-waste) ✗ java -Djdk.attach.allowAttachSelf=true -cp $(coursier fetch -q -p 'org.openjdk.jol:jol-cli:0.9') org.openjdk.jol.Main internals -cp build/quick/classes/reflect 'scala.reflect.internal.Names$TermName'

Failed to find matching constructor, falling back to class-only introspection.

scala.reflect.internal.Names$TermName object internals:
 OFFSET  SIZE                                    TYPE DESCRIPTION                               VALUE
      0    12                                         (object header)                           N/A
     12     4                 scala.reflect.api.Names NameApi.$outer                            N/A
     16     4                                     int Name.index                                N/A
     20     4                                     int Name.len                                  N/A
     24     4                        java.lang.String Name.cachedString                         N/A
     28     4   scala.reflect.internal.Names.TermName TermName.next                             N/A
Instance size: 32 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

Exposing Name.cachedString as a protected val makes it eligible for
the parameter aliasing layout optimization.

[retronym]

Trivial change, merging without review.

[dwijnand]

Where can I read up more about this? "parameter aliasing layout optimization" doesn't google me anything strictly relevant.

[retronym]

The compiler detects if a constructor parameter field can be elided because there is a field in a superclass that is known to store the same value.

The implementation is spread out between:

scala/src/compiler/scala/tools/nsc/typechecker/Typers.scala

Lines 54 to 59 in 6b4d32c

	// For each class, we collect a mapping from constructor param accessors that are aliases of their superclass
	// param accessors. At the end of the typer phase, when this information is available all the way up the superclass
	// chain, this is used to determine which are true aliases, ones where the field can be elided from this class.
	// And yes, if you were asking, this is yet another binary fragility, as we bake knowledge of the super class into
	// this class.
	private val superConstructorCalls: mutable.AnyRefMap[Symbol, collection.Map[Symbol, Symbol]] = perRunCaches.newAnyRefMap()

scala/src/compiler/scala/tools/nsc/typechecker/Typers.scala

Lines 2192 to 2218 in 6b4d32c

	// associate superclass paramaccessors with their aliases
	val (superConstr, superArgs) = decompose(rhs)
	if (superConstr.symbol.isPrimaryConstructor) {
	val superClazz = superConstr.symbol.owner
	if (!superClazz.isJavaDefined) {
	val superParamAccessors = superClazz.constrParamAccessors
	if (sameLength(superParamAccessors, superArgs)) {
	val accToSuperAcc = mutable.AnyRefMap[Symbol, Symbol]()
	for ((superAcc, superArg@Ident(name)) <- superParamAccessors zip superArgs) {
	if (mexists(vparamss)(_.symbol == superArg.symbol)) {
	val ownAcc = clazz.info decl name suchThat (_.isParamAccessor) match {
	case acc if !acc.isDeferred && acc.hasAccessorFlag => acc.accessed
	case acc => acc
	}
	ownAcc match {
	case acc: TermSymbol if !acc.isVariable && !isByNameParamType(acc.info) =>
	accToSuperAcc(acc) = superAcc
	case _ =>
	}
	}
	}
	if (!accToSuperAcc.isEmpty) {
	superConstructorCalls(clazz) = accToSuperAcc
	}
	}
	}
	}

scala/src/compiler/scala/tools/nsc/typechecker/Typers.scala

Lines 6137 to 6165 in 6b4d32c

	/** Finish computation of param aliases after typechecking is completed */
	final def finishComputeParamAlias(): Unit = {
	val classes = superConstructorCalls.keys.toArray
	// superclasses before subclasses to avoid a data race between `superAcc.alias` and `acc.setAlias` below.
	scala.util.Sorting.quickSort(classes)(Ordering.fromLessThan((a, b) => b.isLess(a)))
	for (sym <- classes) {
	for ((ownAcc, superAcc) <- superConstructorCalls.getOrElse(sym, Nil)) {
	// We have a corresponding parameter in the super class.
	val superClazz = sym.superClass
	val alias = (
	superAcc.initialize.alias // Is the param accessor is an alias for a field further up the class hierarchy?
	orElse (superAcc getterIn superAcc.owner) // otherwise, lookup the accessor for the super
	filter (alias => superClazz.info.nonPrivateMember(alias.name) == alias) // the accessor must be public
	)
	if (alias.exists && !alias.accessed.isVariable && !isRepeatedParamType(alias.accessed.info)) {
	ownAcc match {
	case acc: TermSymbol if !acc.isVariable && !isByNameParamType(acc.info) =>
	debuglog(s"$acc has alias ${alias.fullLocationString}")
	acc setAlias alias
	case _ =>
	}
	}
	}
	}
	superConstructorCalls.clear()
	}
	}

scala/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala

Lines 32 to 37 in 6b4d32c

	* (2) Converts references to parameter fields that have the same name as a corresponding
	* public parameter field in a superclass to a reference to the superclass
	* field (corresponding = super class field is initialized with subclass field).
	* This info is pre-computed by the `alias` field in Typer. `dotc` follows a different
	* route; it computes everything in SuperAccessors and changes the subclass field
	* to a forwarder instead of manipulating references. This is more modular.

scala/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala

Lines 325 to 333 in 6b4d32c

	// Direct calls to aliases of param accessors to the superclass in order to avoid
	// duplicating fields.
	// ... but, only if accessible (scala/bug#6793)
	if (sym.isParamAccessor && sym.alias != NoSymbol && isAccessibleFromSuper(sym.alias)) {
	val result = (localTyper.typedPos(tree.pos) {
	Select(Super(qual, tpnme.EMPTY) setPos qual.pos, sym.alias)
	}).asInstanceOf[Select]
	debuglog(s"alias replacement: $sym --> ${sym.alias} / $tree ==> $result"); //debug
	localTyper.typed(gen.maybeMkAsInstanceOf(transformSuperSelect(result), sym.tpe, sym.alias.tpe, beforeRefChecks = true))

[dwijnand]

Ah right. I thought this was a JIT thing (silly, in retrospect).

Thanks!