use scala primitives (e.g. Integer -> Int)

motivation: minify diff for flatgraph migration

Author: mpollmeier

codegen/src/main/scala/overflowdb/codegen/CodeGen.scala

@@ -343,7 +343,7 @@ class CodeGen(schema: Schema) {
         properties.map { property =>
           val name = property.name
           val nameCamelCase = camelCase(name)
-          val tpe = getCompleteType(property)
+          val tpe = getCompleteType(property, nullable = false)
 
           property.cardinality match {
             case Cardinality.One(_) =>
@@ -479,7 +479,7 @@ class CodeGen(schema: Schema) {
     def generateNodeBaseTypeSource(nodeBaseType: NodeBaseType): String = {
       val className = nodeBaseType.className
       val properties = nodeBaseType.properties
-      val propertyAccessors = Helpers.propertyAccessors(properties)
+      val propertyAccessors = Helpers.propertyAccessors(properties, nullable = false)
 
       val mixinsForBaseTypes = nodeBaseType.extendz.map { baseTrait =>
         s"with ${baseTrait.className}"
@@ -601,7 +601,7 @@ class CodeGen(schema: Schema) {
 
       val newNodePropertySetters = nodeBaseType.properties.map { property =>
         val camelCaseName = camelCase(property.name)
-        val tpe = getCompleteType(property)
+        val tpe = getCompleteType(property, nullable = false)
         s"def ${camelCaseName}_=(value: $tpe): Unit"
       }.mkString(lineSeparator)
 
@@ -856,7 +856,7 @@ class CodeGen(schema: Schema) {
               case Cardinality.One(_) =>
                 s"""this._$memberName = $newNodeCasted.$memberName""".stripMargin
               case Cardinality.ZeroOrOne =>
-                s"""this._$memberName = $newNodeCasted.$memberName.orNull""".stripMargin
+                s"""this._$memberName = $newNodeCasted.$memberName match { case None => null; case Some(value) => value }""".stripMargin
               case Cardinality.List =>
                 s"""this._$memberName = if ($newNodeCasted.$memberName != null) $newNodeCasted.$memberName else collection.immutable.ArraySeq.empty""".stripMargin
             }
@@ -993,7 +993,7 @@ class CodeGen(schema: Schema) {
         s"""trait ${className}Base extends AbstractNode $mixinsForExtendedNodesBase $mixinsForMarkerTraits {
            |  def asStored : StoredNode = this.asInstanceOf[StoredNode]
            |
-           |  ${Helpers.propertyAccessors(properties)}
+           |  ${Helpers.propertyAccessors(properties, nullable = false)}
            |
            |  $abstractContainedNodeAccessors
            |}
@@ -1021,7 +1021,7 @@ class CodeGen(schema: Schema) {
       val nodeRefImpl = {
         val propertyDelegators = properties.map { key =>
           val name = camelCase(key.name)
-          s"""override def $name: ${getCompleteType(key)} = get().$name"""
+          s"""override def $name: ${getCompleteType(key, nullable = false)} = get().$name"""
         }.mkString(lineSeparator)
 
         val propertyDefaultValues = propertyDefaultValueImpl(s"$className.PropertyDefaults", properties)
@@ -1095,14 +1095,14 @@ class CodeGen(schema: Schema) {
 
       val updateSpecificPropertyImpl: String = {
         import Property.Cardinality
-        def caseEntry(name: String, accessorName: String, cardinality: Cardinality, baseType: String) = {
+        def caseEntry(name: String, accessorName: String, cardinality: Cardinality, baseType: String, baseTypeNullable: String) = {
           val setter = cardinality match {
             case Cardinality.One(_) | Cardinality.ZeroOrOne =>
               s"value.asInstanceOf[$baseType]"
             case Cardinality.List =>
               s"""value match {
                  |  case null => collection.immutable.ArraySeq.empty
-                 |  case singleValue: $baseType => collection.immutable.ArraySeq(singleValue)
+                 |  case singleValue: $baseTypeNullable => collection.immutable.ArraySeq(singleValue)
                  |  case coll: IterableOnce[Any] if coll.iterator.isEmpty => collection.immutable.ArraySeq.empty
                  |  case arr: Array[_] if arr.isEmpty => collection.immutable.ArraySeq.empty
                  |  case arr: Array[_] => collection.immutable.ArraySeq.unsafeWrapArray(arr).asInstanceOf[IndexedSeq[$baseType]]
@@ -1120,10 +1120,10 @@ class CodeGen(schema: Schema) {
           s"""|case "$name" => this._$accessorName = $setter"""
         }
 
-        val forKeys = properties.map(p => caseEntry(p.name, camelCase(p.name), p.cardinality, typeFor(p))).mkString(lineSeparator)
+        val forKeys = properties.map(p => caseEntry(p.name, camelCase(p.name), p.cardinality, typeFor(p), typeFor(p, nullable = true))).mkString(lineSeparator)
 
         val forContainedNodes = nodeType.containedNodes.map(containedNode =>
-          caseEntry(containedNode.localName, containedNode.localName, containedNode.cardinality, containedNode.classNameForStoredNode)
+          caseEntry(containedNode.localName, containedNode.localName, containedNode.cardinality, containedNode.classNameForStoredNode, containedNode.classNameForStoredNode)
         ).mkString(lineSeparator)
 
         s"""override protected def updateSpecificProperty(key:String, value: Object): Unit = {
@@ -1161,10 +1161,11 @@ class CodeGen(schema: Schema) {
           val fieldName = s"_$publicName"
           val (publicType, tpeForField, fieldAccessor, defaultValue) = {
             val valueType = typeFor(property)
+            val valueTypeNullable = typeFor(property, nullable = true)
             property.cardinality match {
               case Cardinality.One(_)  =>
-                (valueType, valueType, fieldName, s"$className.PropertyDefaults.${property.className}")
-              case Cardinality.ZeroOrOne => (s"Option[$valueType]", valueType, s"Option($fieldName)", "null")
+                (valueType, valueTypeNullable, fieldName, s"$className.PropertyDefaults.${property.className}")
+              case Cardinality.ZeroOrOne => (s"Option[$valueType]", valueTypeNullable, s"Option($fieldName).asInstanceOf[Option[$valueType]]", "null")
               case Cardinality.List   => (s"IndexedSeq[$valueType]", s"IndexedSeq[$valueType]", fieldName, "collection.immutable.ArraySeq.empty")
             }
           }
@@ -1732,27 +1733,29 @@ class CodeGen(schema: Schema) {
 
     def generateNewNodeSource(nodeType: NodeType, properties: Seq[Property[?]], inEdges: Map[String, Set[String]], outEdges: Map[String, Set[String]]) = {
       import Property.Cardinality
-      case class FieldDescription(name: String, valueType: String, fullType: String, cardinality: Cardinality)
+      case class FieldDescription(name: String, valueType: String, valueTypeNullable: String, fullType: String, cardinality: Cardinality)
       val fieldDescriptions = mutable.ArrayBuffer.empty[FieldDescription]
 
       for (property <- properties) {
         fieldDescriptions += FieldDescription(
           camelCase(property.name),
           typeFor(property),
-          getCompleteType(property),
+          typeFor(property, nullable = true),
+          getCompleteType(property, nullable = false),
           property.cardinality)
       }
 
       for (containedNode <- nodeType.containedNodes) {
         fieldDescriptions += FieldDescription(
           containedNode.localName,
           typeFor(containedNode),
+          typeFor(containedNode),
           getCompleteType(containedNode),
           containedNode.cardinality)
       }
 
       val memberVariables = fieldDescriptions.reverse.map {
-        case FieldDescription(name, _, fullType, cardinality) =>
+        case FieldDescription(name, _, _, fullType, cardinality) =>
           val defaultValue = cardinality match {
             case Cardinality.One(default) => defaultValueImpl(default)
             case Cardinality.ZeroOrOne => "None"
@@ -1812,22 +1815,22 @@ class CodeGen(schema: Schema) {
       val mixins = nodeType.extendz.map{baseType => s"with ${baseType.className}New"}.mkString(" ")
 
       val propertySettersImpl = fieldDescriptions.map {
-        case FieldDescription(name, valueType , _, cardinality) =>
+        case FieldDescription(name, valueType, valueTypeNullable, _, cardinality) =>
           cardinality match {
             case Cardinality.One(_) =>
-              s"""def $name(value: $valueType): this.type = {
+              s"""def $name(value: $valueTypeNullable): this.type = {
                  |  this.$name = value
                  |  this
                  |}
                  |""".stripMargin
 
             case Cardinality.ZeroOrOne =>
-              s"""def $name(value: $valueType): this.type = {
+              s"""def $name(value: $valueTypeNullable): this.type = {
                  |  this.$name = Option(value)
                  |  this
                  |}
                  |
-                 |def $name(value: Option[$valueType]): this.type = $name(value.orNull)
+                 |def $name(value: Option[$valueType]): this.type = $name(value match { case None => null; case Some(value) => value: $valueTypeNullable })
                  |""".stripMargin
 
             case Cardinality.List =>

codegen/src/main/scala/overflowdb/codegen/Helpers.scala

@@ -32,18 +32,17 @@ object Helpers {
     case nonEmptyString => Some(nonEmptyString)
   }
 
-  def typeFor[A](property: Property[A]): String = {
-    val isMandatory = property.isMandatory
+  def typeFor[A](property: Property[A], nullable: Boolean = false): String = {
     property.valueType match {
-      case ValueType.Boolean => if (isMandatory) "Boolean" else "java.lang.Boolean"
+      case ValueType.Boolean => if (nullable) "java.lang.Boolean" else "Boolean"
       case ValueType.String => "String"
-      case ValueType.Byte => if (isMandatory) "Byte" else "java.lang.Byte"
-      case ValueType.Short => if (isMandatory) "Short" else "java.lang.Short"
-      case ValueType.Int => if (isMandatory) "scala.Int" else "Integer"
-      case ValueType.Long => if (isMandatory) "Long" else "java.lang.Long"
-      case ValueType.Float => if (isMandatory) "Float" else "java.lang.Float"
-      case ValueType.Double => if (isMandatory) "Double" else "java.lang.Double"
-      case ValueType.Char => if (isMandatory) "scala.Char" else "Character"
+      case ValueType.Byte => if (nullable) "java.lang.Byte" else "Byte"
+      case ValueType.Short => if (nullable) "java.lang.Short" else "Short"
+      case ValueType.Int => if (nullable) "Integer" else "scala.Int"
+      case ValueType.Long => if (nullable) "java.lang.Long" else "Long"
+      case ValueType.Float => if (nullable) "java.lang.Float" else "Float"
+      case ValueType.Double => if (nullable) "java.lang.Double" else "Double"
+      case ValueType.Char => if (nullable) "Character" else "scala.Char"
       case ValueType.List => "Seq[_]"
       case ValueType.NodeRef => "overflowdb.NodeRef[_]"
       case ValueType.Unknown => "java.lang.Object"
@@ -120,8 +119,8 @@ object Helpers {
     }
   }
 
-  def getCompleteType[A](property: Property[?]): String =
-    getCompleteType(property.cardinality, typeFor(property))
+  def getCompleteType[A](property: Property[?], nullable: Boolean = true): String =
+    getCompleteType(property.cardinality, typeFor(property, nullable))
 
   def typeFor(containedNode: ContainedNode): String = {
     containedNode.nodeType match {
@@ -200,10 +199,10 @@ object Helpers {
     }.mkString(s"$lineSeparator|    ")
   }
 
-  def propertyAccessors(properties: Seq[Property[?]]): String = {
+  def propertyAccessors(properties: Seq[Property[?]], nullable: Boolean = true): String = {
     properties.map { property =>
       val camelCaseName = camelCase(property.name)
-      val tpe = getCompleteType(property)
+      val tpe = getCompleteType(property, nullable = nullable)
       s"def $camelCaseName: $tpe"
     }.mkString(lineSeparator)
   }

integration-tests/tests/src/test/scala/Schema01Test.scala

@@ -6,6 +6,7 @@ import testschema01.nodes._
 import testschema01.edges._
 import testschema01.traversal._
 import scala.jdk.CollectionConverters.IteratorHasAsScala
+
 class Schema01Test extends AnyWordSpec with Matchers {
   import testschema01.traversal._
   "constants" in {
@@ -58,7 +59,7 @@ class Schema01Test extends AnyWordSpec with Matchers {
       val edge2Specific = edge2.asInstanceOf[Edge2]
       val name: String = node1aSpecific.name
       name shouldBe "node 1a"
-      val o1: Option[Integer] = node1aSpecific.order
+      val o1: Option[Int] = node1aSpecific.order
       node1aSpecific.order shouldBe Some(2)
       node1bSpecific.order shouldBe None
       val o2: Seq[String] = node2aSpecific.options
@@ -97,7 +98,7 @@ class Schema01Test extends AnyWordSpec with Matchers {
         .name("name1")
         .node3(node3)
         .options(Seq("one", "two", "three"))
-        .placements(Seq(1,2,3): Seq[Integer])
+        .placements(Seq(1,2,3))
 
       val builder = new BatchedUpdate.DiffGraphBuilder
       builder.addNode(newNode2)

integration-tests/tests/src/test/scala/Schema02Test.scala

@@ -55,7 +55,7 @@ class Schema02Test extends AnyWordSpec with Matchers {
       copy.order(3)
       copy.order shouldBe Some(3)
 
-      copy.order(Some(4: Integer))
+      copy.order(Some(4))
       copy.order shouldBe Some(4)
 
       original.name shouldBe "A"

integration-tests/tests/src/test/scala/Schema04Test.scala

@@ -175,7 +175,7 @@ class Schema04Test extends AnyWordSpec with Matchers {
     val node1 = NewNode1()
       .bool(true)
       .str("foo")
-      .intList(Seq(1,2,3): Seq[Integer])
+      .intList(Seq(1,2,3))
 
     val node2 = NewNode1().node1Inner(node1)