Implemented valhalla value classes.

Author: lidaisy

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -415,6 +415,9 @@ trait BCodeSkelBuilder extends BCodeHelpers {
         )
         cnode.fields.add(jfield)
         emitAnnotations(jfield, f.annotations)
+
+        if(f.denot.info.isValhallaValueClassType)
+          cnode.visitLoadableDescriptors(jfield.desc)
       }
 
     } // end of method addClassFields()

compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala

@@ -304,7 +304,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I, val frontendAcce
       .addFlagIf(sym.isStaticMember, ACC_STATIC)
       .addFlagIf(sym.is(Bridge), ACC_BRIDGE | ACC_SYNTHETIC)
       .addFlagIf(sym.is(Artifact), ACC_SYNTHETIC)
-      .addFlagIf(sym.isClass && !sym.isInterface, ACC_SUPER)
+      .addFlagIf(sym.isClass && !sym.isInterface && !sym.isValhallaValueClass, ACC_SUPER)
       .addFlagIf(sym.isAllOf(JavaEnum), ACC_ENUM)
       .addFlagIf(sym.is(JavaVarargs), ACC_VARARGS)
       .addFlagIf(sym.is(Synchronized), ACC_SYNCHRONIZED)
@@ -319,5 +319,6 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I, val frontendAcce
       .addFlagIf(sym.hasAnnotation(TransientAttr), ACC_TRANSIENT)
       .addFlagIf(sym.hasAnnotation(VolatileAttr), ACC_VOLATILE)
       .addFlagIf(!sym.is(Mutable), ACC_FINAL)
+      .addFlagIf(sym.denot.owner.isValhallaValueClass, ACC_STRICT)
   }
 }

compiler/src/dotty/tools/backend/jvm/BackendUtils.scala

@@ -19,7 +19,7 @@ class BackendUtils(val postProcessor: PostProcessor) {
   import bTypes.*
   import coreBTypes.jliLambdaMetaFactoryAltMetafactoryHandle
 
-  lazy val classfileVersion: Int = BackendUtils.classfileVersionMap(compilerSettings.target.toInt)
+  lazy val classfileVersion: Int = if compilerSettings.experimental then (69 + (65535 << 16)) else BackendUtils.classfileVersionMap(compilerSettings.target.toInt)
 
   lazy val extraProc: Int = {
     import GenBCodeOps.addFlagIf

compiler/src/dotty/tools/backend/jvm/PostProcessorFrontendAccess.scala

@@ -52,6 +52,7 @@ object PostProcessorFrontendAccess {
   sealed trait CompilerSettings {
     def debug: Boolean
     def target: String // javaOutputVersion
+    def experimental: Boolean
 
     def dumpClassesDirectory: Option[String]
     def outputDirectory: AbstractFile
@@ -120,6 +121,8 @@ object PostProcessorFrontendAccess {
             release
           case (None, None) => "8" // least supported version by default
 
+      override val experimental = s.YvalueClasses.value
+
       override val debug: Boolean = ctx.debug
       override val dumpClassesDirectory: Option[String] = s.Xdumpclasses.valueSetByUser
       override val outputDirectory: AbstractFile = s.outputDir.value

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

@@ -703,6 +703,10 @@ object desugar {
     def isEnumCase = mods.isEnumCase
     def isNonEnumCase = !isEnumCase && (isCaseClass || isCaseObject)
     val isValueClass = parents.nonEmpty && isAnyVal(parents.head)
+    val isValhallaVC = isValueClass && mods.annotations.exists{ annot => annot match
+      case Apply(Select(New(Ident(annotName)), _), _) => annotName eq tpnme.valhalla
+      case _ => false
+    }
       // This is not watertight, but `extends AnyVal` will be replaced by `inline` later.
     val caseClassInScala2Library = isCaseClass && Feature.shouldBehaveAsScala2
 
@@ -1028,7 +1032,7 @@ object desugar {
       }
       else if (companionMembers.nonEmpty || companionDerived.nonEmpty || isEnum)
         companionDefs(anyRef, companionMembers)
-      else if isValueClass && !isObject then
+      else if isValueClass && !isObject && !isValhallaVC then
         companionDefs(anyRef, Nil)
       else Nil
 

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

@@ -552,7 +552,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def wrapArrayMethodName(elemtp: Type)(using Context): TermName = {
     val elemCls = elemtp.classSymbol
     if (elemCls.isPrimitiveValueClass) nme.wrapXArray(elemCls.name)
-    else if (elemCls.derivesFrom(defn.ObjectClass) && !elemCls.isNotRuntimeClass) nme.wrapRefArray
+    else if ((elemCls.derivesFrom(defn.ObjectClass) || elemCls.isValhallaValueClass) && !elemCls.isNotRuntimeClass) nme.wrapRefArray
     else nme.genericWrapArray
   }
 

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -474,6 +474,7 @@ private sealed trait YSettings:
   val YccLog: Setting[Boolean] = BooleanSetting(ForkSetting, "Ycc-log", "Used in conjunction with captureChecking language import, print tracing and debug info")
   val YccVerbose: Setting[Boolean] = BooleanSetting(ForkSetting, "Ycc-verbose", "Print root capabilities with more details")
   val YccPrintSetup: Setting[Boolean] = BooleanSetting(ForkSetting, "Ycc-print-setup", "Used in conjunction with captureChecking language import, print trees after cc.Setup phase")
+  val YvalueClasses: Setting[Boolean] = BooleanSetting(ForkSetting, "Yvalue-classes", "value classes")
 
   /** Area-specific debug output */
   val YexplainLowlevel: Setting[Boolean] = BooleanSetting(ForkSetting, "Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -1113,6 +1113,7 @@ class Definitions {
   @tu lazy val PublicInBinaryAnnot: ClassSymbol = requiredClass("scala.annotation.publicInBinary")
   @tu lazy val WitnessNamesAnnot: ClassSymbol = requiredClass("scala.annotation.internal.WitnessNames")
   @tu lazy val StableNullAnnot: ClassSymbol = requiredClass("scala.annotation.stableNull")
+  @tu lazy val ValhallaAnnot: ClassSymbol = requiredClass("scala.annotation.valhalla")
 
   @tu lazy val JavaRepeatableAnnot: ClassSymbol = requiredClass("java.lang.annotation.Repeatable")
 

compiler/src/dotty/tools/dotc/core/ImplicitNullInterop.scala

@@ -115,7 +115,7 @@ object ImplicitNullInterop:
         case tp: TypeRef =>
           // We don't modify value types because they're non-nullable even in Java.
           val isValueOrSpecialClass =
-            tp.symbol.isValueClass
+           (tp.symbol.isValueClass && !tp.symbol.isValhallaValueClass)
             || tp.isRef(defn.NullClass)
             || tp.isRef(defn.NothingClass)
             || tp.isRef(defn.UnitClass)

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -664,6 +664,7 @@ object StdNames {
     val valueOf : N             = "valueOf"
     val fromOrdinal: N          = "fromOrdinal"
     val values: N               = "values"
+    val valhalla: N             = "valhalla"
     val view_ : N               = "view"
     val varargGetter : N        = "varargGetter"
     val wait_ : N               = "wait"