Merge pull request #28 from jonas/reserved-words

Add a test for reserved words

Author: kornilova203

TypeTranslator.cpp

@@ -153,7 +153,7 @@ std::string TypeTranslator::Translate(const clang::QualType& qtpe, const std::st
         return TranslatePointer(tpe->getAs<clang::PointerType>()->getPointeeType(), avoid);
 
     } else if(qtpe->isStructureType() || qtpe->isUnionType()){
-        return TranslateStructOrUnion(qtpe);
+        return handleReservedWords(TranslateStructOrUnion(qtpe));
 
     } else if(qtpe->isEnumeralType()){
         return TranslateEnum(qtpe);
@@ -166,10 +166,10 @@ std::string TypeTranslator::Translate(const clang::QualType& qtpe, const std::st
 
         auto found = typeMap.find(qtpe.getUnqualifiedType().getAsString());
         if(found != typeMap.end()){
-            return found->second;
+            return handleReservedWords(found->second);
         } else {
             //TODO: Properly handle non-default types
-            return qtpe.getUnqualifiedType().getAsString();
+            return handleReservedWords(qtpe.getUnqualifiedType().getAsString());
         }
     }
 

Utils.h

@@ -68,12 +68,12 @@ static std::array<std::string, 39> reserved_words = {"abstract", "case", "catch"
                                       "protected", "return", "sealed", "super", "this", "throw", "trait", "try",
                                       "true", "type", "val", "var", "while", "with", "yield"};
 
-inline std::string handleReservedWords(std::string name){
+inline std::string handleReservedWords(std::string name, std::string suffix = "") {
     auto found = std::find(reserved_words.begin(), reserved_words.end(), name);
-    if(found != reserved_words.end()){
-        return "`" + name + "`";
-    } else{
-        return name;
+    if (found != reserved_words.end()) {
+        return "`" + name + suffix + "`";
+    } else {
+        return name + suffix;
     }
 }
 

ir/Struct.cpp

@@ -46,10 +46,11 @@ std::string Struct::generateHelperClass() const {
     int fieldIndex = 0;
     for (const auto &field : fields) {
         if (!field.getName().empty()) {
-            std::string fname = handleReservedWords(field.getName());
+            std::string getter = handleReservedWords(field.getName());
+            std::string setter = handleReservedWords(field.getName(), "_=");
             std::string ftype = field.getType();
-            s << "    def " << fname << ": " << ftype << " = !p._" << std::to_string(fieldIndex + 1) << "\n"
-              << "    def " << fname << "_=(value: " + ftype + "):Unit = !p._" << std::to_string(fieldIndex + 1)
+            s << "    def " << getter << ": " << ftype << " = !p._" << std::to_string(fieldIndex + 1) << "\n"
+              << "    def " << setter << "(value: " + ftype + "):Unit = !p._" << std::to_string(fieldIndex + 1)
               << " = value\n";
         }
         fieldIndex++;
@@ -81,13 +82,14 @@ std::string Union::generateHelperClass() const {
       << "(val p: native.Ptr[union_" << name << "]) extends AnyVal {\n";
     for (const auto &field : fields) {
         if (!field.getName().empty()) {
-            std::string fname = handleReservedWords(field.getName());
+            std::string getter = handleReservedWords(field.getName());
+            std::string setter = handleReservedWords(field.getName(), "_=");
             std::string ftype = field.getType();
-            s << "    def " << fname
+            s << "    def " << getter
               << ": native.Ptr[" << ftype << "] = p.cast[native.Ptr[" << ftype << "]]\n";
 
-            s << "    def " << fname
-              << "_=(value: " << ftype << "): Unit = !p.cast[native.Ptr[" << ftype << "]] = value\n";
+            s << "    def " << setter
+              << "(value: " << ftype << "): Unit = !p.cast[native.Ptr[" << ftype << "]] = value\n";
         }
     }
     s << "  }\n";

tests/build.sbt

@@ -14,6 +14,7 @@ inThisBuild(
 
 val `scala-native-bindgen-tests` = project
   .in(file("."))
+  .aggregate(samples)
   .settings(
     fork in Test := true,
     javaOptions in Test += "-Dbindgen.path=" + file("../target/scalaBindgen"),
@@ -25,5 +26,6 @@ val `scala-native-bindgen-tests` = project
     libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.5" % Test
   )
 
-val samples = project
+lazy val samples = project
   .enablePlugins(ScalaNativePlugin)
+  .settings(test := (compile in Compile).value)

tests/samples/ReservedWords.h

@@ -0,0 +1,27 @@
+typedef int match;
+typedef match var[5];
+
+struct object {
+  match yield;
+  int val;
+};
+
+typedef struct object object;
+typedef struct object type;
+
+union lazy {
+  object *instance;
+  match forSome;
+  struct {
+    char def;
+    type *super;
+  } implicit;
+};
+
+typedef union lazy lazy;
+
+type with(match sealed, var implicit, lazy forSome);
+
+typedef match def;
+typedef struct { def val; lazy finally; } finally;
+match implicit(finally type[12]);

tests/samples/ReservedWords.scala

@@ -0,0 +1,52 @@
+import scala.scalanative._
+import scala.scalanative.native._
+import scala.scalanative.native.Nat._
+
+@native.link("ReservedWords")
+@native.extern
+object ReservedWords {
+  type `match` = native.CInt
+  type `var` = native.CArray[`match`, _5]
+  type `object` = struct_object
+  type `type` = struct_object
+  type `lazy` = union_lazy
+  type `def` = `match`
+  type `finally` = struct_finally
+  type struct_object = native.CStruct2[`match`, native.CInt]
+  type struct_finally = native.CStruct2[`def`, `lazy`]
+  type union_lazy = native.CArray[Byte, Digit[_1, Digit[_2, _8]]]
+  def `with`(`sealed`: `match`, `implicit`: native.Ptr[`match`], `forSome`: `lazy`): `type` = native.extern
+  def `implicit`(`type`: native.Ptr[`finally`]): `match` = native.extern
+}
+
+import ReservedWords._
+
+object ReservedWordsHelpers {
+
+  implicit class struct_object_ops(val p: native.Ptr[struct_object]) extends AnyVal {
+    def `yield`: `match` = !p._1
+    def `yield_=`(value: `match`):Unit = !p._1 = value
+    def `val`: native.CInt = !p._2
+    def `val_=`(value: native.CInt):Unit = !p._2 = value
+  }
+
+  def struct_object()(implicit z: native.Zone): native.Ptr[struct_object] = native.alloc[struct_object]
+
+  implicit class struct_finally_ops(val p: native.Ptr[struct_finally]) extends AnyVal {
+    def `val`: `def` = !p._1
+    def `val_=`(value: `def`):Unit = !p._1 = value
+    def `finally`: `lazy` = !p._2
+    def `finally_=`(value: `lazy`):Unit = !p._2 = value
+  }
+
+  def struct_finally()(implicit z: native.Zone): native.Ptr[struct_finally] = native.alloc[struct_finally]
+
+  implicit class union_lazy_pos(val p: native.Ptr[union_lazy]) extends AnyVal {
+    def instance: native.Ptr[native.Ptr[`object`]] = p.cast[native.Ptr[native.Ptr[`object`]]]
+    def instance_=(value: native.Ptr[`object`]): Unit = !p.cast[native.Ptr[native.Ptr[`object`]]] = value
+    def `forSome`: native.Ptr[`match`] = p.cast[native.Ptr[`match`]]
+    def `forSome_=`(value: `match`): Unit = !p.cast[native.Ptr[`match`]] = value
+    def `implicit`: native.Ptr[native.CArray[Byte, Digit[_1, Digit[_2, _8]]]] = p.cast[native.Ptr[native.CArray[Byte, Digit[_1, Digit[_2, _8]]]]]
+    def `implicit_=`(value: native.CArray[Byte, Digit[_1, Digit[_2, _8]]]): Unit = !p.cast[native.Ptr[native.CArray[Byte, Digit[_1, Digit[_2, _8]]]]] = value
+  }
+}