[lldb][NFC] Inclusive language: rename m_master in ASTImporterDelegate

[quinnp]

Summary

[NFC] As part of using inclusive language within the llvm project, this patch
replaces m_master in ASTImporterDelegate with m_main.

lldb/source/Plugins/ExpressionParser/Clang/ClangASTImporter.h

public:
   /// This class updates the map from declarations to their original
   /// declarations and can record declarations that have been imported in a
   /// certain interval.
   ///
   /// When intercepting a declaration import, the ASTImporterDelegate uses the
   /// CxxModuleHandler to replace any missing or malformed declarations with
   /// their counterpart from a C++ module.
   struct ASTImporterDelegate : public clang::ASTImporter {
-    ASTImporterDelegate(ClangASTImporter &master, clang::ASTContext *target_ctx,
+    ASTImporterDelegate(ClangASTImporter &main, clang::ASTContext *target_ctx,
                         clang::ASTContext *source_ctx)
-        : clang::ASTImporter(*target_ctx, master.m_file_manager, *source_ctx,
-                             master.m_file_manager, true /*minimal*/),
-          m_master(master), m_source_ctx(source_ctx) {
+        : clang::ASTImporter(*target_ctx, main.m_file_manager, *source_ctx,
+                             main.m_file_manager, true /*minimal*/),
+          m_main(main), m_source_ctx(source_ctx) {
       // Target and source ASTContext shouldn't be identical. Importing AST
       // nodes within the same AST doesn't make any sense as the whole idea
       // is to import them to a different AST.
       lldbassert(target_ctx != source_ctx && "Can't import into itself");
       // This is always doing a minimal import of any declarations. This means
       // that there has to be an ExternalASTSource in the target ASTContext
       // (that should implement the callbacks that complete any declarations
       // on demand). Without an ExternalASTSource, this ASTImporter will just
protected:
     llvm::Expected<clang::Decl *> ImportImpl(clang::Decl *From) override;
 
   private:
     /// Decls we should ignore when mapping decls back to their original
     /// ASTContext. Used by the CxxModuleHandler to mark declarations that
     /// were created from the 'std' C++ module to prevent that the Importer
     /// tries to sync them with the broken equivalent in the debug info AST.
     llvm::SmallPtrSet<clang::Decl *, 16> m_decls_to_ignore;
-    ClangASTImporter &m_master;
+    ClangASTImporter &m_main;
     clang::ASTContext *m_source_ctx;
     CxxModuleHandler *m_std_handler = nullptr;
     /// The currently attached listener.
     NewDeclListener *m_new_decl_listener = nullptr;
   };
 
   typedef std::shared_ptr<ASTImporterDelegate> ImporterDelegateSP;
   typedef llvm::DenseMap<clang::ASTContext *, ImporterDelegateSP> DelegateMap;

lldb/source/Plugins/ExpressionParser/Clang/ClangASTImporter.cpp

if (D) {
       // ASTImporter to try 'updating' the module decl with the minimal one from
       // the debug info.
       m_decls_to_ignore.insert(*D);
       return *D;
     }
   }
 
   // Check which ASTContext this declaration originally came from.
-  DeclOrigin origin = m_master.GetDeclOrigin(From);
+  DeclOrigin origin = m_main.GetDeclOrigin(From);
 
   // Prevent infinite recursion when the origin tracking contains a cycle.
   assert(origin.decl != From && "Origin points to itself?");
 
   // If it originally came from the target ASTContext then we can just
   // pretend that the original is the one we imported. This can happen for
   // example when inspecting a persistent declaration from the scratch
   // ASTContext (which will provide the declaration when parsing the
ClangASTImporter::ASTImporterDelegate::ImportImpl(Decl *From) {
   // original ASTContext and copy the original to the target. This is not
   // only faster than first completing our current decl and then copying it
   // to the target, but it also prevents that indirectly copying the same
   // declaration to the same target requires the ASTImporter to merge all
   // the different decls that appear to come from different ASTContexts (even
   // though all these different source ASTContexts just got a copy from
   // one source AST).
   if (origin.Valid()) {
-    auto R = m_master.CopyDecl(&getToContext(), origin.decl);
+    auto R = m_main.CopyDecl(&getToContext(), origin.decl);
     if (R) {
       RegisterImportedDecl(From, R);
       return R;
     }
   }
 
   // If we have a forcefully completed type, try to find an actual definition
   // for it in other modules.
-  const ClangASTMetadata *md = m_master.GetDeclMetadata(From);
+  const ClangASTMetadata *md = m_main.GetDeclMetadata(From);
   auto *td = dyn_cast<TagDecl>(From);
   if (td && md && md->IsForcefullyCompleted()) {
     Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
     LLDB_LOG(log,
              "[ClangASTImporter] Searching for a complete definition of {0} in "
              "other modules",
              td->getName());
     Expected<DeclContext *> dc_or_err = ImportContext(td->getDeclContext());
if (from_source && to_source) {
     OptionalClangModuleID from_id(from->getOwningModuleID());
     OptionalClangModuleID to_id =
         RemapModule(from_id, *from_source, *to_source);
     TypeSystemClang &to_ts = to_source->GetTypeSystem();
     to_ts.SetOwningModule(to, to_id);
   }
 
   lldb::user_id_t user_id = LLDB_INVALID_UID;
-  ClangASTMetadata *metadata = m_master.GetDeclMetadata(from);
+  ClangASTMetadata *metadata = m_main.GetDeclMetadata(from);
   if (metadata)
     user_id = metadata->GetUserID();
 
   if (log) {
     if (NamedDecl *from_named_decl = dyn_cast<clang::NamedDecl>(from)) {
       std::string name_string;
       llvm::raw_string_ostream name_stream(name_string);
       from_named_decl->printName(name_stream);
       name_stream.flush();
 
       LLDB_LOG(log,
                "    [ClangASTImporter] Imported ({0}Decl*){1}, named {2} (from "
                "(Decl*){3}), metadata {4}",
                from->getDeclKindName(), to, name_string, from, user_id);
     } else {
       LLDB_LOG(log,
                "    [ClangASTImporter] Imported ({0}Decl*){1} (from "
                "(Decl*){2}), metadata {3}",
                from->getDeclKindName(), to, from, user_id);
     }
   }
 
   ASTContextMetadataSP to_context_md =
-      m_master.GetContextMetadata(&to->getASTContext());
+      m_main.GetContextMetadata(&to->getASTContext());
   ASTContextMetadataSP from_context_md =
-      m_master.MaybeGetContextMetadata(m_source_ctx);
+      m_main.MaybeGetContextMetadata(m_source_ctx);
 
   if (from_context_md) {
     DeclOrigin origin = from_context_md->getOrigin(from);
 
     if (origin.Valid()) {
       if (origin.ctx != &to->getASTContext()) {
         if (!to_context_md->hasOrigin(to) || user_id != LLDB_INVALID_UID)
           to_context_md->setOrigin(to, origin);
 
         ImporterDelegateSP direct_completer =
-            m_master.GetDelegate(&to->getASTContext(), origin.ctx);
+            m_main.GetDelegate(&to->getASTContext(), origin.ctx);
 
         if (direct_completer.get() != this)
           direct_completer->ASTImporter::Imported(origin.decl, to);
 
         LLDB_LOG(log,
                  "    [ClangASTImporter] Propagated origin "
                  "(Decl*){0}/(ASTContext*){1} from (ASTContext*){2} to "
                  "(ASTContext*){3}",
LLDB_LOG(
         "    [ClangASTImporter] To is a TagDecl - attributes {0}{1} [{2}->{3}]",
         (to_tag_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
         (to_tag_decl->hasExternalVisibleStorage() ? " Visible" : ""),
         (from_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"),
         (to_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"));
   }
 
   if (auto *to_namespace_decl = dyn_cast<NamespaceDecl>(to)) {
-    m_master.BuildNamespaceMap(to_namespace_decl);
+    m_main.BuildNamespaceMap(to_namespace_decl);
     to_namespace_decl->setHasExternalVisibleStorage();
   }
 
   if (auto *to_container_decl = dyn_cast<ObjCContainerDecl>(to)) {
     to_container_decl->setHasExternalLexicalStorage();
     to_container_decl->setHasExternalVisibleStorage();
 
     if (log) {
if (log) {
             ((Decl *)to_container_decl)->getDeclKindName(),
             (to_container_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
             (to_container_decl->hasExternalVisibleStorage() ? " Visible" : ""));
       }
     }
   }
 
   if (clang::CXXMethodDecl *to_method = dyn_cast<CXXMethodDecl>(to))
-    MaybeCompleteReturnType(m_master, to_method);
+    MaybeCompleteReturnType(m_main, to_method);
 }
 
 clang::Decl *
 ClangASTImporter::ASTImporterDelegate::GetOriginalDecl(clang::Decl *To) {
-  return m_master.GetDeclOrigin(To).decl;
+  return m_main.GetDeclOrigin(To).decl;
 }