formatting

Author: elsh

Diff for: include/swift/AST/AccessScope.h

@@ -28,14 +28,14 @@ class AccessScope {
   /// <DeclContext*, bool> pair to determine the scope, as shown
   /// in the table below.
   ///
-  /// <DeclContext*, bool>     AccessScope      AccessLevel
-  /// --------------------------------------------
-  ///  <nullptr, false>                Public             public or open
-  ///  <nullptr, true>                  Public             public `@_spi`
-  ///  <PackageUnit*, _>             Package             package
-  ///  <ModuleDecl*, _>                Module               internal
-  ///  <FileUnit*, false>           FileScope           fileprivate
-  ///  <FileUnit*, true>              Private               private
+  /// <DeclContext*, bool>          AccessScope        AccessLevel
+  /// ----------------------------------------------------------------
+  ///  <nullptr, false>              Public           public or open
+  ///  <nullptr, true>               Public           public `@_spi`
+  ///  <PackageUnit*, _>             Package            package
+  ///  <ModuleDecl*, _>              Module             internal
+  ///  <FileUnit*, false>            FileScope        fileprivate
+  ///  <FileUnit*, true>             Private            private
   ///
   /// For example, if a decl with `public` access level is referenced outside of
   /// its defining module, it will be maped to the <nullptr, false> pair during
@@ -84,8 +84,8 @@ class AccessScope {
   /// child of the other.
   /// 2. This function does _not_ check the restrictiveness of the _access
   /// level_ between two decls.
-  /// 3. The DeclContext of this (use site) may not be null even if the use site has
-  /// a `public` access level.
+  /// 3. The DeclContext of this (use site) may not be null even if the use site
+  /// has a `public` access level.
   ///
   /// Here's an example while typechecking a file with the following code.
   ///
@@ -96,12 +96,12 @@ class AccessScope {
   /// public func myFunc(_ arg: OtherModule.Foo) {}
   /// ```
   ///
-  /// The use site of `Foo`is a function `myFunc`, and its DeclContext is non-null
-  /// (FileUnit) even though the function decl itself has a `public` access level.
-  /// When `isChildOf` is called, the argument passed in is a pair <nullptr,
-  /// false> created in \c getAccessScopeForFormalAccess based on the access
-  /// level of the decl `Foo`. Since FileUnit is a child of nullptr in the DeclContext
-  /// hierarchy (described above), it returns true.
+  /// The use site of `Foo`is a function `myFunc`, and its DeclContext is
+  /// non-null (FileUnit) even though the function decl itself has a `public`
+  /// access level. When `isChildOf` is called, the argument passed in is a pair
+  /// <nullptr, false> created in \c getAccessScopeForFormalAccess based on the
+  /// access level of the decl `Foo`. Since FileUnit is a child of nullptr in
+  /// the DeclContext hierarchy (described above), it returns true.
   ///
   /// \see AccessScope::getAccessScopeForFormalAccess
   /// \see AccessScope::checkAccessUsingAccessScope
@@ -114,7 +114,7 @@ class AccessScope {
         return allowsPrivateAccess(getDeclContext(), AS.getDeclContext());
       else
         return AS.isPublic();
-    } else {// It's public, so can't be a child of the argument scope
+    } else { // It's public, so can't be a child of the argument scope
       return false;
     }
   }

Diff for: include/swift/AST/DeclContext.h

@@ -230,14 +230,14 @@ struct FragileFunctionKind {
 /// macro context, please see GenericContext for how to minimize new entries in
 /// the ASTHierarchy enum below.
 ///
-/// The hierarchy between DeclContext subclasses is set in their ctors. For example,
-/// FileUnit ctor takes ModuleDecl as its parent DeclContext. The hierarchy from the most
-/// to least restrictive order is:
-///  decl/expr (e.g. ClassDecl) -> FileUnit -> ModuleDecl -> PackageUnit -> nullptr
+/// The hierarchy between DeclContext subclasses is set in their ctors. For
+/// example, FileUnit ctor takes ModuleDecl as its parent DeclContext. The
+/// hierarchy from the most to least restrictive order is:
+/// decl/expr (e.g. ClassDecl) -> FileUnit -> ModuleDecl -> PackageUnit -> nullptr
 ///
-/// There's an exception, however; the parent of ModuleDecl is set nullptr, not set to
-/// PackageUnit; ModuleDecl has a pointer to PackageUnit as its field, and it is treated as
-/// the enclosing scope of ModuleDecl.
+/// There's an exception, however; the parent of ModuleDecl is set nullptr, not
+/// set to PackageUnit; ModuleDecl has a pointer to PackageUnit as its field,
+/// and it is treated as the enclosing scope of ModuleDecl.
 class alignas(1 << DeclContextAlignInBits) DeclContext
     : public ASTAllocated<DeclContext> {
   enum class ASTHierarchy : unsigned {
@@ -332,7 +332,7 @@ class alignas(1 << DeclContextAlignInBits) DeclContext
   bool isLocalContext() const {
     return getContextKind() <= DeclContextKind::Last_LocalDeclContextKind;
   }
-  
+
   /// \returns true if this is a package context
   LLVM_READONLY
   bool isPackageContext() const; // see swift/AST/Module.h

Diff for: include/swift/AST/Module.h

@@ -343,8 +343,8 @@ class ModuleDecl
     return new (ctx) ModuleDecl(name, ctx, importInfo);
   }
 
-  static ModuleDecl *
-  createMainModule(ASTContext &ctx, Identifier name, ImplicitImportInfo iinfo) {
+  static ModuleDecl *createMainModule(ASTContext &ctx, Identifier name,
+                                      ImplicitImportInfo iinfo) {
     auto *Mod = ModuleDecl::create(name, ctx, iinfo);
     Mod->Bits.ModuleDecl.IsMainModule = true;
     return Mod;

Diff for: lib/AST/Decl.cpp

@@ -3926,7 +3926,7 @@ getAccessScopeForFormalAccess(const ValueDecl *VD,
   case AccessLevel::Internal:
     return AccessScope(resultDC->getParentModule());
   case AccessLevel::Package: {
-    auto pkg = resultDC->getPackageContext(/*lookupIfNotCurrent*/true);
+    auto pkg = resultDC->getPackageContext(/*lookupIfNotCurrent*/ true);
     if (!pkg) {
       auto &d = VD->getASTContext().Diags;
       d.diagnose(VD->getLoc(), diag::access_control_requires_package_name);
@@ -3966,18 +3966,19 @@ ValueDecl::getFormalAccessScope(const DeclContext *useDC,
 /// The use site of `Foo`is a function `myFunc`, and its DeclContext (useDC)
 /// is FileUnit. The call \c getAccessScopeForFormalAccess inside this function
 /// to get the access scope of`Foo` returns a public scope based on its `public`
-/// access level, which is a wrapper around a nullptr DeclContext. Note that the useDC
-/// is still non-null (FileUnit) even though the use site itself also has a `public` acess
-/// level.
+/// access level, which is a wrapper around a nullptr DeclContext. Note that the
+/// useDC is still non-null (FileUnit) even though the use site itself also has
+/// a `public` acess level.
 ///
-/// The `isChildOf` call compares the DeclContext hierarchy of the use site (useDC)
-/// and the decl (VD) site, and returns true in this case, since FileUnit is a child of nullptr
-/// based on the DeclContext hierarchy. The hierarchy is created when subclasses of
-/// DeclContext such as FileUnit or ModuleDecl are constructed. For example, FileUnit
-/// ctor takes ModuleDecl as its parent DeclContext. There's an exception, however; the
-/// parent of ModuleDecl is nullptr, not set to PackageUnit; ModuleDecl has a pointer to
-/// PackageUnit as its field, and it is treated as the enclosing scope of ModuleDecl in the
-/// `isChildOf` call.
+/// The `isChildOf` call compares the DeclContext hierarchy of the use site
+/// (useDC) and the decl (VD) site, and returns true in this case, since
+/// FileUnit is a child of nullptr based on the DeclContext hierarchy. The
+/// hierarchy is created when subclasses of DeclContext such as FileUnit or
+/// ModuleDecl are constructed. For example, FileUnit ctor takes ModuleDecl as
+/// its parent DeclContext. There's an exception, however; the parent of
+/// ModuleDecl is nullptr, not set to PackageUnit; ModuleDecl has a pointer to
+/// PackageUnit as its field, and it is treated as the enclosing scope of
+/// ModuleDecl in the `isChildOf` call.
 ///
 /// \see DeclContext::ASTHierarchy
 /// \see AccessScope::getAccessScopeForFormalAccess
@@ -4113,8 +4114,8 @@ static bool checkAccess(const DeclContext *useDC, const ValueDecl *VD,
     return useSF && useSF->hasTestableOrPrivateImport(access, sourceModule);
   }
   case AccessLevel::Package: {
-    auto srcPkg = sourceDC->getPackageContext(/*lookupIfNotCurrent*/true);
-    auto usePkg = useDC->getPackageContext(/*lookupIfNotCurrent*/true);
+    auto srcPkg = sourceDC->getPackageContext(/*lookupIfNotCurrent*/ true);
+    auto usePkg = useDC->getPackageContext(/*lookupIfNotCurrent*/ true);
     return usePkg->isSamePackageAs(srcPkg);
   }
   case AccessLevel::Public:

Diff for: lib/AST/DeclContext.cpp

@@ -1289,7 +1289,7 @@ bool AccessScope::allowsPrivateAccess(const DeclContext *useDC, const DeclContex
   // has internal or less acl, check if it belongs to
   // the same package as the decl site's to allow access.
   if (auto srcPkg = sourceDC->getPackageContext()) {
-    if (auto usePkg = useDC->getPackageContext(/*lookupIfNotCurrent*/true)) {
+    if (auto usePkg = useDC->getPackageContext(/*lookupIfNotCurrent*/ true)) {
       return usePkg->isSamePackageAs(srcPkg);
     }
   }

Diff for: lib/Sema/TypeCheckAccess.cpp

@@ -2285,7 +2285,8 @@ static void checkExtensionGenericParamAccess(const ExtensionDecl *ED) {
     desiredAccessScope = AccessScope(ED->getModuleContext());
     break;
   case AccessLevel::Package:
-    desiredAccessScope = AccessScope(ED->getPackageContext(/*lookupIfNotCurrent*/true));
+    desiredAccessScope =
+        AccessScope(ED->getPackageContext(/*lookupIfNotCurrent*/ true));
     break;
   case AccessLevel::Public:
   case AccessLevel::Open: