Expose symbol pattern matching to Swift

Author: literalpie

Sources/IndexStoreDB/IndexStoreDB.swift

@@ -81,29 +81,45 @@ public final class IndexStoreDB {
     }
   }
 
-  public func foreachCanonicalSymbolOccurrenceByName(symbolName: String, body: @escaping (SymbolOccurrence) -> Bool) {
+  public func forEachCanonicalSymbolOccurrenceByName(symbolName: String, body: @escaping (SymbolOccurrence) -> Bool) {
     indexstoredb_for_each_canonical_symbol_occurence_by_name(impl, symbolName) { (occur) -> Bool in
       body(SymbolOccurrence(occur))
     }
   }
 
-  public func findSymbols(matching query: String) -> [SymbolOccurrence] {
-    var symbolNameResults: [String] = []
-    indexstoredb_for_each_symbol_name(impl) { pointer in
-      let str = String(cString: pointer)
-      if str.range(of: query) != nil {
-        symbolNameResults.append(str)
-      }
-      return true
+  public func forEachCanonicalSymbolOccurrence(
+    containing pattern: String,
+    anchorStart: Bool,
+    anchorEnd: Bool,
+    subsequence: Bool,
+    ignoreCase: Bool,
+    body: @escaping (SymbolOccurrence) -> Bool
+  ){
+    indexstoredb_for_each_canonical_symbol_occurence_containing_pattern(
+      impl,
+      pattern,
+      anchorStart,
+      anchorEnd,
+      subsequence,
+      ignoreCase
+    ) { occur in
+      body(SymbolOccurrence(occur))
     }
+  }
+
+  public func findSymbols(matching query: String) -> [SymbolOccurrence] {
     var symbolOccurenceResults: [SymbolOccurrence] = []
-    symbolNameResults.forEach { (symbolName) in
-      foreachCanonicalSymbolOccurrenceByName(symbolName: symbolName) {occurence in
-        if !occurence.location.isSystem {
-          symbolOccurenceResults.append(occurence)
-        }
-        return true
+    forEachCanonicalSymbolOccurrence(
+      containing: query,
+      anchorStart: false,
+      anchorEnd: false,
+      subsequence: true,
+      ignoreCase: true
+    ) { (occurence) -> Bool in
+      if !occurence.location.isSystem {
+        symbolOccurenceResults.append(occurence)
       }
+      return true
     }
     return symbolOccurenceResults
   }

include/CIndexStoreDB/CIndexStoreDB.h

@@ -86,7 +86,7 @@ typedef _Nullable indexstoredb_indexstore_library_t(^indexstore_library_provider
 typedef bool(^indexstoredb_symbol_occurrence_receiver_t)(_Nonnull indexstoredb_symbol_occurrence_t);
 
 /// Returns true to continue.
-typedef bool(^indexstoredb_for_each_symbol_receiver)(const char *_Nonnull);
+typedef bool(^indexstoredb_symbol_name_receiver)(const char *_Nonnull);
 
 INDEXSTOREDB_PUBLIC _Nullable
 indexstoredb_index_t
@@ -163,7 +163,18 @@ INDEXSTOREDB_PUBLIC void
 indexstoredb_error_dispose(_Nullable indexstoredb_error_t);
 
 INDEXSTOREDB_PUBLIC bool
-indexstoredb_for_each_symbol_name(_Nonnull indexstoredb_index_t index, _Nonnull indexstoredb_for_each_symbol_receiver);
+indexstoredb_for_each_symbol_name(_Nonnull indexstoredb_index_t index, _Nonnull indexstoredb_symbol_name_receiver);
+
+INDEXSTOREDB_PUBLIC bool
+indexstoredb_for_each_canonical_symbol_occurence_containing_pattern(
+    _Nonnull indexstoredb_index_t index,
+    const char *_Nonnull Pattern,
+    bool AnchorStart,
+    bool AnchorEnd,
+    bool Subsequence,
+    bool IgnoreCase,
+    _Nonnull indexstoredb_symbol_occurrence_receiver_t receiver);
+
 
 INDEXSTOREDB_PUBLIC bool
 indexstoredb_for_each_canonical_symbol_occurence_by_name(

lib/CIndexStoreDB/CIndexStoreDB.cpp

@@ -149,7 +149,7 @@ indexstoredb_symbol_name(indexstoredb_symbol_t symbol) {
 /// @param receiver a function to be called for each symbol, the CString of the symbol will be passed in to this function.
 /// The function should return a boolean indicating whether the looping should continue.
 bool
-indexstoredb_for_each_symbol_name(indexstoredb_index_t index, indexstoredb_for_each_symbol_receiver receiver) {
+indexstoredb_for_each_symbol_name(indexstoredb_index_t index, indexstoredb_symbol_name_receiver receiver) {
   // indexSystem has foreachsymbolName.
   auto obj = (IndexStoreDBObject<std::shared_ptr<IndexSystem>> *)index;
   return obj->value->foreachSymbolName([&](StringRef ref) -> bool {
@@ -175,6 +175,38 @@ indexstoredb_for_each_canonical_symbol_occurence_by_name(
   });
 }
 
+/// loops through each canonical symbol that matches the pattern, perform the passed in function
+/// @param index an IndexStoreDB object which contains the symbols.
+/// @param AnchorStart when true, symbol names should only be considered matching when the first characters of the symbol name match the pattern.
+/// @param AnchorEnd when true, symbol names should only be considered matching when the first characters of the symbol name match the pattern.
+/// @param Subsequence when true, symbols will be matched even if the pattern is not matched contiguously.
+/// @param IgnoreCase when true, symbols may be returned even if the case of letters does not match the pattern.
+/// @param receiver a function to be called for each canonical occurence that matches the pattern.
+/// The SymbolOccurenceRef of the symbol will be passed in to this function.
+/// The function should return a boolean indicating whether the looping should continue.
+bool
+indexstoredb_for_each_canonical_symbol_occurence_containing_pattern(
+  indexstoredb_index_t index,
+  const char *_Nonnull Pattern,
+  bool AnchorStart,
+  bool AnchorEnd,
+  bool Subsequence,
+  bool IgnoreCase,
+  indexstoredb_symbol_occurrence_receiver_t receiver)
+{
+  auto obj = (IndexStoreDBObject<std::shared_ptr<IndexSystem>> *)index;
+  return obj->value->foreachCanonicalSymbolOccurrenceContainingPattern(
+    Pattern,
+    AnchorStart,
+    AnchorEnd,
+    Subsequence,
+    IgnoreCase,
+    [&](SymbolOccurrenceRef occur
+  ) -> bool {
+      return receiver(make_object(occur));
+  });
+}
+
 indexstoredb_symbol_t
 indexstoredb_symbol_occurrence_symbol(indexstoredb_symbol_occurrence_t occur) {
   auto obj = (IndexStoreDBObject<SymbolOccurrenceRef> *)occur;