Rename lib object and functions with name "native"

Author: kornilova203

bindgen/ir/Function.cpp

@@ -6,11 +6,14 @@ Parameter::Parameter(std::string name, std::string type)
 
 Function::Function(std::string name, std::vector<Parameter> parameters,
                    std::string retType, bool isVariadic)
-    : name(std::move(name)), parameters(std::move(parameters)),
+    : name(name), scalaName(name), parameters(std::move(parameters)),
       retType(std::move(retType)), isVariadic(isVariadic) {}
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const Function &func) {
-    s << "  def " << handleReservedWords(func.name) << "(";
+    if (func.scalaName != func.name) {
+        s << "  @native.link(\"" << func.name << "\")\n";
+    }
+    s << "  def " << handleReservedWords(func.scalaName) << "(";
     std::string sep = "";
     for (const auto &param : func.parameters) {
         s << sep << handleReservedWords(param.getName()) << ": "
@@ -43,17 +46,21 @@ std::string Function::getName() const { return name; }
 std::string Function::getVarargsParameterName() const {
     std::string parameterName = "varArgs";
     int i = 0;
-    while (existParameterWithName(parameterName)) {
+    while (existsParameterWithName(parameterName)) {
         parameterName = "varArgs" + std::to_string(i++);
     }
     return parameterName;
 }
 
-bool Function::existParameterWithName(const std::string &parameterName) const {
+bool Function::existsParameterWithName(const std::string &parameterName) const {
     for (const auto &parameter : parameters) {
         if (parameter.getName() == parameterName) {
             return true;
         }
     }
     return false;
 }
+
+void Function::setScalaName(std::string scalaName) {
+    this->scalaName = std::move(scalaName);
+}

bindgen/ir/Function.h

@@ -23,12 +23,15 @@ class Function {
 
     std::string getName() const;
 
+    void setScalaName(std::string scalaName);
+
   private:
     std::string getVarargsParameterName() const;
 
-    bool existParameterWithName(const std::string &parameterName) const;
+    bool existsParameterWithName(const std::string &parameterName) const;
 
-    std::string name;
+    std::string name;      // real name of the function
+    std::string scalaName; // not empty
     std::vector<Parameter> parameters;
     std::string retType;
     bool isVariadic;

bindgen/ir/IR.cpp

@@ -1,7 +1,15 @@
 #include "IR.h"
 #include "../Utils.h"
 
-IR::IR(std::string libName) : libName(std::move(libName)) {}
+IR::IR(std::string libName) : libName(std::move(libName)) {
+    if (this->libName == "native") {
+        /* there are at most 3 objects in the file.
+         * All of them will have distinct names. */
+        libObjectName = "nativeLib";
+    } else {
+        libObjectName = this->libName;
+    }
+}
 
 void IR::addFunction(std::string name, std::vector<Parameter> parameters,
                      std::string retType, bool isVariadic) {
@@ -46,7 +54,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
           << "import scala.scalanative.native._\n\n";
     }
 
-    std::string libObjName = handleReservedWords(ir.libName);
+    std::string libObjName = handleReservedWords(ir.libObjectName);
 
     if (!ir.libObjEmpty()) {
         s << "@native.link(\"" << ir.libName << "\")\n"
@@ -116,6 +124,7 @@ void IR::generateTypeDefs() {
 
 void IR::generate(const std::string &excludePrefix) {
     if (!generated) {
+        setScalaNames();
         filterDeclarations(excludePrefix);
         generateTypeDefs();
         generated = true;
@@ -199,5 +208,30 @@ bool IR::typeIsUsedOnlyInTypeDefs(std::string type) {
 }
 
 void IR::setPackageName(std::string packageName) {
-    this->packageName = packageName;
+    this->packageName = std::move(packageName);
+}
+
+void IR::setScalaNames() {
+    /* Renaming according to Scala naming conventions
+     * should happen here */
+
+    for (auto &function : functions) {
+        if (function.getName() == "native") {
+            std::string scalaName = "nativeFunc";
+            int i = 0;
+            while (existsFunctionWithName(scalaName)) {
+                scalaName = "nativeFunc" + std::to_string(i++);
+            }
+            function.setScalaName(scalaName);
+        }
+    }
+}
+
+bool IR::existsFunctionWithName(std::string functionName) {
+    for (const auto &function : functions) {
+        if (function.getName() == functionName) {
+            return true;
+        }
+    }
+    return false;
 }

bindgen/ir/IR.h

@@ -101,7 +101,12 @@ class IR {
     bool isTypeUsed(const std::vector<T> &declarations,
                     const std::string &type);
 
-    std::string libName;
+    void setScalaNames();
+
+    bool existsFunctionWithName(std::string functionName);
+
+    std::string libName;       // name of the library
+    std::string libObjectName; // name of Scala object
     std::vector<Function> functions;
     std::vector<TypeDef> typeDefs;
     std::vector<Struct> structs;

tests/samples/native.h

@@ -0,0 +1,4 @@
+void native(int);
+void nativeFunc(float);
+
+typedef int nativeFunc0;

tests/samples/native.scala

@@ -0,0 +1,11 @@
+import scala.scalanative._
+import scala.scalanative.native._
+
+@native.link("native")
+@native.extern
+object nativeLib {
+  type nativeFunc0 = native.CInt
+  @native.link("native")
+  def nativeFunc0(anonymous0: native.CInt): Unit = native.extern
+  def nativeFunc(anonymous0: native.CFloat): Unit = native.extern
+}