refactor: improve parameter handling and memory management across various classes

- Updated function and method signatures to use const references for string parameters, enhancing performance and clarity.
- Introduced new member variables for better organization and memory management in classes such as MemberDecl and MetadataFactory.
- Enhanced the handling of collections by reserving space in vectors and unordered sets to optimize memory usage.
- Improved the process of adding and managing protocols, enums, and classes within the MetadataFactory, ensuring more efficient lookups and insertions.
- Refactored various methods to utilize move semantics for better performance when dealing with temporary objects.

Author: DjDeveloperr

metadata-generator/include/IR.h

@@ -234,6 +234,7 @@ class MemberDecl {
 
   // Method overloads for TS emission (used to preserve superclass signatures).
   std::vector<MemberDecl> overloads;
+  std::vector<std::string> overloadSignatureKeys;
 
   void addOverloadFrom(const MemberDecl& member);
 };
@@ -248,7 +249,7 @@ class ClassDecl {
 
   ClassDecl(CXCursor cursor);
 
-  MemberDecl* getMemberNamed(std::string& name);
+  MemberDecl* getMemberNamed(const std::string& name);
 
   void postProcessMembers();
 
@@ -279,7 +280,7 @@ class ProtocolDecl {
 
   ProtocolDecl(CXCursor cursor);
 
-  MemberDecl* getMemberNamed(std::string& name);
+  MemberDecl* getMemberNamed(const std::string& name);
 
   void postProcessMembers();
 
@@ -376,10 +377,11 @@ class MetadataFactory {
   std::unordered_set<std::string> referencedProtocols;
 
   std::unordered_set<std::string> renamedProtocols;
-  std::unordered_set<std::string> missingClasses;
+ std::unordered_set<std::string> missingClasses;
 
  private:
   bool _checkAvailability = false;
+  std::unordered_map<std::string, bool> shouldProcessCache;
 
   std::unordered_map<std::string, EnumDecl> skippedEnums;
   std::unordered_map<std::string, StructDecl> skippedStructs;

metadata-generator/include/MetadataWriter.h

@@ -236,19 +236,22 @@ class MDSection : public std::unordered_map<MDSectionOffset, T> {
   size_t section_size;
   S serde;
   std::unordered_map<std::string, MDSectionOffset> stringToKey;
+  std::vector<std::pair<MDSectionOffset, T>> orderedEntries;
 
   MDSection(S serde) : section_offset(0), section_size(0), serde(serde) {}
 
-  inline MDSectionOffset add(T value, std::string strKey) {
-    if (stringToKey.contains(strKey)) {
-      return stringToKey[strKey];
+  inline MDSectionOffset add(T value, const std::string& strKey) {
+    auto keyIt = stringToKey.find(strKey);
+    if (keyIt != stringToKey.end()) {
+      return keyIt->second;
     }
     MDSectionOffset key = (MDSectionOffset)section_offset;
     size_t valueSize = serde.size(value);
     section_offset += valueSize;
     section_size += valueSize;
-    this->insert(std::make_pair(key, value));
-    stringToKey.insert(std::make_pair(strKey, key));
+    this->emplace(key, value);
+    orderedEntries.emplace_back(key, value);
+    stringToKey.emplace(strKey, key);
     return key;
   }
 };
@@ -272,7 +275,7 @@ class MDMetadataWriter {
         protocols(MDProtocolSerde()), classes(MDClassSerde()),
         structs(MDStructSerde()), unions(MDUnionSerde()) {}
 
-  MDTypeInfo *getTypeInfo(TypeSpec &type);
+  MDTypeInfo *getTypeInfo(const TypeSpec &type);
 
   MDMember *memberFromDecl(MemberDecl &decl);
 

metadata-generator/include/TSEmitter.h

@@ -18,7 +18,7 @@ class TSLines {
 public:
   TSLines() {}
 
-  void write(std::string value);
+  void write(const std::string& value);
   void newline();
   void enter();
   void exit();
@@ -48,7 +48,7 @@ class TSFile {
 
   std::string toString();
 
-  inline void import(std::string module) { imports.insert(module); }
+  inline void import(const std::string& module) { imports.insert(module); }
 
   MetadataFactory *factory = nullptr;
 
@@ -72,7 +72,7 @@ class TSEmitter {
 
   void resolveImports(TSFile &file);
 
-  void ensureFile(std::string framework);
+  TSFile& ensureFile(const std::string& framework);
 
   void write();
 

metadata-generator/include/Util.h

@@ -5,8 +5,9 @@
 
 namespace metagen {
 
-inline std::string jsifySelector(std::string selector) {
+inline std::string jsifySelector(const std::string& selector) {
   std::string jsifiedSelector;
+  jsifiedSelector.reserve(selector.size());
   bool nextupper = false;
   for (auto c : selector) {
     if (c == ':') {
@@ -21,29 +22,31 @@ inline std::string jsifySelector(std::string selector) {
   return jsifiedSelector;
 }
 
-inline std::string jsifyName(std::string name) {
+inline std::string jsifyName(const std::string& name) {
   if (name == "arguments" || name == "function" || name == "DOMException") {
     return name + "$";
   } else {
     return name;
   }
 }
 
-inline std::vector<std::string> splitCamelCase(std::string value) {
+inline std::vector<std::string> splitCamelCase(const std::string& value) {
   std::vector<std::string> result;
+  result.reserve(value.size() / 4 + 1);
 
-  std::string current = "";
+  std::string current;
+  current.reserve(value.size());
   for (auto c : value) {
     if (isupper(c)) {
-      if (current != "") {
+      if (!current.empty()) {
         result.emplace_back(current);
       }
       current = "";
     }
     current += c;
   }
 
-  if (current != "") {
+  if (!current.empty()) {
     result.emplace_back(current);
   }
 
@@ -117,7 +120,7 @@ inline bool isAvailable(CXCursor cursor) {
          availability == CXAvailability_Deprecated;
 }
 
-inline bool isSelectorOwned(std::string selectorName) {
+inline bool isSelectorOwned(const std::string& selectorName) {
   return selectorName.find("copy") == 0 ||
          selectorName.find("mutableCopy") == 0 ||
          selectorName.find("new") == 0 || selectorName.find("alloc") == 0;

metadata-generator/src/IR/Category.cpp

@@ -59,7 +59,7 @@ void CategoryDecl::processMembers(
         case CXCursor_ObjCInstanceMethodDecl: {
           auto member = MemberDecl(cursor, cls->_classTypeParameters);
           member.parentClassName = cls->className;
-          cls->members.emplace_back(member);
+          cls->members.emplace_back(std::move(member));
           break;
         }
 

metadata-generator/src/IR/Class.cpp

@@ -90,7 +90,7 @@ ClassDecl::ClassDecl(CXCursor cursor) {
           case CXCursor_ObjCInstanceMethodDecl: {
             auto member = MemberDecl(cursor, &cls->typeParameters);
             member.parentClassName = cls->name;
-            cls->members.emplace_back(member);
+            cls->members.emplace_back(std::move(member));
             break;
           }
           default:
@@ -102,7 +102,7 @@ ClassDecl::ClassDecl(CXCursor cursor) {
       this);
 }
 
-MemberDecl* ClassDecl::getMemberNamed(std::string& name) {
+MemberDecl* ClassDecl::getMemberNamed(const std::string& name) {
   for (auto& member : members) {
     if (member.name == name) {
       return &member;
@@ -113,6 +113,7 @@ MemberDecl* ClassDecl::getMemberNamed(std::string& name) {
 
 void removeDuplicateMethods(std::vector<MemberDecl>& members) {
   std::vector<MemberDecl> filteredMembers;
+  filteredMembers.reserve(members.size());
 
   // Remove getter methods in favor of properties
 
@@ -154,23 +155,23 @@ void removeDuplicateMethods(std::vector<MemberDecl>& members) {
     filtered.insert(member.name);
   }
 
-  members = filteredMembers;
+  members = std::move(filteredMembers);
 }
 
 void MetadataFactory::processClassRefs() {
   while (!referencedClasses.empty()) {
-    std::unordered_set<std::string> refs = referencedClasses;
-    referencedClasses.clear();
+    std::unordered_set<std::string> refs;
+    refs.swap(referencedClasses);
 
     for (const std::string& name : refs) {
       if (classes.contains(name)) {
         continue;
       }
 
-      if (skippedClasses.contains(name)) {
-        ClassDecl decl = skippedClasses[name];
-        classes[name] = decl;
-        postProcessClass(classes[name]);
+      auto skippedIt = skippedClasses.find(name);
+      if (skippedIt != skippedClasses.end()) {
+        auto [inserted, _] = classes.try_emplace(name, skippedIt->second);
+        postProcessClass(inserted->second);
       } else {
         std::cerr << "ERROR: Unknown class " << name << std::endl;
         missingClasses.emplace(name);

metadata-generator/src/IR/Enum.cpp

@@ -14,13 +14,13 @@ namespace metagen {
 // Basically, split the name into parts (assuming camel case), and then remove
 // the repeating parts from the beginning and end of the name.
 void transformEnumMemberNames(std::vector<EnumConstDecl> &members) {
-  std::vector<std::string> result;
   std::vector<std::vector<std::string>> parts;
+  parts.reserve(members.size());
   size_t skip_begin = 0, skip_end = 0;
   std::vector<std::string> largestPart;
 
-  for (auto part : members) {
-    auto split = splitCamelCase(part.name);
+  for (const auto& member : members) {
+    auto split = splitCamelCase(member.name);
     parts.emplace_back(split);
     if (split.size() > largestPart.size()) {
       largestPart = split;
@@ -30,7 +30,7 @@ void transformEnumMemberNames(std::vector<EnumConstDecl> &members) {
   skip_begin = skip_end = largestPart.size();
 
   for (size_t i = 0; i < parts.size(); i++) {
-    auto part = parts[i];
+    const auto& part = parts[i];
     size_t skip = 0;
 
     for (size_t j = 0; j < part.size(); j++) {
@@ -51,11 +51,12 @@ void transformEnumMemberNames(std::vector<EnumConstDecl> &members) {
 
     skip = 0;
 
-    for (size_t j = part.size() - 1; j >= 0; j--) {
-      if (j >= largestPart.size()) {
+    for (size_t k = 0; k < part.size(); k++) {
+      if (k >= largestPart.size()) {
         break;
       }
 
+      const size_t j = part.size() - 1 - k;
       if (part[j] == largestPart[largestPart.size() - 1 - skip]) {
         skip++;
       } else {
@@ -69,8 +70,9 @@ void transformEnumMemberNames(std::vector<EnumConstDecl> &members) {
   }
 
   for (size_t i = 0; i < members.size(); i++) {
-    auto part = parts[i];
-    std::string name = "";
+    const auto& part = parts[i];
+    std::string name;
+    name.reserve(members[i].name.size());
 
     for (size_t j = skip_begin; j < part.size() - skip_end; j++) {
       name += part[j];
@@ -132,20 +134,21 @@ EnumDecl::EnumDecl(CXCursor cursor) {
 }
 
 void MetadataFactory::processEnumRefs() {
-  for (const std::string &ref : referencedEnums) {
+  std::unordered_set<std::string> refs;
+  refs.swap(referencedEnums);
+
+  for (const std::string &ref : refs) {
     if (enums.contains(ref)) {
       continue;
     }
 
-    if (skippedEnums.contains(ref)) {
-      EnumDecl decl = skippedEnums[ref];
-      enums[decl.name] = decl;
+    auto skippedIt = skippedEnums.find(ref);
+    if (skippedIt != skippedEnums.end()) {
+      enums.insert_or_assign(skippedIt->second.name, skippedIt->second);
     } else {
       std::cerr << "processEnumRef: Enum " << ref << " not found" << std::endl;
     }
   }
-
-  referencedEnums.clear();
 }
 
 } // namespace metagen