[lldb][clang] Reflect LangStandard.h move to clang/Basic

[ro]

Summary

D65562 moves LangStandard.h from clang/Frontend to clang/Basic. This patch
adjusts the single file in lldb that uses it to match.

Tested on x86_64-pc-linux-gnu. Ok for trunk?

One thing I'm unsure about is the scenario of building lldb with an existing (pre-Langstandard.h move)
clang: is this supposed to work in the general case and if so, how to deal with the two
possible paths for the header? I couldn't find an example of this in lldb.

[labath]

building lldb with an existing (pre-Langstandard.h move)
clang: is this supposed to work in the general case

No, this isn't something that is supposed to work in the general case. master LLDB builds only with master clang. Sometimes you might be able to get away with using a slightly older (~a week) clang or llvm (I do to cut down on build times), but that is a totally unsupported thing...

lldb/trunk/source/Symbol/ClangASTContext.cpp

 #include "clang/AST/Mangle.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/VTableBuilder.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/FileSystemOptions.h"
+#include "clang/Basic/LangStandard.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
 #include "clang/Frontend/FrontendOptions.h"
-#include "clang/Frontend/LangStandard.h"
 #include "clang/Sema/Sema.h"
 
 #ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG
 #undef NDEBUG
 #undef LLDB_DEFINED_NDEBUG_FOR_CLANG
 // Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
 #include <assert.h>
 #endif

 using namespace lldb_private;
 using namespace llvm;
 using namespace clang;
 
 namespace {
 static inline bool
 ClangASTContextSupportsLanguage(lldb::LanguageType language) {
   return language == eLanguageTypeUnknown || // Clang is the default type system
-         Language::LanguageIsC(language) ||
-         Language::LanguageIsCPlusPlus(language) ||
-         Language::LanguageIsObjC(language) ||
-         Language::LanguageIsPascal(language) ||
+         lldb_private::Language::LanguageIsC(language) ||
+         lldb_private::Language::LanguageIsCPlusPlus(language) ||
+         lldb_private::Language::LanguageIsObjC(language) ||
+         lldb_private::Language::LanguageIsPascal(language) ||
          // Use Clang for Rust until there is a proper language plugin for it
          language == eLanguageTypeRust ||
          language == eLanguageTypeExtRenderScript ||
          // Use Clang for D until there is a proper language plugin for it
          language == eLanguageTypeD ||
          // Open Dylan compiler debug info is designed to be Clang-compatible
          language == eLanguageTypeDylan;
 }

 }
 
 static void ParseLangArgs(LangOptions &Opts, InputKind IK, const char *triple) {
   // FIXME: Cleanup per-file based stuff.
 
   // Set some properties which depend solely on the input kind; it would be
   // nice to move these to the language standard, and have the driver resolve
   // the input kind + language standard.
-  if (IK.getLanguage() == InputKind::Asm) {
+  if (IK.getLanguage() == clang::Language::Asm) {
     Opts.AsmPreprocessor = 1;
   } else if (IK.isObjectiveC()) {
     Opts.ObjC = 1;
   }
 
   LangStandard::Kind LangStd = LangStandard::lang_unspecified;
 
   if (LangStd == LangStandard::lang_unspecified) {
     // Based on the base language, pick one.
     switch (IK.getLanguage()) {
-    case InputKind::Unknown:
-    case InputKind::LLVM_IR:
-    case InputKind::RenderScript:
+    case clang::Language::Unknown:
+    case clang::Language::LLVM_IR:
+    case clang::Language::RenderScript:
       llvm_unreachable("Invalid input kind!");
-    case InputKind::OpenCL:
+    case clang::Language::OpenCL:
       LangStd = LangStandard::lang_opencl10;
       break;
-    case InputKind::CUDA:
+    case clang::Language::CUDA:
       LangStd = LangStandard::lang_cuda;
       break;
-    case InputKind::Asm:
-    case InputKind::C:
-    case InputKind::ObjC:
+    case clang::Language::Asm:
+    case clang::Language::C:
+    case clang::Language::ObjC:
       LangStd = LangStandard::lang_gnu99;
       break;
-    case InputKind::CXX:
-    case InputKind::ObjCXX:
+    case clang::Language::CXX:
+    case clang::Language::ObjCXX:
       LangStd = LangStandard::lang_gnucxx98;
       break;
-    case InputKind::HIP:
+    case clang::Language::HIP:
       LangStd = LangStandard::lang_hip;
       break;
     }
   }
 
   const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
   Opts.LineComment = Std.hasLineComments();
   Opts.C99 = Std.isC99();
if (m_identifier_table_up == nullptr)
     m_identifier_table_up.reset(
         new IdentifierTable(*ClangASTContext::getLanguageOptions(), nullptr));
   return m_identifier_table_up.get();
 }
 
 LangOptions *ClangASTContext::getLanguageOptions() {
   if (m_language_options_up == nullptr) {
     m_language_options_up.reset(new LangOptions());
-    ParseLangArgs(*m_language_options_up, InputKind::ObjCXX, GetTargetTriple());
-    //        InitializeLangOptions(*m_language_options_up, InputKind::ObjCXX);
+    ParseLangArgs(*m_language_options_up, clang::Language::ObjCXX,
+                  GetTargetTriple());
+    //        InitializeLangOptions(*m_language_options_up, Language::ObjCXX);
   }
   return m_language_options_up.get();
 }
 
 SelectorTable *ClangASTContext::getSelectorTable() {
   if (m_selector_table_up == nullptr)
     m_selector_table_up.reset(new SelectorTable());
   return m_selector_table_up.get();