Generate constructor helper

Author: kornilova203

bindgen/ir/IR.cpp

@@ -181,6 +181,13 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
         s << "\n  object implicits {\n" << ir.getHelperMethods() << "  }\n";
     }
 
+    for (const auto &str : ir.structs) {
+        visitedTypes.clear();
+        if (ir.shouldOutput(str, visitedTypes) && str->hasHelperMethods()) {
+            s << "\n" << str->getConstructorHelper(ir.locationManager);
+        }
+    }
+
     s << "}\n\n";
 
     return s;

bindgen/ir/Struct.cpp

@@ -44,11 +44,6 @@ Struct::generateHelperClass(const LocationManager &locationManager) const {
     }
     s << "    }\n";
 
-    /* makes struct instantiation easier */
-    s << "    def "
-      << type + "()(implicit z: native.Zone): native.Ptr[" + type + "]"
-      << " = native.alloc[" + type + "]\n";
-
     return s.str();
 }
 
@@ -132,7 +127,8 @@ std::string Struct::generateSetterForStructRepresentation(
     unsigned fieldIndex, const LocationManager &locationManager) const {
     std::shared_ptr<Field> field = fields[fieldIndex];
     std::string setter = handleReservedWords(field->getName(), "_=");
-    std::string parameterType = field->getType()->str(locationManager);
+    std::string parameterType =
+        wrapArrayOrRecordInPointer(field->getType())->str(locationManager);
     std::string value = "value";
     std::vector<std::shared_ptr<const Struct>> structTypesThatShouldBeReplaced =
         shouldFieldBreakCycle(field);
@@ -141,9 +137,7 @@ std::string Struct::generateSetterForStructRepresentation(
         std::shared_ptr<const Type> typeReplacement = getTypeReplacement(
             field->getType(), structTypesThatShouldBeReplaced);
         value = value + ".cast[" + typeReplacement->str(locationManager) + "]";
-    } else if (isAliasForType<ArrayType>(field->getType().get()) ||
-               isAliasForType<Struct>(field->getType().get())) {
-        parameterType = "native.Ptr[" + parameterType + "]";
+    } else if (isArrayOrRecord(field->getType())) {
         value = "!" + value;
     }
     std::stringstream s;
@@ -156,17 +150,16 @@ std::string Struct::generateGetterForStructRepresentation(
     unsigned fieldIndex, const LocationManager &locationManager) const {
     std::shared_ptr<Field> field = fields[fieldIndex];
     std::string getter = handleReservedWords(field->getName());
-    std::string returnType = field->getType()->str(locationManager);
+    std::string returnType =
+        wrapArrayOrRecordInPointer(field->getType())->str(locationManager);
     std::string methodBody = "p._" + std::to_string(fieldIndex + 1);
-    if (isAliasForType<ArrayType>(field->getType().get()) ||
-        isAliasForType<Struct>(field->getType().get())) {
-        returnType = "native.Ptr[" + returnType + "]";
-    } else if (!shouldFieldBreakCycle(field).empty()) {
-        /* field type is changed to avoid cyclic types in generated code */
-        methodBody = "(!" + methodBody + ").cast[" +
-                     field->getType()->str(locationManager) + "]";
-    } else {
+    if (!isArrayOrRecord(field->getType())) {
         methodBody = "!" + methodBody;
+        if (!shouldFieldBreakCycle(field).empty()) {
+            /* field type is changed to avoid cyclic types in generated code */
+            methodBody = "(" + methodBody + ").cast[" +
+                         field->getType()->str(locationManager) + "]";
+        }
     }
     std::stringstream s;
     s << "      def " << getter << ": " << returnType << " = " << methodBody
@@ -182,7 +175,8 @@ std::string Struct::generateSetterForArrayRepresentation(
     unsigned int fieldIndex, const LocationManager &locationManager) const {
     std::shared_ptr<Field> field = fields[fieldIndex];
     std::string setter = handleReservedWords(field->getName(), "_=");
-    std::string parameterType = field->getType()->str(locationManager);
+    std::string parameterType =
+        wrapArrayOrRecordInPointer(field->getType())->str(locationManager);
     std::string value = "value";
     std::string castedField = "p._1";
 
@@ -201,9 +195,7 @@ std::string Struct::generateSetterForArrayRepresentation(
         std::shared_ptr<const Type> typeReplacement = getTypeReplacement(
             field->getType(), structTypesThatShouldBeReplaced);
         value = value + ".cast[" + typeReplacement->str(locationManager) + "]";
-    } else if (isAliasForType<ArrayType>(field->getType().get()) ||
-               isAliasForType<Struct>(field->getType().get())) {
-        parameterType = pointerToFieldType.str(locationManager);
+    } else if (isArrayOrRecord(field->getType())) {
         value = "!" + value;
     }
     std::stringstream s;
@@ -217,7 +209,8 @@ std::string Struct::generateGetterForArrayRepresentation(
     unsigned fieldIndex, const LocationManager &locationManager) const {
     std::shared_ptr<Field> field = fields[fieldIndex];
     std::string getter = handleReservedWords(field->getName());
-    std::string returnType;
+    std::string returnType =
+        wrapArrayOrRecordInPointer(field->getType())->str(locationManager);
     std::string methodBody;
 
     PointerType pointerToFieldType = PointerType(field->getType());
@@ -230,17 +223,13 @@ std::string Struct::generateGetterForArrayRepresentation(
     methodBody =
         methodBody + ".cast[" + pointerToFieldType.str(locationManager) + "]";
 
-    if (isAliasForType<ArrayType>(field->getType().get()) ||
-        isAliasForType<Struct>(field->getType().get())) {
-        returnType = pointerToFieldType.str(locationManager);
-    } else if (!shouldFieldBreakCycle(field).empty()) {
-        /* field type is changed to avoid cyclic types in generated code */
-        methodBody = "(!" + methodBody + ").cast[" +
-                     field->getType()->str(locationManager) + "]";
-        returnType = field->getType()->str(locationManager);
-    } else {
+    if (!isArrayOrRecord(field->getType())) {
         methodBody = "!" + methodBody;
-        returnType = field->getType()->str(locationManager);
+        if (!shouldFieldBreakCycle(field).empty()) {
+            /* field type is changed to avoid cyclic types in generated code */
+            methodBody = "(" + methodBody + ").cast[" +
+                         field->getType()->str(locationManager) + "]";
+        }
     }
     std::stringstream s;
     s << "      def " << getter << ": " << returnType << " = " << methodBody
@@ -352,3 +341,47 @@ bool Struct::hasBiggestName(const CycleNode &node,
     }
     return false;
 }
+
+std::string
+Struct::getConstructorHelper(const LocationManager &locationManager) const {
+    std::stringstream s;
+    std::string type = replaceChar(getTypeName(), " ", "_");
+    s << "  object " << type << " {\n"
+      << "    import implicits._\n";
+
+    /* constructor with no parameters */
+    s << "    def apply()(implicit z: native.Zone): native.Ptr[" + type + "]"
+      << " = native.alloc[" + type + "]\n";
+
+    /* constructor that initializes all fields */
+    s << "    def apply(";
+    std::string sep = "";
+    for (const auto &field : fields) {
+        s << sep << handleReservedWords(field->getName()) << ": "
+          << wrapArrayOrRecordInPointer(field->getType())->str(locationManager);
+        sep = ", ";
+    }
+    s << ")(implicit z: native.Zone): native.Ptr[" << type << "] = {\n"
+      << "      val ptr = native.alloc[" << type << "]\n";
+    for (const auto &field : fields) {
+        std::string name = handleReservedWords(field->getName());
+        s << "      ptr." << name << " = " << name << "\n";
+    }
+    s << "      ptr\n"
+      << "    }\n"
+      << "  }\n";
+    return s.str();
+}
+
+bool Struct::isArrayOrRecord(std::shared_ptr<const Type> type) const {
+    return isAliasForType<ArrayType>(type.get()) ||
+           isAliasForType<Struct>(type.get());
+}
+
+std::shared_ptr<const Type>
+Struct::wrapArrayOrRecordInPointer(std::shared_ptr<const Type> type) const {
+    if (isArrayOrRecord(type)) {
+        return std::make_shared<PointerType>(type);
+    }
+    return type;
+}

bindgen/ir/Struct.h

@@ -41,6 +41,9 @@ class Struct : public Record {
         const std::shared_ptr<const Struct> &startStruct, CycleNode &cycleNode,
         std::vector<std::shared_ptr<const Type>> &visitedTypes) const override;
 
+    std::string
+    getConstructorHelper(const LocationManager &locationManager) const;
+
   private:
     /** type size is needed if number of fields is bigger than 22 */
     uint64_t typeSize;
@@ -121,6 +124,14 @@ class Struct : public Record {
      */
     bool hasBiggestName(const CycleNode &node,
                         std::vector<std::string> namesInCycle) const;
+
+    bool isArrayOrRecord(std::shared_ptr<const Type> type) const;
+
+    /**
+     * @return pointer to given type if given type is record or array
+     */
+    std::shared_ptr<const Type>
+    wrapArrayOrRecordInPointer(std::shared_ptr<const Type> type) const;
 };
 
 #endif // SCALA_NATIVE_BINDGEN_STRUCT_H

tests/samples/AnonymousTypes.scala

@@ -19,31 +19,68 @@ object AnonymousTypes {
       def a: native.CChar = !p._1
       def a_=(value: native.CChar): Unit = !p._1 = value
     }
-    def struct_anonymous_0()(implicit z: native.Zone): native.Ptr[struct_anonymous_0] = native.alloc[struct_anonymous_0]
 
     implicit class struct_anonymous_1_ops(val p: native.Ptr[struct_anonymous_1]) extends AnyVal {
       def innerUnion: native.Ptr[union_anonymous_0] = !p._1
       def innerUnion_=(value: native.Ptr[union_anonymous_0]): Unit = !p._1 = value
     }
-    def struct_anonymous_1()(implicit z: native.Zone): native.Ptr[struct_anonymous_1] = native.alloc[struct_anonymous_1]
 
     implicit class struct_StructWithAnonymousStruct_ops(val p: native.Ptr[struct_StructWithAnonymousStruct]) extends AnyVal {
       def innerStruct: native.Ptr[struct_anonymous_1] = !p._1
       def innerStruct_=(value: native.Ptr[struct_anonymous_1]): Unit = !p._1 = value
       def innerEnum: native.CUnsignedInt = !p._2
       def innerEnum_=(value: native.CUnsignedInt): Unit = !p._2 = value
     }
-    def struct_StructWithAnonymousStruct()(implicit z: native.Zone): native.Ptr[struct_StructWithAnonymousStruct] = native.alloc[struct_StructWithAnonymousStruct]
 
     implicit class struct_anonymous_2_ops(val p: native.Ptr[struct_anonymous_2]) extends AnyVal {
       def result: native.CInt = !p._1
       def result_=(value: native.CInt): Unit = !p._1 = value
     }
-    def struct_anonymous_2()(implicit z: native.Zone): native.Ptr[struct_anonymous_2] = native.alloc[struct_anonymous_2]
 
     implicit class union_anonymous_0_pos(val p: native.Ptr[union_anonymous_0]) extends AnyVal {
       def a: native.Ptr[native.CLong] = p.cast[native.Ptr[native.CLong]]
       def a_=(value: native.CLong): Unit = !p.cast[native.Ptr[native.CLong]] = value
     }
   }
+
+  object struct_anonymous_0 {
+    import implicits._
+    def apply()(implicit z: native.Zone): native.Ptr[struct_anonymous_0] = native.alloc[struct_anonymous_0]
+    def apply(a: native.CChar)(implicit z: native.Zone): native.Ptr[struct_anonymous_0] = {
+      val ptr = native.alloc[struct_anonymous_0]
+      ptr.a = a
+      ptr
+    }
+  }
+
+  object struct_anonymous_1 {
+    import implicits._
+    def apply()(implicit z: native.Zone): native.Ptr[struct_anonymous_1] = native.alloc[struct_anonymous_1]
+    def apply(innerUnion: native.Ptr[union_anonymous_0])(implicit z: native.Zone): native.Ptr[struct_anonymous_1] = {
+      val ptr = native.alloc[struct_anonymous_1]
+      ptr.innerUnion = innerUnion
+      ptr
+    }
+  }
+
+  object struct_StructWithAnonymousStruct {
+    import implicits._
+    def apply()(implicit z: native.Zone): native.Ptr[struct_StructWithAnonymousStruct] = native.alloc[struct_StructWithAnonymousStruct]
+    def apply(innerStruct: native.Ptr[struct_anonymous_1], innerEnum: native.CUnsignedInt)(implicit z: native.Zone): native.Ptr[struct_StructWithAnonymousStruct] = {
+      val ptr = native.alloc[struct_StructWithAnonymousStruct]
+      ptr.innerStruct = innerStruct
+      ptr.innerEnum = innerEnum
+      ptr
+    }
+  }
+
+  object struct_anonymous_2 {
+    import implicits._
+    def apply()(implicit z: native.Zone): native.Ptr[struct_anonymous_2] = native.alloc[struct_anonymous_2]
+    def apply(result: native.CInt)(implicit z: native.Zone): native.Ptr[struct_anonymous_2] = {
+      val ptr = native.alloc[struct_anonymous_2]
+      ptr.result = result
+      ptr
+    }
+  }
 }