Add a test for reserved words

Fix case where reserved word inside `native.Ptr[...]` was not quoted.

Author: jonas

TypeTranslator.cpp

@@ -81,7 +81,7 @@ std::string TypeTranslator::TranslatePointer(const clang::QualType& pte, const s
 
 
 
-    return std::string("native.Ptr[") + Translate(pte, avoid) + std::string("]");
+    return std::string("native.Ptr[") + handleReservedWords(Translate(pte, avoid)) + std::string("]");
 }
 
 std::string TypeTranslator::TranslateStructOrUnion(const clang::QualType& qtpe){

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/samples/ReservedWords.h

@@ -0,0 +1,26 @@
+typedef int match;
+
+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, int 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,51 @@
+import scala.scalanative._
+import scala.scalanative.native._
+import scala.scalanative.native.Nat._
+
+@native.link("ReservedWords")
+@native.extern
+object ReservedWords {
+  type `match` = native.CInt
+  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.CInt, `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
+  }
+}