Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

docs/CppInteroperability/GettingStartedWithC++Interop.md

@@ -32,12 +32,12 @@ module CxxTest {
 Add the C++ module to the include path and enable C++ interop:
 - Navigate to your project directory
 - In `Project` navigate to `Build Settings` -> `Swift Compiler`
-- Under `Custom Flags` -> `Other Swift Flags` add`-enable-experimental-cxx-interop`
-- Under `Search Paths` -> `Import Paths` add your search path to the C++ module (i.e, `./ProjectName/CxxTest`). Repeat this step in `Other Swift Flags`
+- Under `Custom Flags` -> `Other Swift Flags` add `-Xfrontend -enable-experimental-cxx-interop`
+- Under `Search Paths` -> `Import Paths` add your search path to the C++ module (i.e, `./ProjectName/CxxTest`). 
 
 ```
-//Add to Other Swift Flags and Import Paths respectively
--enable-experimental-cxx-interop
+// Add to Other Swift Flags and Import Paths respectively
+-Xfrontend -enable-experimental-cxx-interop
 -I./ProjectName/CxxTest
 ```
 

include/swift-c/MockPlugin/MockPlugin.h

@@ -0,0 +1,31 @@
+//===--- MockPlugin.h ---------------------------------------------*- C -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_C_MOCK_PLUGIN_H
+#define SWIFT_C_MOCK_PLUGIN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int _mock_plugin_main(const char *);
+
+#ifdef __cplusplus
+}
+#endif
+
+/// Usage: MOCK_PLUGIN(JSON)
+/// 'JSON' is a *bare* JSON value.
+#define MOCK_PLUGIN(...)                                                       \
+  int main() { return _mock_plugin_main(#__VA_ARGS__); }
+
+#endif // SWIFT_C_MOCK_PLUGIN_H

include/swift/AST/CASTBridging.h

@@ -118,17 +118,18 @@ extern "C" {
 /// information and then must be finished via \c SwiftDiagnostic_finish.
 BridgedDiagnostic SwiftDiagnostic_create(
     void *diagnosticEngine, BridgedDiagnosticSeverity severity,
-    void *_Nullable sourceLoc,
+    const void *_Nullable sourceLoc,
     const uint8_t *_Nullable text, long textLen);
 
 /// Highlight a source range as part of the diagnostic.
 void SwiftDiagnostic_highlight(
-    BridgedDiagnostic diag, void *_Nullable startLoc, void *_Nullable endLoc);
+    BridgedDiagnostic diag, const void *_Nullable startLoc, const void *_Nullable endLoc);
 
 /// Add a Fix-It to replace a source range as part of the diagnostic.
 void SwiftDiagnostic_fixItReplace(
     BridgedDiagnostic diag,
-    void *_Nullable replaceStartLoc, void *_Nullable replaceEndLoc,
+    const void *_Nullable replaceStartLoc,
+    const void *_Nullable replaceEndLoc,
     const uint8_t *_Nullable newText, long newTextLen);
 
 /// Finish the given diagnostic and emit it.

include/swift/AST/Decl.h

@@ -1423,6 +1423,12 @@ class ImportDecl final : public Decl,
   /// the decls it references. Otherwise, returns an empty array.
   ArrayRef<ValueDecl *> getDecls() const;
 
+  /// Access level of this import, either explicitly declared or implicit.
+  AccessLevel getAccessLevel() const;
+
+  /// Is the access level of this import implicit, aka a default import?
+  bool isAccessLevelImplicit() const;
+
   const clang::Module *getClangModule() const {
     return getClangNode().getClangModule();
   }

include/swift/AST/DiagnosticEngine.h

@@ -41,6 +41,7 @@ namespace swift {
   class Decl;
   class DeclAttribute;
   class DiagnosticEngine;
+  class GeneratedSourceInfo;
   class SourceManager;
   class ValueDecl;
   class SourceFile;
@@ -1478,6 +1479,10 @@ namespace swift {
 std::pair<unsigned, DeclName>
 getAccessorKindAndNameForDiagnostics(const ValueDecl *D);
 
+/// Retrieve the macro name for a generated source info that represents
+/// a macro expansion.
+DeclName getGeneratedSourceInfoMacroName(const GeneratedSourceInfo &info);
+
 } // end namespace swift
 
 #endif

include/swift/AST/DiagnosticsSema.def

@@ -2048,6 +2048,16 @@ ERROR(spi_only_imports_not_enabled, none,
       "'@_spiOnly' requires setting the frontend flag '-experimental-spi-only-imports'",
       ())
 
+// Access level on imports
+ERROR(access_level_on_import_not_enabled, none,
+      "Access level on imports require '-enable-experimental-feature AccessLevelOnImport'",
+      ())
+ERROR(access_level_on_import_unsupported, none,
+      "The access level %0 is unsupported on imports: "
+      "only 'public', 'package', 'internal', 'fileprivate' and 'private' "
+      "are unsupported",
+      (DeclAttribute))
+
 // Opaque return types
 ERROR(opaque_type_invalid_constraint,none,
       "an 'opaque' type must specify only 'Any', 'AnyObject', protocols, "

include/swift/AST/Import.h

@@ -584,14 +584,24 @@ struct AttributedImport {
   /// attribute, this is the given access level.
   Optional<AccessLevel> docVisibility;
 
+  /// Access level limiting how imported types can be exported.
+  AccessLevel accessLevel;
+
+  /// Location of the attribute that defined \c accessLevel. Also indicates
+  /// if the access level was implicit or explicit.
+  SourceLoc accessLevelLoc;
+
   AttributedImport(ModuleInfo module, SourceLoc importLoc = SourceLoc(),
                    ImportOptions options = ImportOptions(),
                    StringRef filename = {}, ArrayRef<Identifier> spiGroups = {},
                    SourceRange preconcurrencyRange = {},
-                   Optional<AccessLevel> docVisibility = None)
+                   Optional<AccessLevel> docVisibility = None,
+                   AccessLevel accessLevel = AccessLevel::Public,
+                   SourceLoc accessLevelLoc = SourceLoc())
       : module(module), importLoc(importLoc), options(options),
         sourceFileArg(filename), spiGroups(spiGroups),
-        preconcurrencyRange(preconcurrencyRange), docVisibility(docVisibility) {
+        preconcurrencyRange(preconcurrencyRange), docVisibility(docVisibility),
+        accessLevel(accessLevel), accessLevelLoc(accessLevelLoc) {
     assert(!(options.contains(ImportFlags::Exported) &&
              options.contains(ImportFlags::ImplementationOnly)) ||
            options.contains(ImportFlags::Reserved));
@@ -601,15 +611,18 @@ struct AttributedImport {
   AttributedImport(ModuleInfo module, AttributedImport<OtherModuleInfo> other)
     : AttributedImport(module, other.importLoc, other.options,
                        other.sourceFileArg, other.spiGroups,
-                       other.preconcurrencyRange, other.docVisibility) { }
+                       other.preconcurrencyRange, other.docVisibility,
+                       other.accessLevel, other.accessLevelLoc) { }
 
   friend bool operator==(const AttributedImport<ModuleInfo> &lhs,
                          const AttributedImport<ModuleInfo> &rhs) {
     return lhs.module == rhs.module &&
            lhs.options.toRaw() == rhs.options.toRaw() &&
            lhs.sourceFileArg == rhs.sourceFileArg &&
            lhs.spiGroups == rhs.spiGroups &&
-           lhs.docVisibility == rhs.docVisibility;
+           lhs.docVisibility == rhs.docVisibility &&
+           lhs.accessLevel == rhs.accessLevel &&
+           lhs.accessLevelLoc == rhs.accessLevelLoc;
   }
 
   AttributedImport<ImportedModule> getLoaded(ModuleDecl *loadedModule) const {
@@ -761,14 +774,16 @@ struct DenseMapInfo<swift::AttributedImport<ModuleInfo>> {
                             SourceLocDMI::getEmptyKey(),
                             ImportOptionsDMI::getEmptyKey(),
                             StringRefDMI::getEmptyKey(),
-                            {}, {}, None);
+                            {}, {}, None,
+                            swift::AccessLevel::Public, {});
   }
   static inline AttributedImport getTombstoneKey() {
     return AttributedImport(ModuleInfoDMI::getTombstoneKey(),
                             SourceLocDMI::getEmptyKey(),
                             ImportOptionsDMI::getTombstoneKey(),
                             StringRefDMI::getTombstoneKey(),
-                            {}, {}, None);
+                            {}, {}, None,
+                            swift::AccessLevel::Public, {});
   }
   static inline unsigned getHashValue(const AttributedImport &import) {
     return detail::combineHashValue(
@@ -783,7 +798,9 @@ struct DenseMapInfo<swift::AttributedImport<ModuleInfo>> {
            ImportOptionsDMI::isEqual(a.options, b.options) &&
            StringRefDMI::isEqual(a.sourceFileArg, b.sourceFileArg) &&
            a.spiGroups == b.spiGroups &&
-           a.docVisibility == b.docVisibility;
+           a.docVisibility == b.docVisibility &&
+           a.accessLevel == b.accessLevel &&
+           a.accessLevelLoc == b.accessLevelLoc;
   }
 };
 }

include/swift/Basic/Features.def

@@ -116,7 +116,9 @@ EXPERIMENTAL_FEATURE(MoveOnlyClasses, true)
 EXPERIMENTAL_FEATURE(OneWayClosureParameters, false)
 EXPERIMENTAL_FEATURE(TypeWitnessSystemInference, false)
 EXPERIMENTAL_FEATURE(LayoutPrespecialization, true)
+
 EXPERIMENTAL_FEATURE(ModuleInterfaceExportAs, true)
+EXPERIMENTAL_FEATURE(AccessLevelOnImport, false)
 
 /// Whether to enable experimental layout string value witnesses
 EXPERIMENTAL_FEATURE(LayoutStringValueWitnesses, true)

include/swift/Frontend/PrintingDiagnosticConsumer.h

@@ -22,6 +22,7 @@
 #include "swift/Basic/DiagnosticOptions.h"
 #include "swift/Basic/LLVM.h"
 
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/Process.h"
 
@@ -47,10 +48,14 @@ class PrintingDiagnosticConsumer : public DiagnosticConsumer {
   bool SuppressOutput = false;
 
   /// swift-syntax rendering
+
+  /// A queued up source file known to the queued diagnostics.
+  using QueuedBuffer = void *;
+
+  /// The queued diagnostics structure.
   void *queuedDiagnostics = nullptr;
-  void *queuedSourceFile = nullptr;
-  unsigned queuedDiagnosticsBufferID;
-  StringRef queuedBufferName;
+  llvm::DenseMap<unsigned, QueuedBuffer> queuedBuffers;
+  unsigned queuedDiagnosticsOutermostBufferID;
 
 public:
   PrintingDiagnosticConsumer(llvm::raw_ostream &stream = llvm::errs());
@@ -91,6 +96,7 @@ class PrintingDiagnosticConsumer : public DiagnosticConsumer {
   }
 
 private:
+  void queueBuffer(SourceManager &sourceMgr, unsigned bufferID);
   void printDiagnostic(SourceManager &SM, const DiagnosticInfo &Info);
 };
 

lib/AST/ASTPrinter.cpp

@@ -3118,6 +3118,10 @@ static bool usesFeatureModuleInterfaceExportAs(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureAccessLevelOnImport(Decl *decl) {
+  return false;
+}
+
 static bool usesFeatureNamedOpaqueTypes(Decl *decl) {
   return false;
 }