Scala 2.11编译器为何重命名私有方法？求解释及资源

Hey there! It sounds like you've run into one of Scala's more behind-the-scenes behaviors: method name mangling. Let me break down why this happens, especially for Scala 2.11.8, and point you to ways to dig deeper.

Why Do Method Names Change? #

Scala is a far more expressive language than Java, but it has to run on the JVM—which has strict, inflexible rules about method signatures. To support Scala features that don't map directly to JVM limitations, the compiler modifies (mangles) method names behind the scenes. Common triggers include:

• Overloaded methods with type erasure conflicts: If two methods have signatures that look identical after JVM type erasure, the compiler adds suffixes like $1, $2 to tell them apart.
• Default parameters: Methods with default arguments get auto-generated bridge methods named with a $default$ prefix (e.g., foo$default$1 for the first default parameter).
• Trait implementations: When a class implements multiple traits with overlapping method signatures, the compiler may generate mangled names to resolve conflicts.
• Special identifiers or reserved words: If your method uses a name that's a Java reserved word (like var or val), Scala will mangle it (e.g., var becomes var$).

Scala 2.11.8-Specific Details #

Scala 2.11 has subtle differences in naming logic compared to later versions (2.12+). For class B specifically, here are some scenarios to check:

• If B extends a trait with abstract methods, the compiler might generate mangled names for concrete implementations to handle trait composition.
• If B has overloaded methods that would clash after type erasure, 2.11's mangling rules might produce different suffixes than newer versions.
• Internal classes or nested methods in B could have names that include outer class identifiers (e.g., B$innerMethod).

How to Investigate Further #

1. Use javap to inspect the class file: Run javap -p B.class in your terminal—this will print all methods (including private ones) with their mangled names. Comparing the original Scala code to the javap output will help you map which Scala method corresponds to which mangled JVM method.
2. Check the Scala compiler's naming logic: The core of name mangling lives in the scala.tools.naming.NameTransformer class. For Scala 2.11.8, you can look at the source code of this class to see exactly how names are transformed (search for methods like encode or mangle).
3. Review Scala's language specification: The official Scala spec has a section on "Interoperation with Java" that outlines the basics of name mangling, even if it doesn't dive into every version-specific detail.

Where to Find More Resources #

While the official Scala 2.11 docs might not spell out every mangling case, the Scala community has covered this extensively:

• Old Scala user mailing list archives often have deep dives into version-specific compiler behavior.
• Stack Overflow has dozens of questions about Scala method name mangling—search for terms like "Scala 2.11 method name changed" or "Scala javap mangled names" to find relevant discussions.

内容的提问来源于stack exchange，提问作者Vince.Bdn