Merge pull request swiftlang#34304 from aschwaighofer/rename_usableFromInline_flags

aschwaighofer · web-flow · commit 8b170f9a4a3c · 2020-10-15T11:20:08.000-07:00
Rename various IncludeUsableFromInlineAndInlineable to IncludeUsableFromInline
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -2188,7 +2188,7 @@ class ValueDecl : public Decl {
   /// the default implementations are not visible to name lookup.
   bool isAccessibleFrom(const DeclContext *DC,
                         bool forConformance = false,
-                        bool includeInlineable = false) const;
+                        bool allowUsableFromInline = false) const;
 
   /// Returns whether this declaration should be treated as \c open from
   /// \p useDC. This is very similar to #getFormalAccess, but takes
diff --git a/include/swift/AST/LookupKinds.h b/include/swift/AST/LookupKinds.h
@@ -51,7 +51,7 @@ enum NLOptions : unsigned {
   NL_IncludeAttributeImplements = 1 << 5,
 
   // Include @usableFromInline and @inlinable
-  NL_IncludeUsableFromInlineAndInlineable = 1 << 6,
+  NL_IncludeUsableFromInline = 1 << 6,
 
   /// The default set of options used for qualified name lookup.
   ///
diff --git a/include/swift/AST/ModuleNameLookup.h b/include/swift/AST/ModuleNameLookup.h
@@ -57,7 +57,7 @@ void simple_display(llvm::raw_ostream &out, ResolutionKind kind);
 ///        being performed, for checking access. This must be either a
 ///        FileUnit or a Module.
 /// \param options name lookup options. Currently only used to communicate the
-/// NL_IncludeUsableFromInlineAndInlineable option.
+/// NL_IncludeUsableFromInline option.
 void lookupInModule(const DeclContext *moduleOrFile,
                     DeclName name, SmallVectorImpl<ValueDecl *> &decls,
                     NLKind lookupKind, ResolutionKind resolutionKind,
diff --git a/include/swift/AST/NameLookup.h b/include/swift/AST/NameLookup.h
@@ -227,7 +227,7 @@ enum class UnqualifiedLookupFlags {
   IncludeOuterResults   = 1 << 4,
   // This lookup should include results that are @inlinable or
   // @usableFromInline.
-  IncludeInlineableAndUsableFromInline = 1 << 5,
+  IncludeUsableFromInline = 1 << 5,
 };
 
 using UnqualifiedLookupOptions = OptionSet<UnqualifiedLookupFlags>;
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -3394,8 +3394,8 @@ static bool checkAccess(const DeclContext *useDC, const ValueDecl *VD,
 
 bool ValueDecl::isAccessibleFrom(const DeclContext *useDC,
                                  bool forConformance,
-                                 bool includeInlineable) const {
-  return checkAccess(useDC, this, forConformance, includeInlineable,
+                                 bool allowUsableFromInline) const {
+  return checkAccess(useDC, this, forConformance, allowUsableFromInline,
                      [&]() { return getFormalAccess(); });
 }
 
diff --git a/lib/AST/ModuleNameLookup.cpp b/lib/AST/ModuleNameLookup.cpp
@@ -145,7 +145,7 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
 
   const size_t initialCount = decls.size();
   size_t currentCount = decls.size();
-  bool includeInlineable = options & NL_IncludeUsableFromInlineAndInlineable;
+  bool includeUsableFromInline = options & NL_IncludeUsableFromInline;
 
   auto updateNewDecls = [&](const DeclContext *moduleScopeContext) {
     if (decls.size() == currentCount)
@@ -157,7 +157,8 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
         if (resolutionKind == ResolutionKind::TypesOnly && !isa<TypeDecl>(VD))
           return true;
         if (respectAccessControl &&
-            !VD->isAccessibleFrom(moduleScopeContext, false, includeInlineable))
+            !VD->isAccessibleFrom(moduleScopeContext, false,
+                                  includeUsableFromInline))
           return true;
         return false;
       });
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -1502,8 +1502,9 @@ static bool isAcceptableLookupResult(const DeclContext *dc,
   // Check access.
   if (!(options & NL_IgnoreAccessControl) &&
       !dc->getASTContext().isAccessControlDisabled()) {
-    bool allowInlinable = options & NL_IncludeUsableFromInlineAndInlineable;
-    return decl->isAccessibleFrom(dc, /*forConformance*/ false, allowInlinable);
+    bool allowUsableFromInline = options & NL_IncludeUsableFromInline;
+    return decl->isAccessibleFrom(dc, /*forConformance*/ false,
+                                  allowUsableFromInline);
   }
 
   return true;
diff --git a/lib/AST/UnqualifiedLookup.cpp b/lib/AST/UnqualifiedLookup.cpp
@@ -384,8 +384,8 @@ void UnqualifiedLookupFactory::addImportedResults(const DeclContext *const dc) {
   auto resolutionKind = isOriginallyTypeLookup ? ResolutionKind::TypesOnly
                                                : ResolutionKind::Overloadable;
   auto nlOptions = NL_UnqualifiedDefault;
-  if (options.contains(Flags::IncludeInlineableAndUsableFromInline))
-    nlOptions |= NL_IncludeUsableFromInlineAndInlineable;
+  if (options.contains(Flags::IncludeUsableFromInline))
+    nlOptions |= NL_IncludeUsableFromInline;
   lookupInModule(dc, Name.getFullName(), CurModuleResults,
                  NLKind::UnqualifiedLookup, resolutionKind, dc, nlOptions);
 
@@ -841,4 +841,4 @@ ValueDecl *ASTScope::lookupSingleLocalDecl(SourceFile *sf, DeclName name,
   if (result.size() != 1)
     return nullptr;
   return result[0];
-}
+}
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -2458,7 +2458,7 @@ static void lookupReplacedDecl(DeclNameRef replacedDeclName,
 
   auto options = NL_QualifiedDefault;
   if (declCtxt->isInSpecializeExtensionContext())
-    options |= NL_IncludeUsableFromInlineAndInlineable;
+    options |= NL_IncludeUsableFromInline;
 
   if (typeCtx)
     moduleScopeCtxt->lookupQualified({typeCtx}, replacedDeclName, options,
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -2190,7 +2190,7 @@ static Type validateParameterType(ParamDecl *decl) {
   options |= TypeResolutionFlags::Direct;
 
   if (dc->isInSpecializeExtensionContext())
-    options |= TypeResolutionFlags::AllowInlinable;
+    options |= TypeResolutionFlags::AllowUsableFromInline;
 
   const auto resolution =
       TypeResolution::forInterface(dc, options, unboundTyOpener);
@@ -2727,7 +2727,7 @@ ExtendedTypeRequest::evaluate(Evaluator &eval, ExtensionDecl *ext) const {
   // Compute the extended type.
   TypeResolutionOptions options(TypeResolverContext::ExtensionBinding);
   if (ext->isInSpecializeExtensionContext())
-    options |= TypeResolutionFlags::AllowInlinable;
+    options |= TypeResolutionFlags::AllowUsableFromInline;
   const auto resolution = TypeResolution::forStructural(
       ext->getDeclContext(), options,
       [](auto unboundTy) {
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp
@@ -905,7 +905,7 @@ RequirementRequest::evaluate(Evaluator &evaluator,
   // Figure out the type resolution.
   auto options = TypeResolutionOptions(TypeResolverContext::GenericRequirement);
   if (owner.dc->isInSpecializeExtensionContext())
-    options |= TypeResolutionFlags::AllowInlinable;
+    options |= TypeResolutionFlags::AllowUsableFromInline;
   Optional<TypeResolution> resolution;
   switch (stage) {
   case TypeResolutionStage::Structural:
diff --git a/lib/Sema/TypeCheckNameLookup.cpp b/lib/Sema/TypeCheckNameLookup.cpp
@@ -211,8 +211,8 @@ convertToUnqualifiedLookupOptions(NameLookupOptions options) {
     newOptions |= UnqualifiedLookupFlags::IgnoreAccessControl;
   if (options.contains(NameLookupFlags::IncludeOuterResults))
     newOptions |= UnqualifiedLookupFlags::IncludeOuterResults;
-  if (options.contains(NameLookupFlags::IncludeInlineableAndUsableFromInline))
-    newOptions |= UnqualifiedLookupFlags::IncludeInlineableAndUsableFromInline;
+  if (options.contains(NameLookupFlags::IncludeUsableFromInline))
+    newOptions |= UnqualifiedLookupFlags::IncludeUsableFromInline;
 
   return newOptions;
 }
@@ -388,8 +388,8 @@ LookupTypeResult TypeChecker::lookupMemberType(DeclContext *dc,
 
   if (options.contains(NameLookupFlags::IgnoreAccessControl))
     subOptions |= NL_IgnoreAccessControl;
-  if (options.contains(NameLookupFlags::IncludeInlineableAndUsableFromInline))
-    subOptions |= NL_IncludeUsableFromInlineAndInlineable;
+  if (options.contains(NameLookupFlags::IncludeUsableFromInline))
+    subOptions |= NL_IncludeUsableFromInline;
 
   // Make sure we've resolved implicit members, if we need them.
   if (auto *current = type->getAnyNominal()) {
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -1314,8 +1314,8 @@ static Type resolveTopLevelIdentTypeComponent(TypeResolution resolution,
   }
 
   NameLookupOptions lookupOptions = defaultUnqualifiedLookupOptions;
-  if (options.contains(TypeResolutionFlags::AllowInlinable))
-    lookupOptions |= NameLookupFlags::IncludeInlineableAndUsableFromInline;
+  if (options.contains(TypeResolutionFlags::AllowUsableFromInline))
+    lookupOptions |= NameLookupFlags::IncludeUsableFromInline;
   auto globals = TypeChecker::lookupUnqualifiedType(DC, id, comp->getLoc(),
                                                     lookupOptions);
 
@@ -1518,8 +1518,8 @@ static Type resolveNestedIdentTypeComponent(TypeResolution resolution,
 
   // Look for member types with the given name.
   NameLookupOptions lookupOptions = defaultMemberLookupOptions;
-  if (options.contains(TypeResolutionFlags::AllowInlinable))
-    lookupOptions |= NameLookupFlags::IncludeInlineableAndUsableFromInline;
+  if (options.contains(TypeResolutionFlags::AllowUsableFromInline))
+    lookupOptions |= NameLookupFlags::IncludeUsableFromInline;
   LookupTypeResult memberTypes;
   if (parentTy->mayHaveMembers())
     memberTypes = TypeChecker::lookupMemberType(
diff --git a/lib/Sema/TypeCheckType.h b/lib/Sema/TypeCheckType.h
@@ -60,7 +60,7 @@ enum class TypeResolutionFlags : uint16_t {
   AllowModule = 1 << 7,
 
   /// Make internal @usableFromInline and @inlinable decls visible.
-  AllowInlinable = 1 << 8,
+  AllowUsableFromInline = 1 << 8,
 };
 
 /// Type resolution contexts that require special handling.
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
@@ -153,7 +153,7 @@ enum class NameLookupFlags {
   /// result.
   IncludeOuterResults = 1 << 1,
   // Whether to include results that are marked @inlinable or @usableFromInline.
-  IncludeInlineableAndUsableFromInline = 1 << 2,
+  IncludeUsableFromInline = 1 << 2,
 };
 
 /// A set of options that control name lookup.

Original file line number	Diff line number	Diff line change
`@@ -3394,8 +3394,8 @@ static bool checkAccess(const DeclContext useDC, const ValueDecl VD,`
`3394`	`3394`
`3395`	`3395`	`bool ValueDecl::isAccessibleFrom(const DeclContext *useDC,`
`3396`	`3396`	`bool forConformance,`
`3397`		`- bool includeInlineable) const {`
`3398`		`- return checkAccess(useDC, this, forConformance, includeInlineable,`
	`3397`	`+ bool allowUsableFromInline) const {`
	`3398`	`+ return checkAccess(useDC, this, forConformance, allowUsableFromInline,`
`3399`	`3399`	`[&]() { return getFormalAccess(); });`
`3400`	`3400`	`}`
`3401`	`3401`