Add index-while-building support to Clang - non-Apple platforms

[yvvan]

Summary

Follow up for https://reviews.llvm.org/D41407 - make it not Apple-specific. With this patch works with both clang and clang-cl

include/clang/Driver/Options.td

 def objcmt_migrate_designated_init : Flag<["-"], "objcmt-migrate-designated-init">, Flags<[CC1Option]>,
   HelpText<"Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods">;
 def objcmt_whitelist_dir_path: Joined<["-"], "objcmt-whitelist-dir-path=">, Flags<[CC1Option]>,
   HelpText<"Only modify files with a filename contained in the provided directory path">;
 // The misspelt "white-list" [sic] alias is due for removal.
 def : Joined<["-"], "objcmt-white-list-dir-path=">, Flags<[CC1Option]>,
     Alias<objcmt_whitelist_dir_path>;
 
-def index_store_path : Separate<["-"], "index-store-path">, Flags<[CC1Option]>,
+def index_store_path : Separate<["-"], "index-store-path">, Flags<[CoreOption,CC1Option]>,
   HelpText<"Enable indexing with the specified data store path">;
-def index_ignore_system_symbols : Flag<["-"], "index-ignore-system-symbols">, Flags<[CC1Option]>,
+def index_ignore_system_symbols : Flag<["-"], "index-ignore-system-symbols">, Flags<[CoreOption,CC1Option]>,
   HelpText<"Ignore symbols from system headers">;
-def index_record_codegen_name : Flag<["-"], "index-record-codegen-name">, Flags<[CC1Option]>,
+def index_record_codegen_name : Flag<["-"], "index-record-codegen-name">, Flags<[CoreOption,CC1Option]>,
   HelpText<"Record the codegen name for symbols">;
 
 // Make sure all other -ccc- options are rejected.
 def ccc_ : Joined<["-"], "ccc-">, Group<internal_Group>, Flags<[Unsupported]>;
 
 // Standard Options
 
 def _HASH_HASH_HASH : Flag<["-"], "###">, Flags<[DriverOption, CoreOption]>,

include/clang/Index/IndexDataStore.h

 //===--- IndexDataStore.h - Index data store info -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_INDEX_INDEXDATASTORE_H
 #define LLVM_CLANG_INDEX_INDEXDATASTORE_H
 
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
+
+#include <ctime>
 #include <functional>
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace index {
 

include/indexstore/IndexStoreCXX.h

public:
   IndexRecordOccurrence(indexstore_occurrence_t obj) : obj(obj) {}
 
   IndexRecordSymbol getSymbol() {
     return indexstore_occurrence_get_symbol(obj);
   }
   uint64_t getRoles() { return indexstore_occurrence_get_roles(obj); }
 
   bool foreachRelation(llvm::function_ref<bool(IndexSymbolRelation)> receiver) {
-#if INDEXSTORE_HAS_BLOCKS
     return indexstore_occurrence_relations_apply(
-        obj, ^bool(indexstore_symbol_relation_t sym_rel) {
-          return receiver(sym_rel);
-        });
+        obj,
+#if INDEXSTORE_HAS_BLOCKS
+        ^bool(indexstore_symbol_relation_t sym_rel) {
 #else
-    return false;
+        [receiver](indexstore_symbol_relation_t sym_rel) {
 #endif
+          return receiver(sym_rel);
+        });
   }
 
   std::pair<unsigned, unsigned> getLineCol() {
     unsigned line, col;
     indexstore_occurrence_get_line_col(obj, &line, &col);
     return std::make_pair(line, col);
   }
 };
public:
   static unsigned formatVersion() { return indexstore_format_version(); }
 
   bool isValid() const { return obj; }
   bool isInvalid() const { return !isValid(); }
   explicit operator bool() const { return isValid(); }
 
   bool foreachUnit(bool sorted,
                    llvm::function_ref<bool(StringRef unitName)> receiver) {
-#if INDEXSTORE_HAS_BLOCKS
     return indexstore_store_units_apply(
-        obj, sorted, ^bool(indexstore_string_ref_t unit_name) {
-          return receiver(stringFromIndexStoreStringRef(unit_name));
-        });
+        obj, sorted,
+#if INDEXSTORE_HAS_BLOCKS
+        ^bool(indexstore_string_ref_t unit_name) {
 #else
-    return false;
+        [receiver](indexstore_string_ref_t unit_name) {
 #endif
+          return receiver(stringFromIndexStoreStringRef(unit_name));
+        });
   }
 
   class UnitEvent {
     indexstore_unit_event_t obj;
 
   public:
     UnitEvent(indexstore_unit_event_t obj) : obj(obj) {}
 
public:
     UnitEvent getEvent(size_t index) const {
       return indexstore_unit_event_notification_get_event(obj, index);
     }
   };
 
   typedef std::function<void(UnitEventNotification)> UnitEventHandler;
 
   void setUnitEventHandler(UnitEventHandler handler) {
-#if INDEXSTORE_HAS_BLOCKS
     if (!handler) {
       indexstore_store_set_unit_event_handler(obj, nullptr);
       return;
     }
 
     indexstore_store_set_unit_event_handler(
-        obj, ^(indexstore_unit_event_notification_t evt_note) {
+        obj,
+#if INDEXSTORE_HAS_BLOCKS
+        ^(indexstore_unit_event_notification_t evt_note) {
+#else
+        [handler](indexstore_unit_event_notification_t evt_note) {
+#endif
           handler(UnitEventNotification(evt_note));
         });
-#endif
   }
 
   bool startEventListening(bool waitInitialSync, std::string &error) {
     indexstore_unit_event_listen_options_t opts;
     opts.wait_initial_sync = waitInitialSync;
     indexstore_error_t c_err = nullptr;
     bool ret = indexstore_store_start_unit_event_listening(
         obj, &opts, sizeof(opts), &c_err);
return indexstore_record_reader_search_symbols(
         obj,
         ^bool(indexstore_symbol_t symbol, bool *stop) {
           return filter(symbol, *stop);
         },
         ^(indexstore_symbol_t symbol) {
           receiver(symbol);
         });
 #else
-    return false;
+    return indexstore_record_reader_search_symbols(
+        obj,
+        [filter](indexstore_symbol_t symbol, bool *stop) {
+          return filter(symbol, *stop);
+        },
+        [receiver](indexstore_symbol_t symbol) { receiver(symbol); });
 #endif
   }
 
   bool foreachSymbol(bool noCache,
                      llvm::function_ref<bool(IndexRecordSymbol)> receiver) {
-#if INDEXSTORE_HAS_BLOCKS
     return indexstore_record_reader_symbols_apply(
-        obj, noCache, ^bool(indexstore_symbol_t sym) {
-          return receiver(sym);
-        });
+        obj, noCache,
+#if INDEXSTORE_HAS_BLOCKS
+        ^bool(indexstore_symbol_t sym) {
 #else
-    return false;
+        [receiver](indexstore_symbol_t sym) {
 #endif
+          return receiver(sym);
+        });
   }
 
   /// \param DeclsFilter if non-empty indicates the list of decls that we want
   /// to get occurrences for. An empty array indicates that we want occurrences
   /// for all decls.
   /// \param RelatedDeclsFilter Same as \c DeclsFilter but for related decls.
   bool
   foreachOccurrence(ArrayRef<IndexRecordSymbol> symbolsFilter,
                     ArrayRef<IndexRecordSymbol> relatedSymbolsFilter,
                     llvm::function_ref<bool(IndexRecordOccurrence)> receiver) {
-#if INDEXSTORE_HAS_BLOCKS
     llvm::SmallVector<indexstore_symbol_t, 16> c_symbolsFilter;
     c_symbolsFilter.reserve(symbolsFilter.size());
     for (IndexRecordSymbol sym : symbolsFilter) {
       c_symbolsFilter.push_back(sym.obj);
     }
     llvm::SmallVector<indexstore_symbol_t, 16> c_relatedSymbolsFilter;
     c_relatedSymbolsFilter.reserve(relatedSymbolsFilter.size());
     for (IndexRecordSymbol sym : relatedSymbolsFilter) {
       c_relatedSymbolsFilter.push_back(sym.obj);
     }
+
     return indexstore_record_reader_occurrences_of_symbols_apply(
         obj, c_symbolsFilter.data(), c_symbolsFilter.size(),
         c_relatedSymbolsFilter.data(), c_relatedSymbolsFilter.size(),
+#if INDEXSTORE_HAS_BLOCKS
         ^bool(indexstore_occurrence_t occur) {
-          return receiver(occur);
-        });
 #else
-    return false;
+        [receiver](indexstore_occurrence_t occur) {
 #endif
+          return receiver(occur);
+        });
   }
 
   bool
   foreachOccurrence(llvm::function_ref<bool(IndexRecordOccurrence)> receiver) {
-#if INDEXSTORE_HAS_BLOCKS
     return indexstore_record_reader_occurrences_apply(
-        obj, ^bool(indexstore_occurrence_t occur) {
-          return receiver(occur);
-        });
+        obj,
+#if INDEXSTORE_HAS_BLOCKS
+        ^bool(indexstore_occurrence_t occur) {
 #else
-    return false;
+        [receiver](indexstore_occurrence_t occur) {
 #endif
+          return receiver(occur);
+        });
   }
 
   bool foreachOccurrenceInLineRange(
       unsigned lineStart, unsigned lineEnd,
       llvm::function_ref<bool(IndexRecordOccurrence)> receiver) {
 #if INDEXSTORE_HAS_BLOCKS
     return indexstore_record_reader_occurrences_in_line_range_apply(
         obj, lineStart, lineEnd, ^bool(indexstore_occurrence_t occur) {
           return receiver(occur);
         });
 #else
-    return false;
+    return indexstore_record_reader_occurrences_in_line_range_apply(
+        obj, lineStart, lineEnd,
+        [receiver](indexstore_occurrence_t occur) { return receiver(occur); });
 #endif
   }
 };
 
 class IndexUnitDependency {
   indexstore_unit_dependency_t obj;
   friend class IndexUnitReader;
 
public:
   }
   StringRef getTarget() {
     return stringFromIndexStoreStringRef(
         indexstore_unit_reader_get_target(obj));
   }
 
   bool
   foreachDependency(llvm::function_ref<bool(IndexUnitDependency)> receiver) {
-#if INDEXSTORE_HAS_BLOCKS
     return indexstore_unit_reader_dependencies_apply(
-        obj, ^bool(indexstore_unit_dependency_t dep) {
-          return receiver(dep);
-        });
+        obj,
+#if INDEXSTORE_HAS_BLOCKS
+        ^bool(indexstore_unit_dependency_t dep) {
 #else
-    return false;
+        [receiver](indexstore_unit_dependency_t dep) {
 #endif
+          return receiver(dep);
+        });
   }
 
   bool foreachInclude(llvm::function_ref<bool(IndexUnitInclude)> receiver) {
-#if INDEXSTORE_HAS_BLOCKS
     return indexstore_unit_reader_includes_apply(
-        obj, ^bool(indexstore_unit_include_t inc) {
-          return receiver(inc);
-        });
+        obj,
+#if INDEXSTORE_HAS_BLOCKS
+        ^bool(indexstore_unit_include_t inc) {
 #else
-    return false;
+        [receiver](indexstore_unit_include_t inc) {
 #endif
+          return receiver(inc);
+        });
   }
 };
 
 } // namespace indexstore
 
 #endif

include/indexstore/indexstore.h

 /*===-- indexstore/indexstore.h - Index Store C API ----------------- C -*-===*\
 |*                                                                            *|
 |*                     The LLVM Compiler Infrastructure                       *|
 |*                                                                            *|
 |* This file is distributed under the University of Illinois Open Source      *|
 |* License. See LICENSE.TXT for details.                                      *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This header provides a C API for the index store.                          *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #ifndef LLVM_CLANG_C_INDEXSTORE_INDEXSTORE_H
 #define LLVM_CLANG_C_INDEXSTORE_INDEXSTORE_H
 
+#include "llvm/ADT/STLExtras.h"
+
 #include <ctime>
 #include <stddef.h>
 #include <stdint.h>
 
 /**
  * \brief The version constants for the Index Store C API.
  * INDEXSTORE_VERSION_MINOR should increase when there are API additions.
  * INDEXSTORE_VERSION_MAJOR is intended for "major" source/ABI breaking changes.

 #define INDEXSTORE_END_DECLS }
 #else
 #define INDEXSTORE_BEGIN_DECLS
 #define INDEXSTORE_END_DECLS
 #endif
 
 #ifndef INDEXSTORE_PUBLIC
 #if defined(_MSC_VER)
+#ifdef _INDEXSTORE_LIB_
+  #define INDEXSTORE_PUBLIC __declspec(dllexport)
+#else
   #define INDEXSTORE_PUBLIC __declspec(dllimport)
+#endif
 #else
 #define INDEXSTORE_PUBLIC
 #endif
 #endif
 
 #ifndef __has_feature
 #define __has_feature(x) 0
 #endif

 
 typedef void *indexstore_t;
 
 INDEXSTORE_PUBLIC indexstore_t
 indexstore_store_create(const char *store_path, indexstore_error_t *error);
 
 INDEXSTORE_PUBLIC void indexstore_store_dispose(indexstore_t store);
 
-#if INDEXSTORE_HAS_BLOCKS
 INDEXSTORE_PUBLIC bool indexstore_store_units_apply(
     indexstore_t, unsigned sorted,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_string_ref_t unit_name));
+#else
+    llvm::function_ref<bool(indexstore_string_ref_t)> applier);
 #endif
 
 typedef void *indexstore_unit_event_notification_t;
 typedef void *indexstore_unit_event_t;
 
 INDEXSTORE_PUBLIC size_t indexstore_unit_event_notification_get_events_count(
     indexstore_unit_event_notification_t notification);
 

 indexstore_unit_event_get_modification_time(indexstore_unit_event_t event);
 
 #if INDEXSTORE_HAS_BLOCKS
 typedef void (^indexstore_unit_event_handler_t)(
     indexstore_unit_event_notification_t);
 
 INDEXSTORE_PUBLIC void indexstore_store_set_unit_event_handler(
     indexstore_t store, indexstore_unit_event_handler_t handler);
+#else
+typedef std::function<void(indexstore_unit_event_notification_t)>
+indexstore_unit_event_handler_t;
+
+INDEXSTORE_PUBLIC void indexstore_store_set_unit_event_handler(
+    indexstore_t store,
+    llvm::function_ref<void(indexstore_unit_event_notification_t)> handler);
 #endif
 
 typedef struct {
   /// If true, \c indexstore_store_start_unit_event_listening will block until
   /// the initial set of units is passed to the unit event handler, otherwise
   /// the function will return and the initial set will be passed
   /// asynchronously.
   bool wait_initial_sync;

 INDEXSTORE_PUBLIC indexstore_symbol_t
 indexstore_symbol_relation_get_symbol(indexstore_symbol_relation_t relation);
 
 typedef void *indexstore_occurrence_t;
 
 INDEXSTORE_PUBLIC indexstore_symbol_t
 indexstore_occurrence_get_symbol(indexstore_occurrence_t occur);
 
-#if INDEXSTORE_HAS_BLOCKS
 INDEXSTORE_PUBLIC bool indexstore_occurrence_relations_apply(
     indexstore_occurrence_t occur,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_symbol_relation_t relation));
+#else
+    llvm::function_ref<bool(indexstore_symbol_relation_t)> applier);
 #endif
 
 INDEXSTORE_PUBLIC uint64_t
 indexstore_occurrence_get_roles(indexstore_occurrence_t occur);
 
 INDEXSTORE_PUBLIC void
 indexstore_occurrence_get_line_col(indexstore_occurrence_t occur,
                                    unsigned *line, unsigned *column);
 
 typedef void *indexstore_record_reader_t;
 
 INDEXSTORE_PUBLIC indexstore_record_reader_t indexstore_record_reader_create(
     indexstore_t store, const char *record_name, indexstore_error_t *error);
 
 INDEXSTORE_PUBLIC void
 indexstore_record_reader_dispose(indexstore_record_reader_t reader);
 
-#if INDEXSTORE_HAS_BLOCKS
 /// Goes through the symbol data and passes symbols to \c receiver, for the
 /// symbol data that \c filter returns true on.
 ///
 /// This allows allocating memory only for the record symbols that the caller is
 /// interested in.
 INDEXSTORE_PUBLIC bool indexstore_record_reader_search_symbols(
     indexstore_record_reader_t reader,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^filter)(indexstore_symbol_t symbol, bool *stop),
     void (^receiver)(indexstore_symbol_t symbol));
+#else
+    llvm::function_ref<bool(indexstore_symbol_t, bool *)> filter,
+    llvm::function_ref<void(indexstore_symbol_t)> receiver);
+#endif
 
 /// \param nocache if true, avoids allocating memory for the symbols.
 /// Useful when the caller does not intend to keep \c indexstore_record_reader_t
 /// for more queries.
 INDEXSTORE_PUBLIC bool indexstore_record_reader_symbols_apply(
     indexstore_record_reader_t reader, bool nocache,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_symbol_t symbol));
+#else
+    llvm::function_ref<bool(indexstore_symbol_t)> applier);
+#endif
 
 INDEXSTORE_PUBLIC bool indexstore_record_reader_occurrences_apply(
     indexstore_record_reader_t reader,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_occurrence_t occur));
+#else
+    llvm::function_ref<bool(indexstore_occurrence_t)> applier);
+#endif
 
 INDEXSTORE_PUBLIC bool indexstore_record_reader_occurrences_in_line_range_apply(
     indexstore_record_reader_t reader, unsigned line_start, unsigned line_count,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_occurrence_t occur));
+#else
+    llvm::function_ref<bool(indexstore_occurrence_t)> applier);
+#endif
 
 /// \param symbols if non-zero \c symbols_count, indicates the list of symbols
 /// that we want to get occurrences for. An empty array indicates that we want
 /// occurrences for all symbols.
 /// \param related_symbols Same as \c symbols but for related symbols.
 INDEXSTORE_PUBLIC bool indexstore_record_reader_occurrences_of_symbols_apply(
     indexstore_record_reader_t reader, indexstore_symbol_t *symbols,
     size_t symbols_count, indexstore_symbol_t *related_symbols,
     size_t related_symbols_count,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_occurrence_t occur));
+#else
+    llvm::function_ref<bool(indexstore_occurrence_t)> applier);
 #endif
 
 typedef void *indexstore_unit_reader_t;
 
 INDEXSTORE_PUBLIC indexstore_unit_reader_t indexstore_unit_reader_create(
     indexstore_t store, const char *unit_name, indexstore_error_t *error);
 
 INDEXSTORE_PUBLIC void

 indexstore_unit_include_get_source_path(indexstore_unit_include_t dep);
 
 INDEXSTORE_PUBLIC indexstore_string_ref_t
 indexstore_unit_include_get_target_path(indexstore_unit_include_t dep);
 
 INDEXSTORE_PUBLIC unsigned
 indexstore_unit_include_get_source_line(indexstore_unit_include_t dep);
 
-#if INDEXSTORE_HAS_BLOCKS
 INDEXSTORE_PUBLIC bool indexstore_unit_reader_dependencies_apply(
     indexstore_unit_reader_t reader,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_unit_dependency_t dep));
+#else
+    llvm::function_ref<bool(indexstore_unit_dependency_t)> applier);
+#endif
 
 INDEXSTORE_PUBLIC bool indexstore_unit_reader_includes_apply(
     indexstore_unit_reader_t reader,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_unit_include_t include));
-
+#else
+    llvm::function_ref<bool(indexstore_unit_include_t)> applier);
 #endif
 
 INDEXSTORE_END_DECLS
 
 #endif

lib/Index/IndexUnitReader.cpp

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Bitcode/BitstreamReader.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
+#if !defined(_MSC_VER) && !defined(__MINGW32__)
 #include <unistd.h>
+#else
+#include <io.h>
+#endif
 
 using namespace clang;
 using namespace clang::index;
 using namespace clang::index::store;
 using namespace llvm;
 
 namespace {
 

tools/IndexStore/CMakeLists.txt

 set(ENABLE_SHARED SHARED)
 
 if(WIN32)
   set(output_name "libIndexStore")
 else()
   set(output_name "IndexStore")
 endif()
 
-# FIXME: needs to be ported to non-Apple platforms.
-if(APPLE)
-
 add_clang_library(IndexStore ${ENABLE_SHARED} ${ENABLE_STATIC}
   OUTPUT_NAME ${output_name}
   ${SOURCES}
 
   LINK_LIBS
   ${LIBS}
 
   LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   Core
   Support
   )
 
 set(INDEXSTORE_LIBRARY_VERSION "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}")
 
 if(ENABLE_SHARED)
   if(WIN32)
     set_target_properties(IndexStore
       PROPERTIES
       VERSION ${INDEXSTORE_LIBRARY_VERSION}
-      DEFINE_SYMBOL _CINDEX_LIB_)
+      DEFINE_SYMBOL _INDEXSTORE_LIB_)
   elseif(APPLE)
     set(INDEXSTORE_LINK_FLAGS " -Wl,-compatibility_version -Wl,1")
     set(INDEXSTORE_LINK_FLAGS "${INDEXSTORE_LINK_FLAGS} -Wl,-current_version -Wl,${INDEXSTORE_LIBRARY_VERSION}")
 
     check_include_files("CoreServices/CoreServices.h" HAVE_CORESERVICES_H)
     if(HAVE_CORESERVICES_H)
       set(INDEXSTORE_LINK_FLAGS "${INDEXSTORE_LINK_FLAGS} -framework CoreServices")
     endif()
 
     set_property(TARGET IndexStore APPEND_STRING PROPERTY
                  LINK_FLAGS ${INDEXSTORE_LINK_FLAGS})
   else()
     set_target_properties(IndexStore
       PROPERTIES
       VERSION ${INDEXSTORE_LIBRARY_VERSION}
-      DEFINE_SYMBOL _CINDEX_LIB_)
+      DEFINE_SYMBOL _INDEXSTORE_LIB_)
   endif()
 endif()
 
 if (LLVM_INSTALL_TOOLCHAIN_ONLY)
   install(TARGETS IndexStore
     COMPONENT IndexStore
     LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
     ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}

 
 install(DIRECTORY ../../include/indexstore
   COMPONENT IndexStore
   DESTINATION "${INDEXSTORE_HEADERS_INSTALL_DESTINATION}"
   FILES_MATCHING
   PATTERN "*.h"
   PATTERN ".svn" EXCLUDE
   )
-endif()

tools/IndexStore/IndexStore.cpp

 #include "clang/Index/IndexDataStoreSymbolUtils.h"
 #include "clang/Index/IndexRecordReader.h"
 #include "clang/Index/IndexUnitReader.h"
 #include "clang/Index/IndexUnitWriter.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Chrono.h"
+
+#if INDEXSTORE_HAS_BLOCKS
 #include <Block.h>
+#endif
 
 using namespace clang;
 using namespace clang::index;
 using namespace llvm;
 
 static indexstore_string_ref_t toIndexStoreString(StringRef str) {
   return indexstore_string_ref_t{str.data(), str.size()};
 }
indexstore_t indexstore_store_create(const char *store_path,
   }
   return store.release();
 }
 
 void indexstore_store_dispose(indexstore_t store) {
   delete static_cast<IndexDataStore *>(store);
 }
 
-#if INDEXSTORE_HAS_BLOCKS
 bool indexstore_store_units_apply(
     indexstore_t c_store, unsigned sorted,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_string_ref_t unit_name)) {
+#else
+    llvm::function_ref<bool(indexstore_string_ref_t)> applier) {
+#endif
   IndexDataStore *store = static_cast<IndexDataStore *>(c_store);
   return store->foreachUnitName(sorted, [&](StringRef unitName) -> bool {
     return applier(toIndexStoreString(unitName));
   });
 }
 
 size_t indexstore_unit_event_notification_get_events_count(
     indexstore_unit_event_notification_t c_evtnote) {
if (!blk_handler) {
     return;
   }
 
   class BlockWrapper {
     indexstore_unit_event_handler_t blk_handler;
 
   public:
     BlockWrapper(indexstore_unit_event_handler_t handler) {
-      blk_handler = Block_copy(handler);
+      blk_handler = handler;
     }
     BlockWrapper(const BlockWrapper &other) {
-      blk_handler = Block_copy(other.blk_handler);
+      blk_handler = other.blk_handler;
     }
-    ~BlockWrapper() { Block_release(blk_handler); }
 
     void operator()(indexstore_unit_event_notification_t evt_note) const {
       blk_handler(evt_note);
     }
   };
 
   BlockWrapper handler(blk_handler);
 
   store->setUnitEventHandler(
       [handler](IndexDataStore::UnitEventNotification evtNote) {
         handler(&evtNote);
       });
 }
-#endif
 
 bool indexstore_store_start_unit_event_listening(
     indexstore_t c_store, indexstore_unit_event_listen_options_t *client_opts,
     size_t listen_options_struct_size, indexstore_error_t *c_error) {
   IndexDataStore *store = static_cast<IndexDataStore *>(c_store);
   indexstore_unit_event_listen_options_t listen_opts;
   memset(&listen_opts, 0, sizeof(listen_opts));
   unsigned clientOptSize = listen_options_struct_size < sizeof(listen_opts)
indexstore_symbol_relation_get_symbol(indexstore_symbol_relation_t sym_rel) {
   return (indexstore_symbol_t) static_cast<IndexRecordRelation *>(sym_rel)->Dcl;
 }
 
 indexstore_symbol_t
 indexstore_occurrence_get_symbol(indexstore_occurrence_t occur) {
   return (indexstore_symbol_t) static_cast<IndexRecordOccurrence *>(occur)->Dcl;
 }
 
-#if INDEXSTORE_HAS_BLOCKS
 bool indexstore_occurrence_relations_apply(
     indexstore_occurrence_t occur,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_symbol_relation_t symbol_rel)) {
+#else
+    llvm::function_ref<bool(indexstore_symbol_relation_t)> applier) {
+#endif
   auto *recOccur = static_cast<IndexRecordOccurrence *>(occur);
   for (auto &rel : recOccur->Relations) {
     if (!applier(&rel))
       return false;
   }
   return true;
 }
-#endif
 
 uint64_t indexstore_occurrence_get_roles(indexstore_occurrence_t occur) {
   return static_cast<IndexRecordOccurrence *>(occur)->Roles;
 }
 
 void indexstore_occurrence_get_line_col(indexstore_occurrence_t occur,
                                         unsigned *line, unsigned *column) {
   auto *recOccur = static_cast<IndexRecordOccurrence *>(occur);
indexstore_record_reader_create(indexstore_t c_store, const char *record_name,
   return reader.release();
 }
 
 void indexstore_record_reader_dispose(indexstore_record_reader_t rdr) {
   auto *reader = static_cast<IndexRecordReader *>(rdr);
   delete reader;
 }
 
-#if INDEXSTORE_HAS_BLOCKS
 /// Goes through the symbol data and passes symbols to \c receiver, for the
 /// symbol data that \c filter returns true on.
 ///
 /// This allows allocating memory only for the record symbols that the caller is
 /// interested in.
 bool indexstore_record_reader_search_symbols(
     indexstore_record_reader_t rdr,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^filter)(indexstore_symbol_t symbol, bool *stop),
     void (^receiver)(indexstore_symbol_t symbol)) {
+#else
+    llvm::function_ref<bool(indexstore_symbol_t, bool *)> filter,
+    llvm::function_ref<void(indexstore_symbol_t)> receiver) {
+#endif
   auto *reader = static_cast<IndexRecordReader *>(rdr);
 
   auto filterFn =
       [&](const IndexRecordDecl &D) -> IndexRecordReader::DeclSearchReturn {
     bool stop = false;
     bool accept = filter((indexstore_symbol_t)&D, &stop);
     return {accept, !stop};
   };
   auto receiverFn = [&](const IndexRecordDecl *D) {
     receiver((indexstore_symbol_t)D);
   };
 
   return reader->searchDecls(filterFn, receiverFn);
 }
 
 bool indexstore_record_reader_symbols_apply(
     indexstore_record_reader_t rdr, bool nocache,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_symbol_t symbol)) {
+#else
+    llvm::function_ref<bool(indexstore_symbol_t)> applier) {
+#endif
   auto *reader = static_cast<IndexRecordReader *>(rdr);
   auto receiverFn = [&](const IndexRecordDecl *D) -> bool {
     return applier((indexstore_symbol_t)D);
   };
   return reader->foreachDecl(nocache, receiverFn);
 }
 
 bool indexstore_record_reader_occurrences_apply(
     indexstore_record_reader_t rdr,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_occurrence_t occur)) {
+#else
+    llvm::function_ref<bool(indexstore_occurrence_t)> applier) {
+#endif
   auto *reader = static_cast<IndexRecordReader *>(rdr);
   auto receiverFn = [&](const IndexRecordOccurrence &RO) -> bool {
     return applier((indexstore_occurrence_t)&RO);
   };
   return reader->foreachOccurrence(receiverFn);
 }
 
 bool indexstore_record_reader_occurrences_in_line_range_apply(
     indexstore_record_reader_t rdr, unsigned line_start, unsigned line_count,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_occurrence_t occur)) {
+#else
+    llvm::function_ref<bool(indexstore_occurrence_t)> applier) {
+#endif
   auto *reader = static_cast<IndexRecordReader *>(rdr);
   auto receiverFn = [&](const IndexRecordOccurrence &RO) -> bool {
     return applier((indexstore_occurrence_t)&RO);
   };
   return reader->foreachOccurrenceInLineRange(line_start, line_count,
                                               receiverFn);
 }
 
 /// \param symbols if non-zero \c symbols_count, indicates the list of symbols
 /// that we want to get occurrences for. An empty array indicates that we want
 /// occurrences for all symbols.
 /// \param related_symbols Same as \c symbols but for related symbols.
 bool indexstore_record_reader_occurrences_of_symbols_apply(
     indexstore_record_reader_t rdr, indexstore_symbol_t *symbols,
     size_t symbols_count, indexstore_symbol_t *related_symbols,
     size_t related_symbols_count,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_occurrence_t occur)) {
+#else
+    llvm::function_ref<bool(indexstore_occurrence_t)> applier) {
+#endif
   auto *reader = static_cast<IndexRecordReader *>(rdr);
   auto receiverFn = [&](const IndexRecordOccurrence &RO) -> bool {
     return applier((indexstore_occurrence_t)&RO);
   };
   return reader->foreachOccurrence(
       {(IndexRecordDecl **)symbols, symbols_count},
       {(IndexRecordDecl **)related_symbols, related_symbols_count}, receiverFn);
 }
-#endif
 
 size_t indexstore_store_get_unit_name_from_output_path(indexstore_t store,
                                                        const char *output_path,
                                                        char *name_buf,
                                                        size_t buf_size) {
   SmallString<256> unitName;
   IndexUnitWriter::getUnitNameForAbsoluteOutputFile(output_path, unitName);
   size_t nameLen = unitName.size();
-  strlcpy(name_buf, unitName.c_str(), buf_size);
+  strncpy(name_buf, unitName.c_str(), buf_size);
   return nameLen;
 }
 
 bool indexstore_store_get_unit_modification_time(indexstore_t c_store,
                                                  const char *unit_name,
                                                  int64_t *seconds,
                                                  int64_t *nanoseconds,
                                                  indexstore_error_t *c_error) {

 }
 
 unsigned
 indexstore_unit_include_get_source_line(indexstore_unit_include_t c_inc) {
   auto inc = static_cast<const IndexUnitReader::IncludeInfo *>(c_inc);
   return inc->SourceLine;
 }
 
-#if INDEXSTORE_HAS_BLOCKS
 bool indexstore_unit_reader_dependencies_apply(
     indexstore_unit_reader_t rdr,
+#if INDEXSTORE_HAS_BLOCKS
     bool (^applier)(indexstore_unit_dependency_t)) {
+#else
+    llvm::function_ref<bool(indexstore_unit_dependency_t)> applier) {
+#endif
   auto reader = static_cast<IndexUnitReader *>(rdr);
   return reader->foreachDependency(
       [&](const IndexUnitReader::DependencyInfo &depInfo) -> bool {
         return applier((void *)&depInfo);
       });
 }
 
 bool indexstore_unit_reader_includes_apply(
-    indexstore_unit_reader_t rdr, bool (^applier)(indexstore_unit_include_t)) {
+    indexstore_unit_reader_t rdr,
+#if INDEXSTORE_HAS_BLOCKS
+    bool (^applier)(indexstore_unit_include_t)) {
+#else
+    llvm::function_ref<bool(indexstore_unit_include_t)> applier) {
+#endif
   auto reader = static_cast<IndexUnitReader *>(rdr);
   return reader->foreachInclude(
       [&](const IndexUnitReader::IncludeInfo &incInfo) -> bool {
         return applier((void *)&incInfo);
       });
 }
-#endif

tools/c-index-test/CMakeLists.txt

 include(CheckIncludeFiles)
 
 set(LLVM_LINK_COMPONENTS
   support
 )
 
 add_clang_executable(c-index-test
   c-index-test.c
   core_main.cpp
   JSONAggregation.cpp
   )
 
 set(INDEXSTORE_LIB)
 set(CINDEXTEST_LIBS)
-if(APPLE)
-  set(INDEXSTORE_LIB IndexStore)
-endif()
 
 if(NOT MSVC)
   set_property(
     SOURCE c-index-test.c
     PROPERTY COMPILE_FLAGS "-std=gnu89"
     )
 endif()
 

tools/c-index-test/JSONAggregation.cpp

 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace clang::index;
 using namespace indexstore;
 using namespace llvm;
 
-#if INDEXSTORE_HAS_BLOCKS
-
 namespace {
 
 typedef size_t FilePathIndex;
 typedef size_t RecordIndex;
 typedef size_t SymbolIndex;
 
 struct UnitSourceInfo {
   FilePathIndex FilePath;
bool index::aggregateDataAsJSON(StringRef StorePath, raw_ostream &OS) {
   // is going to exit when we are done.
   Aggregator *aggregator = new Aggregator(std::move(dataStore));
   bool err = aggregator->process();
   if (err)
     return true;
   aggregator->dumpJSON(OS);
   return false;
 }
-
-#else
-
-bool index::aggregateDataAsJSON(StringRef StorePath, raw_ostream &OS) {
-  return true;
-}
-#endif

tools/c-index-test/core_main.cpp

static bool printSourceUnit(ArrayRef<const char *> Args, bool IndexLocals,
 
   auto PCHContainerOps = std::make_shared<PCHContainerOperations>();
   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
       std::move(CInvok), PCHContainerOps, Diags, IndexAction.get()));
 
   return !Unit;
 }
 
-#if INDEXSTORE_HAS_BLOCKS
-
 //===----------------------------------------------------------------------===//
 // Print Record
 //===----------------------------------------------------------------------===//
 
 static void printSymbol(const IndexRecordDecl &Rec, raw_ostream &OS);
 static void printSymbol(const IndexRecordOccurrence &Rec, raw_ostream &OS);
 
 static int printRecord(StringRef Filename, raw_ostream &OS) {
bool Success =
         bool err = printStoreUnit(Store, UnitName, OS);
         OS << '\n';
         return !err;
       });
 
   return !Success;
 }
 
-#else
-
-static int printUnit(StringRef Filename, raw_ostream &OS) { return 1; }
-
-static int printStoreUnits(StringRef StorePath, raw_ostream &OS) { return 1; }
-
-static int printStoreFileRecord(StringRef storePath, StringRef filePath,
-                                Optional<unsigned> lineStart,
-                                unsigned lineCount, raw_ostream &OS) {
-  return 1;
-}
-
-#endif
-
 //===----------------------------------------------------------------------===//
 // Helper Utils
 //===----------------------------------------------------------------------===//
 
 static void printSymbolInfo(SymbolInfo SymInfo, raw_ostream &OS) {
   OS << getSymbolKindString(SymInfo.Kind);
   if (SymInfo.SubKind != SymbolSubKind::None)
     OS << '/' << getSymbolSubKindString(SymInfo.SubKind);
static void printSymbolNameAndUSR(const Decl *D, ASTContext &Ctx,
   SmallString<256> USRBuf;
   if (generateUSRForDecl(D, USRBuf)) {
     OS << "<no-usr>";
   } else {
     OS << USRBuf;
   }
 }
 
-#if INDEXSTORE_HAS_BLOCKS
-
 static void printSymbol(const IndexRecordDecl &Rec, raw_ostream &OS) {
   printSymbolInfo(Rec.SymInfo, OS);
   OS << " | ";
 
   if (Rec.Name.empty())
     OS << "<no-name>";
   else
     OS << Rec.Name;
if (Sym.getUSR().empty())
       OS << "<no-usr>";
     else
       OS << Sym.getUSR();
     OS << '\n';
     return true;
   });
 }
 
-#else
-
-static int printRecord(StringRef Filename, raw_ostream &OS) { return 1; }
-static int printStoreRecords(StringRef StorePath, raw_ostream &OS) { return 1; }
-
-#endif
-
 static int watchDirectory(StringRef dirPath) {
   raw_ostream &OS = outs();
   auto receiver = [&](ArrayRef<DirectoryWatcher::Event> Events,
                       bool isInitial) {
     for (auto evt : Events) {
       switch (evt.Kind) {
       case DirectoryWatcher::EventKind::Added:
         OS << "added: ";
if (options::Action == ActionType::PrintUnit) {
     }
 
     if (sys::fs::is_directory(options::InputFiles[0]))
       return printStoreUnits(options::InputFiles[0], outs());
     else
       return printUnit(options::InputFiles[0], outs());
   }
 
-#if INDEXSTORE_HAS_BLOCKS
   if (options::Action == ActionType::PrintStoreFormatVersion) {
     outs() << indexstore::IndexStore::formatVersion() << '\n';
   }
-#endif
 
   if (options::Action == ActionType::AggregateAsJSON) {
     if (options::InputFiles.empty()) {
       errs() << "error: missing input data store directory\n";
       return 1;
     }
     StringRef storePath = options::InputFiles[0];
     if (options::OutputFile.empty())