[interpreter] new function TInterpreter::SetIncludePath

core/meta/inc/TInterpreter.h

@@ -137,6 +137,7 @@ class TInterpreter : public TNamed {
    virtual ~TInterpreter() { }
 
    virtual void     AddIncludePath(const char *path) = 0;
+   virtual void     SetIncludePath(const char *path) = 0;
    virtual void    *SetAutoLoadCallBack(void* /*cb*/) { return nullptr; }
    virtual void    *GetAutoLoadCallBack() const { return nullptr; }
    virtual Int_t    AutoLoad(const char *classname, Bool_t knowDictNotLoaded = kFALSE) = 0;

core/metacling/src/TCling.cxx

@@ -2683,6 +2683,23 @@ void TCling::AddIncludePath(const char *path)
    fInterpreter->AddIncludePath(sPath.Data());
 }
 
+////////////////////////////////////////////////////////////////////////////////
+/// \brief Replaces current list of directories with a single path in which the
+///        interpreter looks for include files.
+/// \param[in] path The path to the directory.
+/// \note Only one path item can be specified at a time, i.e. "path1:path2" is
+///       \b NOT supported.
+/// \warning Only the path to the directory should be specified, without
+///          prepending the \c -I prefix, i.e.
+///          <tt>gCling->AddIncludePath("/path/to/my/includes")</tt>. If the
+///          \c -I prefix is used it will be ignored.
+void TCling::SetIncludePath(const char *path)
+{
+   R__LOCKGUARD(gInterpreterMutex);
+   fInterpreter->ResetIncludePaths();
+   AddIncludePath(path);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 /// Visit all members over members, recursing over base classes.
 

core/metacling/src/TCling.h

@@ -195,6 +195,7 @@ class TCling final : public TInterpreter {
    TCling(const char* name, const char* title, const char* const argv[], void *interpLibHandle);
 
    void    AddIncludePath(const char* path) final;
+   void    SetIncludePath(const char* path) final;
    void   *GetAutoLoadCallBack() const final { return fAutoLoadCallBack; }
    void   *SetAutoLoadCallBack(void* cb) final { void* prev = fAutoLoadCallBack; fAutoLoadCallBack = cb; return prev; }
    Int_t   AutoLoad(const char *classname, Bool_t knowDictNotLoaded = kFALSE) final;

interpreter/cling/include/cling/Interpreter/Interpreter.h

@@ -438,12 +438,16 @@ namespace cling {
     ///
     bool isUniqueName(llvm::StringRef name);
 
-    ///\brief Adds multiple include paths separated by a delimter.
+    ///\brief Adds multiple include paths separated by a delimiter.
     ///
     ///\param[in] PathsStr - Path(s)
     ///\param[in] Delim - Delimiter to separate paths or NULL if a single path
     ///
     void AddIncludePaths(llvm::StringRef PathsStr, const char* Delim = ":");
+
+    ///\brief Unsets preexisting include paths.
+    ///
+    void ResetIncludePaths();
 
     ///\brief Adds a single include path (-I).
     ///

interpreter/cling/lib/Interpreter/Interpreter.cpp

@@ -651,6 +651,28 @@ namespace cling {
     if (m_CUDACompiler)
       m_CUDACompiler->getPTXInterpreter()->AddIncludePaths(PathStr, Delm);
   }
+
+  void Interpreter::ResetIncludePaths() {
+    CompilerInstance* CI = getCI();
+    HeaderSearchOptions& HOpts = CI->getHeaderSearchOpts();
+
+    Preprocessor& PP = CI->getPreprocessor();
+    SourceManager& SM = PP.getSourceManager();
+    FileManager& FM = SM.getFileManager();
+    HeaderSearch& HSearch = PP.getHeaderSearchInfo();
+    const bool isFramework = false;
+    // Remove old entries from Preprocessor
+    size_t Idx = HOpts.UserEntries.size();
+    for (const size_t N = HOpts.UserEntries.size(); Idx < N; ++Idx) {
+      const HeaderSearchOptions::Entry& E = HOpts.UserEntries[Idx];
+      if (auto DE = FM.getOptionalDirectoryRef(E.Path))
+        HSearch.RemoveSearchPath(DirectoryLookup(*DE, SrcMgr::C_User, isFramework),
+                              E.Group == frontend::Angled);
+    }
+    HOpts.ResetPaths();
+    if (m_CUDACompiler)
+      m_CUDACompiler->getPTXInterpreter()->ResetIncludePaths();
+  }
 
   void Interpreter::AddIncludePath(llvm::StringRef PathsStr) {
     return AddIncludePaths(PathsStr, nullptr);

interpreter/llvm-project/clang/include/clang/Lex/HeaderSearch.h

@@ -375,7 +375,10 @@ class HeaderSearch {
 
   /// Add an additional search path.
   void AddSearchPath(const DirectoryLookup &dir, bool isAngled);
-
+
+  /// Remove search path.
+  void RemoveSearchPath(const DirectoryLookup &dir, bool isAngled);
+
   /// Add an additional system search path.
   void AddSystemSearchPath(const DirectoryLookup &dir) {
     SearchDirs.push_back(dir);

interpreter/llvm-project/clang/include/clang/Lex/HeaderSearchOptions.h

@@ -284,6 +284,11 @@ class HeaderSearchOptions {
                bool IsFramework, bool IgnoreSysRoot) {
     UserEntries.emplace_back(Path, Group, IsFramework, IgnoreSysRoot);
   }
+
+  /// ResetPaths - Removes all paths from the user entries list.
+  void ResetPaths() {
+    UserEntries.clear();
+  }
 
   /// AddSystemHeaderPrefix - Override whether \#include directives naming a
   /// path starting with \p Prefix should be considered as naming a system

interpreter/llvm-project/clang/lib/Lex/HeaderSearch.cpp

@@ -127,6 +127,16 @@ void HeaderSearch::AddSearchPath(const DirectoryLookup &dir, bool isAngled) {
   SystemDirIdx++;
 }
 
+void HeaderSearch::RemoveSearchPath(const DirectoryLookup &dir, bool isAngled) {
+  auto position = std::find(SearchDirs.begin(), SearchDirs.end(), dir);
+  auto idx = std::distance(SearchDirs.begin(), position);
+  SearchDirs.erase(position);
+  SearchDirsUsage.erase(SearchDirsUsage.begin() + idx);
+  if (!isAngled)
+    AngledDirIdx--;
+  SystemDirIdx--;
+}
+
 std::vector<bool> HeaderSearch::computeUserEntryUsage() const {
   std::vector<bool> UserEntryUsage(HSOpts->UserEntries.size());
   for (unsigned I = 0, E = SearchDirsUsage.size(); I < E; ++I) {