[lldb][NFCI] Remove the copy-pasted version of CompilerInvocation::setLangDefaults

[teemperor]

Summary

A long time ago CompilerInvocation::setLangDefaults was apparently copy-pasted into
TypeSystemClang. Since then Clang folks have been keeping this copy of the function
more or less in sync with the original Clang one.

This patch removes the copy and just calls the original function instead. The resulting
LangOpts are identical with the previous ones beside the fact that we now no longer
enable GNUInline (which would cause __GNUC_GNU_INLINE__ to be
defined in the PP and enables support for it in Sema), NoInlineDefine (defines the
__NO_INLINE__ macro) and Digraphs (which does what you would expect).

The last two of the changed options are only relevant for lexing/preprocessing and the
ASTs we create here are always manually populated (by the ASTImporter or us building
ASTNodes via the TypeSystemClang APIs), so this should be NFC.

The GNUInline options also defines whether Sema actually respects the respective
attribute, but from what I can see there is no way one can actually generate such
an attribute in LLDB. The option is disabled in all Clang parsers we have and we
never manually construct the attribute anywhere.

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTFwd.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
private:
   /// May be null if we are already done parsing this ASTContext or the
   /// ASTContext wasn't created by parsing source code.
   clang::Sema *m_sema = nullptr;
 
   // For TypeSystemClang only
   TypeSystemClang(const TypeSystemClang &);
   const TypeSystemClang &operator=(const TypeSystemClang &);
   /// Creates the internal ASTContext.
-  void CreateASTContext();
+  /// \param target_triple The triple that defines the basic characteristics
+  ///        of the ASTContext (e.g., the size and availability of builtin
+  ///        types).
+  void CreateASTContext(const llvm::Triple &target_triple);
   void SetTargetTriple(llvm::StringRef target_triple);
 };
 
 /// The TypeSystemClang instance used for the scratch ASTContext in a
 /// lldb::Target.
 class ScratchTypeSystemClang : public TypeSystemClang {
   /// LLVM RTTI support
   static char ID;

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

 #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/CompilerInvocation.h"
 #include "clang/Frontend/FrontendOptions.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/ModuleMap.h"
 #include "clang/Sema/Sema.h"
 
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/Threading.h"
TypeSystemClang::ConvertAccessTypeToAccessSpecifier(AccessType access) {
   case eAccessPrivate:
     return AS_private;
   case eAccessProtected:
     return AS_protected;
   }
   return AS_none;
 }
 
-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() == 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 clang::Language::Unknown:
-    case clang::Language::LLVM_IR:
-    case clang::Language::RenderScript:
-      llvm_unreachable("Invalid input kind!");
-    case clang::Language::OpenCL:
-      LangStd = LangStandard::lang_opencl10;
-      break;
-    case clang::Language::OpenCLCXX:
-      LangStd = LangStandard::lang_openclcpp;
-      break;
-    case clang::Language::CUDA:
-      LangStd = LangStandard::lang_cuda;
-      break;
-    case clang::Language::Asm:
-    case clang::Language::C:
-    case clang::Language::ObjC:
-      LangStd = LangStandard::lang_gnu99;
-      break;
-    case clang::Language::CXX:
-    case clang::Language::ObjCXX:
-      LangStd = LangStandard::lang_gnucxx98;
-      break;
-    case clang::Language::HIP:
-      LangStd = LangStandard::lang_hip;
-      break;
-    }
-  }
-
-  const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
-  Opts.LineComment = Std.hasLineComments();
-  Opts.C99 = Std.isC99();
-  Opts.CPlusPlus = Std.isCPlusPlus();
-  Opts.CPlusPlus11 = Std.isCPlusPlus11();
-  Opts.Digraphs = Std.hasDigraphs();
-  Opts.GNUMode = Std.isGNUMode();
-  Opts.GNUInline = !Std.isC99();
-  Opts.HexFloats = Std.hasHexFloats();
-  Opts.ImplicitInt = Std.hasImplicitInt();
-
-  Opts.WChar = true;
-
-  // OpenCL has some additional defaults.
-  if (LangStd == LangStandard::lang_opencl10) {
-    Opts.OpenCL = 1;
-    Opts.AltiVec = 1;
-    Opts.CXXOperatorNames = 1;
-    Opts.setLaxVectorConversions(LangOptions::LaxVectorConversionKind::All);
-  }
-
-  // OpenCL and C++ both have bool, true, false keywords.
-  Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
-
-  Opts.setValueVisibilityMode(DefaultVisibility);
-
-  // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs is
-  // specified, or -std is set to a conforming mode.
-  Opts.Trigraphs = !Opts.GNUMode;
-  Opts.CharIsSigned = ArchSpec(triple).CharIsSignedByDefault();
-  Opts.OptimizeSize = 0;
-
-  // FIXME: Eliminate this dependency.
-  //    unsigned Opt =
-  //    Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags);
-  //    Opts.Optimize = Opt != 0;
-  unsigned Opt = 0;
-
-  // This is the __NO_INLINE__ define, which just depends on things like the
-  // optimization level and -fno-inline, not actually whether the backend has
-  // inlining enabled.
-  //
-  // FIXME: This is affected by other options (-fno-inline).
-  Opts.NoInlineDefine = !Opt;
+/// Creates the appropriate Clang LangOptions for the given triple.
+///
+/// Note that this is only used to create the LangOptions for internal Clang
+/// ASTContext instances that are used to store AST nodes. This doesn't
+/// influence the LangOptions of things like the expression parser, the
+/// ClangModulesDeclVendor and so on.
+static LangOptions CreateLangOpts(const llvm::Triple &triple) {
+  LangOptions opts;
+  // setLangDefaults computes some includes but we don't actually use them
+  // in LLDB.
+  std::vector<std::string> includes;
+
+  // We're always using Objective-C++ in LLDB.
+  // ASTs in LLDB can receive Objective-C and C++ declarations form other ASTs
+  // so this should allow any TypeSystemClang to receive all possible AST nodes.
+  // FIXME: This could potentially cause that C++ identifiers are turned into
+  // Objective-C keywords. Especially keywords that don't take the usual
+  // '@'-prefix could be affected by this (e.g., `__bridge`).
+  // FIXME: This should use a newer LangStandard but that will break some things
+  // in subtle ways (e.g. name printing for templates changes in Clang with
+  // C++11).
+  clang::CompilerInvocation::setLangDefaults(
+      opts, clang::InputKind(clang::Language::ObjCXX), triple, includes,
+      LangStandard::lang_gnucxx98);
 
   // This is needed to allocate the extra space for the owning module
   // on each decl.
-  Opts.ModulesLocalVisibility = 1;
+  opts.ModulesLocalVisibility = 1;
+
+  return opts;
 }
 
 TypeSystemClang::TypeSystemClang(llvm::StringRef name,
                                  llvm::Triple target_triple) {
   m_display_name = name.str();
   if (!target_triple.str().empty())
     SetTargetTriple(target_triple.str());
   // The caller didn't pass an ASTContext so create a new one for this
   // TypeSystemClang.
-  CreateASTContext();
+  CreateASTContext(target_triple);
 }
 
 TypeSystemClang::TypeSystemClang(llvm::StringRef name,
                                  ASTContext &existing_ctxt) {
   m_display_name = name.str();
   SetTargetTriple(existing_ctxt.getTargetInfo().getTriple().str());
 
   m_ast_up.reset(&existing_ctxt);
public:
   DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
     return new NullDiagnosticConsumer();
   }
 
 private:
   Log *m_log;
 };
 
-void TypeSystemClang::CreateASTContext() {
+void TypeSystemClang::CreateASTContext(const llvm::Triple &target_triple) {
   assert(!m_ast_up);
   m_ast_owned = true;
 
-  m_language_options_up = std::make_unique<LangOptions>();
-  ParseLangArgs(*m_language_options_up, clang::Language::ObjCXX,
-                GetTargetTriple());
+  m_language_options_up =
+      std::make_unique<LangOptions>(CreateLangOpts(target_triple));
 
   m_identifier_table_up =
       std::make_unique<IdentifierTable>(*m_language_options_up, nullptr);
   m_builtins_up = std::make_unique<Builtin::Context>();
 
   m_selector_table_up = std::make_unique<SelectorTable>();
 
   clang::FileSystemOptions file_system_options;