Update the threads comment in config.hh w/ the actual core count used

.appveyor.yml

@@ -15,7 +15,7 @@ install:
   - 7z x llvm.tar
   - git submodule update --init --recursive
 build_script:
-  - cmake -G"Visual Studio 15 2017 Win64" -H. -Bbuild -DCMAKE_BUILD_TYPE=Release -DSYSTEM_CLANG=ON -DCLANG_ROOT=C:\projects\ccls\llvm+clang-7.0.0-win64-msvc-release
+  - cmake -G"Visual Studio 15 2017 Win64" -H. -Bbuild -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH=C:\projects\ccls\llvm+clang-7.0.0-win64-msvc-release
   - cmake --build build --target ccls --config Release
 
 artifacts:

.github/ISSUE_TEMPLATE

@@ -0,0 +1,36 @@
+Here are some things you should try before filing a bug report:
+
++ For client issues related to [emacs-ccls](https://github.com/MaskRay/emacs-ccls) or [vscode-ccls](https://github.com/MaskRay/vscode-ccls), report in their own repository.
++ For build problems, check https://github.com/MaskRay/ccls/wiki/Build
++ Check https://github.com/MaskRay/ccls/wiki/Debugging
++ Check [the FAQ](https://github.com/MaskRay/ccls/wiki/FAQ) to see if your issue is mentioned.
+
+If none of those help, remove this section and fill out the four sections in the template below.
+
+---
+
+### Observed behavior
+
+Describe what happened. Any aids you can include (that you think could be relevant) are a tremendous help.
+
+* `compile_commands.json` or `.ccls` ([wiki/Project-Setup](https://github.com/MaskRay/ccls/wiki/Project-Setup))
+* Reduce to A minimal set of `.c` `.cc` `.h` `.hh` files that can still demonstrate the issue.
+* Consider a screencast gif.
+
+### Expected behavior
+
+Describe what you expected to happen.
+
+### Steps to reproduce
+
+1. Select these example steps,
+2. Delete them,
+3. And replace them with precise steps to reproduce your issue.
+
+### System information
+
+* ccls version (`git describe --tags --long`): 
+* clang version: 
+* OS: 
+* Editor: 
+* Language client (and version): 

.gitignore

@@ -3,3 +3,4 @@ build
 debug
 release
 /compile_commands.json
+!.github/

CMakeLists.txt

@@ -1,46 +1,34 @@
 cmake_minimum_required(VERSION 3.8)
 project(ccls LANGUAGES CXX)
 
-list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/)
-include(DefaultCMakeBuildType)
-
-# Required Clang version
-set(CLANG_DOWNLOAD_LOCATION ${CMAKE_BINARY_DIR}
-    CACHE STRING "Downloaded Clang location")
-option(SYSTEM_CLANG "Use system installation of Clang instead of \
-       downloading Clang" OFF)
-option(ASAN "Compile with address sanitizers" OFF)
-option(LLVM_ENABLE_RTTI "-fno-rtti if OFF. This should match LLVM libraries" OFF)
-option(CLANG_USE_BUNDLED_LIBC++ "Let Clang use bundled libc++" OFF)
-option(USE_SHARED_LLVM "Link against libLLVM.so instead separate LLVM{Option,Support,...}" OFF)
+option(USE_SYSTEM_RAPIDJSON "Use system RapidJSON instead of the git submodule if exists" ON)
 
 # Sources for the executable are specified at end of CMakeLists.txt
 add_executable(ccls "")
 
-### Compile options
+### Default build type
+
+set(DEFAULT_CMAKE_BUILD_TYPE Release)
 
-# CMake default compile flags:
-# MSVC + Clang(Windows):
-#   debug: /MDd /Zi /Ob0 /Od /RTC1
-#   release: /MD /O2 /Ob2 /DNDEBUG
-# GCC + Clang(Linux):
-#   debug: -g
-#   release: -O3 -DNDEBUG
+# CMAKE_BUILD_TYPE is not available if a multi-configuration generator is used
+# (eg Visual Studio generators)
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  message(STATUS "Setting build type to '${DEFAULT_CMAKE_BUILD_TYPE}' as none \
+was specified.")
+  set(CMAKE_BUILD_TYPE ${DEFAULT_CMAKE_BUILD_TYPE}
+      CACHE STRING "Choose the type of build." FORCE)
+
+  # Set the possible values of build type for cmake-gui
+  set_property(CACHE CMAKE_BUILD_TYPE
+               PROPERTY STRINGS Debug Release MinSizeRel RelWithDebInfo)
+endif()
+
+### Compile options
 
 # Enable C++17 (Required)
 set_property(TARGET ccls PROPERTY CXX_STANDARD 17)
 set_property(TARGET ccls PROPERTY CXX_STANDARD_REQUIRED ON)
-# Disable gnu extensions except for Cygwin which needs them to build properly
-if(NOT CYGWIN)
-  set_property(TARGET ccls PROPERTY CXX_EXTENSIONS OFF)
-endif()
-
-if(NOT LLVM_ENABLE_RTTI)
-  # releases.llvm.org libraries are compiled with -fno-rtti
-  # The mismatch between lib{clang,LLVM}* and ccls can make libstdc++ std::make_shared return nullptr
-  # _Sp_counted_ptr_inplace::_M_get_deleter
-  target_compile_options(ccls PRIVATE -fno-rtti)
-endif()
+set_property(TARGET ccls PROPERTY CXX_EXTENSIONS OFF)
 
 # CMake sets MSVC for both MSVC and Clang(Windows)
 if(MSVC)
@@ -76,44 +64,49 @@ else()
     target_compile_options(ccls PRIVATE
                            $<$<CONFIG:Debug>:-fno-limit-debug-info>)
   endif()
-
-  if(ASAN)
-    target_compile_options(ccls PRIVATE -fsanitize=address,undefined)
-    # target_link_libraries also takes linker flags
-    target_link_libraries(ccls PRIVATE -fsanitize=address,undefined)
-  endif()
 endif()
 
-### Download Clang if required
-
-if(NOT SYSTEM_CLANG)
-  message(STATUS "Using downloaded Clang")
-
-  include(DownloadAndExtractClang)
-  download_and_extract_clang(${CLANG_DOWNLOAD_LOCATION})
-  # Used by FindClang
-  set(CLANG_ROOT ${DOWNLOADED_CLANG_DIR})
-
-  if(${CMAKE_CXX_COMPILER_ID} STREQUAL Clang AND CLANG_USE_BUNDLED_LIBC++)
-    message(STATUS "Using bundled libc++")
-    target_compile_options(ccls PRIVATE -nostdinc++ -cxx-isystem ${CLANG_ROOT}/include/c++/v1)
-    if(${CMAKE_SYSTEM_NAME} STREQUAL Linux)
-      # Don't use -stdlib=libc++ because while ccls is linked with libc++, bundled clang+llvm require libstdc++
-      target_link_libraries(ccls PRIVATE -L${CLANG_ROOT}/lib c++ c++abi)
+### Libraries
 
-      # FreeBSD defaults to -stdlib=libc++ and uses system libcxxrt.a
-    endif()
-  endif()
+find_package(Clang REQUIRED)
 
+if(CLANG_LINK_CLANG_DYLIB)
+  target_link_libraries(ccls PRIVATE clang-cpp)
 else()
-  message(STATUS "Using system Clang")
+  target_link_libraries(ccls PRIVATE
+    clangIndex
+    clangFormat
+    clangTooling
+    clangToolingInclusions
+    clangToolingCore
+    clangFrontend
+    clangParse
+    clangSerialization
+    clangSema
+    clangAST
+    clangLex
+    clangDriver
+    clangBasic
+  )
 endif()
 
-### Libraries
+if(LLVM_LINK_LLVM_DYLIB)
+  target_link_libraries(ccls PRIVATE LLVM)
+else()
+  # In llvm 7, clangDriver headers reference LLVMOption
+  target_link_libraries(ccls PRIVATE LLVMOption LLVMSupport)
+endif()
 
-# See cmake/FindClang.cmake
-find_package(Clang 6.0.0)
-target_link_libraries(ccls PRIVATE Clang::Clang)
+if(NOT LLVM_ENABLE_RTTI)
+  # releases.llvm.org libraries are compiled with -fno-rtti
+  # The mismatch between lib{clang,LLVM}* and ccls can make libstdc++ std::make_shared return nullptr
+  # _Sp_counted_ptr_inplace::_M_get_deleter
+  if(MSVC)
+    target_compile_options(ccls PRIVATE /GR-)
+  else()
+    target_compile_options(ccls PRIVATE -fno-rtti)
+  endif()
+endif()
 
 # Enable threading support
 set(THREADS_PREFER_PTHREAD_FLAG ON)
@@ -129,51 +122,56 @@ endif()
 
 ### Definitions
 
-target_compile_definitions(ccls PRIVATE
-                           DEFAULT_RESOURCE_DIRECTORY=R"\(${Clang_RESOURCE_DIR}\)")
+# Find Clang resource directory with Clang executable.
 
-### Includes
-
-target_include_directories(ccls PRIVATE src)
-target_include_directories(ccls SYSTEM PRIVATE
-                           third_party
-                           third_party/rapidjson/include)
+if(NOT CLANG_RESOURCE_DIR)
+  find_program(CLANG_EXECUTABLE clang)
+  if(NOT CLANG_EXECUTABLE)
+    message(FATAL_ERROR "clang executable not found.")
+  endif()
 
-### Install
+  execute_process(
+    COMMAND ${CLANG_EXECUTABLE} -print-resource-dir
+    RESULT_VARIABLE CLANG_FIND_RESOURCE_DIR_RESULT
+    OUTPUT_VARIABLE CLANG_RESOURCE_DIR
+    ERROR_VARIABLE CLANG_FIND_RESOURCE_DIR_ERROR
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
 
-install(TARGETS ccls RUNTIME DESTINATION bin)
+  if(CLANG_FIND_RESOURCE_DIR_RESULT)
+    message(FATAL_ERROR "Error retrieving Clang resource directory with Clang \
+            executable. Output:\n ${CLANG_FIND_RESOURCE_DIR_ERROR}")
+  endif()
+endif()
 
-if(NOT SYSTEM_CLANG AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL Windows)
+set_property(SOURCE src/utils.cc APPEND PROPERTY COMPILE_DEFINITIONS
+             CLANG_RESOURCE_DIRECTORY=R"\(${CLANG_RESOURCE_DIR}\)")
 
-  if(${CMAKE_SYSTEM_NAME} MATCHES Linux|FreeBSD)
-    set_property(TARGET ccls APPEND PROPERTY
-                 INSTALL_RPATH $ORIGIN/../lib)
-  elseif(${CMAKE_SYSTEM_NAME} STREQUAL Darwin)
-    set_property(TARGET ccls APPEND PROPERTY
-                 INSTALL_RPATH @loader_path/../lib)
-  endif()
+### Includes
 
-  file(GLOB LIBCLANG_PLUS_SYMLINKS
-       ${DOWNLOADED_CLANG_DIR}/lib/libclang.[so,dylib]*)
-  install(FILES ${LIBCLANG_PLUS_SYMLINKS} DESTINATION lib)
+if(USE_SYSTEM_RAPIDJSON)
+  find_package(RapidJSON QUIET)
 endif()
-
-# Allow running from build Windows by copying libclang.dll to build directory
-if(NOT SYSTEM_CLANG AND ${CMAKE_SYSTEM_NAME} STREQUAL Windows)
-  add_custom_command(TARGET ccls
-                     POST_BUILD
-                     COMMAND ${CMAKE_COMMAND} -E copy
-                     ${DOWNLOADED_CLANG_DIR}/bin/libclang.dll
-                     $<TARGET_FILE_DIR:ccls>
-                     COMMENT "Copying libclang.dll to build directory ...")
+if(NOT RapidJSON_FOUND)
+  set(RapidJSON_INCLUDE_DIRS third_party/rapidjson/include)
 endif()
 
-### Tools
+target_include_directories(ccls PRIVATE src)
+
+foreach(include_dir third_party
+    ${LLVM_INCLUDE_DIRS} ${CLANG_INCLUDE_DIRS} ${RapidJSON_INCLUDE_DIRS})
+  get_filename_component(include_dir_realpath ${include_dir} REALPATH)
+  # Don't add as SYSTEM if they are in CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES.
+  # It would reorder the system search paths and cause issues with libstdc++'s
+  # use of #include_next. See https://github.com/MaskRay/ccls/pull/417
+  if(NOT "${include_dir_realpath}" IN_LIST CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES)
+    target_include_directories(ccls SYSTEM PRIVATE ${include_dir})
+  endif()
+endforeach()
 
-# We use glob here since source files are already manually added with
-# target_sources further down
-file(GLOB SOURCES src/*.cc src/*.h src/serializers/*.cc src/serializers/*.h
-                  src/messages/*.h src/messages/*.cc)
+### Install
+
+install(TARGETS ccls RUNTIME DESTINATION bin)
 
 ### Sources
 
@@ -225,3 +223,22 @@ target_sources(ccls PRIVATE
   src/messages/textDocument_signatureHelp.cc
   src/messages/workspace.cc
 )
+
+### Obtain CCLS version information from Git
+### This only happens when cmake is re-run!
+
+if(NOT CCLS_VERSION)
+  execute_process(COMMAND git describe --tag --long HEAD
+    OUTPUT_VARIABLE CCLS_VERSION
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}")
+
+  if(NOT CCLS_VERSION)
+    set(CCLS_VERSION "<unknown>")
+  endif()
+endif()
+
+set_property(SOURCE src/main.cc APPEND PROPERTY
+             COMPILE_DEFINITIONS CCLS_VERSION=\"${CCLS_VERSION}\")
+set_property(SOURCE src/messages/initialize.cc APPEND PROPERTY
+             COMPILE_DEFINITIONS CCLS_VERSION=\"${CCLS_VERSION}\")

README.md

@@ -11,7 +11,7 @@ ccls, which originates from [cquery](https://github.com/cquery-project/cquery),
   * formatting
   * hierarchies: [call (caller/callee) hierarchy](src/messages/ccls_call.cc), [inheritance (base/derived) hierarchy](src/messages/ccls_inheritance.cc), [member hierarchy](src/messages/ccls_member.cc)
   * [symbol rename](src/messages/textDocument_rename.cc)
-  * [document symbols](src/messages/textDocument_documentSymbol.cc) and approximate search of [workspace symbol](src/messages/workspace_symbol.cc)
+  * [document symbols](src/messages/textDocument_document.cc) and approximate search of [workspace symbol](src/messages/workspace.cc)
   * [hover information](src/messages/textDocument_hover.cc)
   * diagnostics and code actions (clang FixIts)
   * semantic highlighting and preprocessor skipped regions
@@ -21,28 +21,9 @@ It has a global view of the code base and support a lot of cross reference featu
 It starts indexing the whole project (including subprojects if exist) parallelly when you open the first file, while the main thread can serve requests before the indexing is complete.
 Saving files will incrementally update the index.
 
-Compared with cquery, it makes use of C++17 features, has less third-party dependencies and slimmed-down code base.
-It leverages Clang C++ API as [clangd](https://clang.llvm.org/extra/clangd.html) does, which provides better support for code completion and diagnostics.
-Refactoring is a non-goal as it can be provided by clang-include-fixer and other Clang based tools.
-
-The comparison with cquery as noted on 2018-07-15:
-
-|             | cquery                         | ccls                         |
-|------------ |--------------------------------|------------------------------|
-| third_party | more                           | fewer                        |
-| C++         | C++14                          | C++17                        |
-| clang API   | libclang (C)                   | clang/llvm C++               |
-| Filesystem  | AbsolutePath + custom routines | llvm/Support                 |
-| index       | libclang                       | clangIndex, some enhancement |
-| pipeline    | index merge+id remapping       | simpler and more robust      |
-
-cquery has system include path detection (through running the compiler driver) while ccls uses clangDriver.
-
-# >>> [Getting started](../../wiki/Getting-started) (CLICK HERE) <<<
+# >>> [Getting started](../../wiki/Home) (CLICK HERE) <<<
 
 * [Build](../../wiki/Build)
-* [Emacs](../../wiki/Emacs)
-* [LanguageClient-neovim](../../wiki/LanguageClient-neovim)
 * [FAQ](../../wiki/FAQ)
 
-ccls can index itself (~180MiB RSS when ide, noted on 2018-09-01), FreeBSD, glibc, Linux, LLVM (~1800MiB RSS), musl (~60MiB RSS), ... with decent memory footprint. See [wiki/compile_commands.json](../../wiki/compile_commands.json) for examples.
+ccls can index itself (~180MiB RSS when idle, noted on 2018-09-01), FreeBSD, glibc, Linux, LLVM (~1800MiB RSS), musl (~60MiB RSS), ... with decent memory footprint. See [wiki/Project-Setup](../../wiki/Project-Setup) for examples.