[NFC] Rename and document fields of AttributedImport

Also renames a member in ImportResolution.cpp to align with this naming.

include/swift/AST/Import.h

@@ -444,25 +444,31 @@ struct alignas(uint64_t) ImportedModule {
   };
 };
 
+/// Augments a type representing an import to also include information about the
+/// import's attributes. This is usually used with either \c ImportedModule or
+/// \c UnloadedImportedModule.
 template<class ModuleInfo>
 struct AttributedImport {
+  /// Information about the module and access path being imported.
   ModuleInfo module;
 
-  ImportOptions importOptions;
+  /// Flags indicating which attributes of this import are present.
+  ImportOptions options;
 
-  // Filename for a @_private import.
+  /// If this is a @_private import, the value of its 'sourceFile:' argument;
-  StringRef filename;
+  /// otherwise, empty string.
+  StringRef sourceFileArg;
 
-  // Names of explicitly imported SPIs.
+  /// Names of explicitly imported SPI groups.
   ArrayRef<Identifier> spiGroups;
 
   AttributedImport(ModuleInfo module, ImportOptions options,
                    StringRef filename = {}, ArrayRef<Identifier> spiGroups = {})
-      : module(module), importOptions(options), filename(filename),
+      : module(module), options(options), sourceFileArg(filename),
         spiGroups(spiGroups) {
-    assert(!(importOptions.contains(ImportFlags::Exported) &&
+    assert(!(options.contains(ImportFlags::Exported) &&
-             importOptions.contains(ImportFlags::ImplementationOnly)) ||
+             options.contains(ImportFlags::ImplementationOnly)) ||
-           importOptions.contains(ImportFlags::Reserved));
+           options.contains(ImportFlags::Reserved));
   }
 };
 
@@ -596,14 +602,14 @@ struct DenseMapInfo<swift::AttributedImport<ModuleInfo>> {
     return detail::combineHashValue(
         ModuleInfoDMI::getHashValue(import.module),
         detail::combineHashValue(
-            ImportOptionsDMI::getHashValue(import.importOptions),
+            ImportOptionsDMI::getHashValue(import.options),
-            StringRefDMI::getHashValue(import.filename)));
+            StringRefDMI::getHashValue(import.sourceFileArg)));
   }
   static bool isEqual(const AttributedImport &a,
                       const AttributedImport &b) {
     return ModuleInfoDMI::isEqual(a.module, b.module) &&
-           ImportOptionsDMI::isEqual(a.importOptions, b.importOptions) &&
+           ImportOptionsDMI::isEqual(a.options, b.options) &&
-           StringRefDMI::isEqual(a.filename, b.filename);
+           StringRefDMI::isEqual(a.sourceFileArg, b.sourceFileArg);
   }
 };
 }

lib/AST/Module.cpp

@@ -1191,14 +1191,14 @@ SourceFile::getImportedModules(SmallVectorImpl<ImportedModule> &modules,
 
   for (auto desc : *Imports) {
     ModuleDecl::ImportFilter requiredFilter;
-    if (desc.importOptions.contains(ImportFlags::Exported))
+    if (desc.options.contains(ImportFlags::Exported))
       requiredFilter |= ModuleDecl::ImportFilterKind::Exported;
-    else if (desc.importOptions.contains(ImportFlags::ImplementationOnly))
+    else if (desc.options.contains(ImportFlags::ImplementationOnly))
       requiredFilter |= ModuleDecl::ImportFilterKind::ImplementationOnly;
     else
       requiredFilter |= ModuleDecl::ImportFilterKind::Default;
 
-    if (desc.importOptions.contains(ImportFlags::SPIAccessControl))
+    if (desc.options.contains(ImportFlags::SPIAccessControl))
       requiredFilter |= ModuleDecl::ImportFilterKind::SPIAccessControl;
 
     if (!separatelyImportedOverlays.lookup(desc.module.importedModule).empty())
@@ -1892,7 +1892,7 @@ bool HasImplementationOnlyImportsRequest::evaluate(Evaluator &evaluator,
                                                    SourceFile *SF) const {
   return llvm::any_of(SF->getImports(),
                       [](AttributedImport<ImportedModule> desc) {
-    return desc.importOptions.contains(ImportFlags::ImplementationOnly);
+    return desc.options.contains(ImportFlags::ImplementationOnly);
   });
 }
 
@@ -1917,15 +1917,15 @@ bool SourceFile::hasTestableOrPrivateImport(
         [module, queryKind](AttributedImport<ImportedModule> desc) -> bool {
           if (queryKind == ImportQueryKind::TestableAndPrivate)
             return desc.module.importedModule == module &&
-                   (desc.importOptions.contains(ImportFlags::PrivateImport) ||
+                   (desc.options.contains(ImportFlags::PrivateImport) ||
-                    desc.importOptions.contains(ImportFlags::Testable));
+                    desc.options.contains(ImportFlags::Testable));
           else if (queryKind == ImportQueryKind::TestableOnly)
             return desc.module.importedModule == module &&
-                   desc.importOptions.contains(ImportFlags::Testable);
+                   desc.options.contains(ImportFlags::Testable);
           else {
             assert(queryKind == ImportQueryKind::PrivateOnly);
             return desc.module.importedModule == module &&
-                   desc.importOptions.contains(ImportFlags::PrivateImport);
+                   desc.options.contains(ImportFlags::PrivateImport);
           }
         });
   case AccessLevel::Open:
@@ -1958,8 +1958,8 @@ bool SourceFile::hasTestableOrPrivateImport(
   return llvm::any_of(*Imports,
       [module, filename](AttributedImport<ImportedModule> desc) {
         return desc.module.importedModule == module &&
-              desc.importOptions.contains(ImportFlags::PrivateImport) &&
+              desc.options.contains(ImportFlags::PrivateImport) &&
-              desc.filename == filename;
+              desc.sourceFileArg == filename;
       });
 }
 
@@ -1974,7 +1974,7 @@ bool SourceFile::isImportedImplementationOnly(const ModuleDecl *module) const {
   // Look at the imports of this source file.
   for (auto &desc : *Imports) {
     // Ignore implementation-only imports.
-    if (desc.importOptions.contains(ImportFlags::ImplementationOnly))
+    if (desc.options.contains(ImportFlags::ImplementationOnly))
       continue;
 
     // If the module is imported this way, it's not imported
@@ -2012,7 +2012,7 @@ void SourceFile::lookupImportedSPIGroups(
                         const ModuleDecl *importedModule,
                         llvm::SmallSetVector<Identifier, 4> &spiGroups) const {
   for (auto &import : *Imports) {
-    if (import.importOptions.contains(ImportFlags::SPIAccessControl) &&
+    if (import.options.contains(ImportFlags::SPIAccessControl) &&
         importedModule == import.module.importedModule) {
       auto importedSpis = import.spiGroups;
       spiGroups.insert(importedSpis.begin(), importedSpis.end());

lib/AST/NameLookup.cpp

@@ -290,7 +290,7 @@ static void recordShadowedDeclsAfterTypeMatch(
       auto file = dc->getParentSourceFile();
       if (!file) return false;
       for (const auto &import : file->getImports()) {
-        if (import.importOptions.contains(ImportFlags::PrivateImport)
+        if (import.options.contains(ImportFlags::PrivateImport)
             && import.module.importedModule == module
             && import.module.accessPath.matches(name))
           return true;

lib/AST/OperatorNameLookup.cpp

@@ -83,7 +83,7 @@ static TinyPtrVector<T *> lookupOperatorImpl(
       if (!visitedModules.insert(mod).second)
         continue;
 
-      bool isExported = import.importOptions.contains(ImportFlags::Exported);
+      bool isExported = import.options.contains(ImportFlags::Exported);
       if (!includePrivate && !isExported)
         continue;
 

lib/Sema/ImportResolution.cpp

@@ -61,7 +61,7 @@ struct UnboundImport {
 
   /// If \c options includes \c PrivateImport, the filename we should import
   /// private declarations from.
-  StringRef privateImportFileName;
+  StringRef sourceFileArg;
 
   /// The module names being imported. There will usually be just one for the
   /// top-level module, but a submodule import will have more.
@@ -137,8 +137,8 @@ struct UnboundImport {
   /// UnboundImport.
   AttributedImport<ImportedModule>
   makeAttributedImport(ModuleDecl *module) const {
-    return AttributedImport<ImportedModule>({ accessPath, module }, options,
+    return { ImportedModule{ accessPath, module },
-                                            privateImportFileName, spiGroups);
+             options, sourceFileArg, spiGroups };
   }
 
 private:
@@ -496,7 +496,7 @@ ModuleImplicitImportsRequest::evaluate(Evaluator &evaluator,
 
 /// Create an UnboundImport for a user-written import declaration.
 UnboundImport::UnboundImport(ImportDecl *ID)
-  : importLoc(ID->getLoc()), options(), privateImportFileName(),
+  : importLoc(ID->getLoc()), options(), sourceFileArg(),
     modulePath(ID->getModulePath()), accessPath(ID->getAccessPath()),
     importOrUnderlyingModuleDecl(ID)
 {
@@ -512,7 +512,7 @@ UnboundImport::UnboundImport(ImportDecl *ID)
   if (auto *privateImportAttr =
           ID->getAttrs().getAttribute<PrivateImportAttr>()) {
     options |= ImportFlags::PrivateImport;
-    privateImportFileName = privateImportAttr->getSourceFile();
+    sourceFileArg = privateImportAttr->getSourceFile();
   }
 
   SmallVector<Identifier, 4> spiGroups;
@@ -607,7 +607,7 @@ void UnboundImport::validatePrivate(ModuleDecl *topLevelModule) {
 
   diagnoseInvalidAttr(DAK_PrivateImport, ctx.Diags,
                       diag::module_not_compiled_for_private_import);
-  privateImportFileName = StringRef();
+  sourceFileArg = StringRef();
 }
 
 void UnboundImport::validateImplementationOnly(ASTContext &ctx) {
@@ -915,9 +915,9 @@ ScopedImportLookupRequest::evaluate(Evaluator &evaluator,
 //===----------------------------------------------------------------------===//
 
 static bool canCrossImport(const AttributedImport<ImportedModule> &import) {
-  if (import.importOptions.contains(ImportFlags::Testable))
+  if (import.options.contains(ImportFlags::Testable))
     return false;
-  if (import.importOptions.contains(ImportFlags::PrivateImport))
+  if (import.options.contains(ImportFlags::PrivateImport))
     return false;
 
   return true;
@@ -928,7 +928,7 @@ UnboundImport::UnboundImport(
     ASTContext &ctx, const UnboundImport &base, Identifier overlayName,
     const AttributedImport<ImportedModule> &declaringImport,
     const AttributedImport<ImportedModule> &bystandingImport)
-    : importLoc(base.importLoc), options(), privateImportFileName(),
+    : importLoc(base.importLoc), options(), sourceFileArg(),
       // Cross-imports are not backed by an ImportDecl, so we need to provide
       // our own storage for their module paths.
       modulePath(
@@ -944,8 +944,8 @@ UnboundImport::UnboundImport(
   assert(canCrossImport(declaringImport));
   assert(canCrossImport(bystandingImport));
 
-  auto &declaringOptions = declaringImport.importOptions;
+  auto &declaringOptions = declaringImport.options;
-  auto &bystandingOptions = bystandingImport.importOptions;
+  auto &bystandingOptions = bystandingImport.options;
 
   // If both are exported, the cross-import is exported.
   if (declaringOptions.contains(ImportFlags::Exported) &&