Merge branch 'main' into name-lookup-filtering-expanded-top-level

Author: DougGregor

docs/CppInteroperability/GettingStartedWithC++Interop.md

@@ -32,7 +32,7 @@ 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 `-cxx-interoperability-mode=swift-5.9`
+- Under `Custom Flags` -> `Other Swift Flags` add `-cxx-interoperability-mode=default`
 - Under `Search Paths` -> `Import Paths` add your search path to the C++ module (i.e, `./ProjectName/CxxTest`). 
 
 - This should now allow your to import your C++ Module into any `.swift` file.
@@ -81,7 +81,7 @@ After creating your Swift package project, follow the steps [Creating a Module t
 - Swift code will be in `Sources/CxxInterop` called `main.swift`
 - C++ source code follows the example shown in [Creating a Module to contain your C++ source code](#creating-a-module-to-contain-your-c-source-code)
 - Under targets, add the name of your C++ module and the directory containing the Swift code as a target.
-- In the target defining your Swift target, add a`dependencies` to the C++ Module, the `path`, `source`, and `swiftSettings` with `unsafeFlags` with the source to the C++ Module, and enable `-cxx-interoperability-mode=swift-5.9`
+- In the target defining your Swift target, add a`dependencies` to the C++ Module, the `path`, `source`, and `swiftSettings` with `unsafeFlags` with the source to the C++ Module, and enable `-cxx-interoperability-mode=default`
 
 ```
 //In Package Manifest
@@ -111,7 +111,7 @@ let package = Package(
             sources: [ "main.swift" ],
             swiftSettings: [.unsafeFlags([
                 "-I", "Sources/CxxTest",
-                "-cxx-interoperability-mode=swift-5.9",
+                "-cxx-interoperability-mode=default",
             ])]
         ),
     ]
@@ -144,7 +144,7 @@ After creating your project follow the steps [Creating a Module to contain your
 - Create a `CMakeLists.txt` file and configure for your project
 - In`add_library` invoke `cxx-support` with the path to the C++ implementation file
 - Add the `target_include_directories` with `cxx-support` and path to the C++ Module `${CMAKE_SOURCE_DIR}/Sources/CxxTest`
-- Add the `add_executable` to the specific files/directory you would like to generate source, with`SHELL:-cxx-interoperability-mode=swift-5.9`.
+- Add the `add_executable` to the specific files/directory you would like to generate source, with`SHELL:-cxx-interoperability-mode=default`.
 - In the example below we will be following the file structure used in [Creating a Swift Package](#Creating-a-Swift-Package)
 
 ```
@@ -167,7 +167,7 @@ target_include_directories(cxx-support PUBLIC
 
 add_executable(CxxInterop ./Sources/CxxInterop/main.swift)
 target_compile_options(CxxInterop PRIVATE
-  "SHELL:-cxx-interoperability-mode=swift-5.9"
+  "SHELL:-cxx-interoperability-mode=default"
 target_link_libraries(CxxInterop PRIVATE cxx-support)
 
 ```

include/swift/AST/ASTContext.h

@@ -30,6 +30,7 @@
 #include "swift/Basic/LangOptions.h"
 #include "swift/Basic/Located.h"
 #include "swift/Basic/Malloc.h"
+#include "swift/Basic/BlockList.h"
 #include "swift/SymbolGraphGen/SymbolGraphOptions.h"
 #include "clang/AST/DeclTemplate.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -365,6 +366,8 @@ class ASTContext final {
   /// The Swift module currently being compiled.
   ModuleDecl *MainModule = nullptr;
 
+  /// The block list where we can find special actions based on module name;
+  BlockListStore blockListConfig;
 private:
   /// The current generation number, which reflects the number of
   /// times that external modules have been loaded.

include/swift/AST/DiagnosticsFrontend.def

@@ -524,10 +524,9 @@ WARNING(compiler_plugin_not_loaded,none,
 ERROR(dont_enable_interop_and_compat,none,
       "do not pass both -enable-experimental-cxx-interop and "
       "-cxx-interoperability-mode. Remove -enable-experimental-cxx-interop.", ())
-      
-ERROR(invalid_interop_compat_mode,none,
-      "invalid option passed to -cxx-interoperability-mode. Please select either "
-      "'off' or 'swift-5.9'.", ())
+
+NOTE(valid_cxx_interop_modes,none,
+      "valid arguments to '-cxx-interoperability-mode=' are %0", (StringRef))
 NOTE(swift_will_maintain_compat,none,
      "Swift will maintain source compatibility for imported APIs based on the "
      "selected compatibility mode, so updating the Swift compiler will not "

include/swift/Basic/BlockList.h

@@ -0,0 +1,51 @@
+//===--- BlockList.h ---------------------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines some miscellaneous overloads of hash_value() and
+// simple_display().
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_BASIC_BLOCKLIST_H
+#define SWIFT_BASIC_BLOCKLIST_H
+
+#include "swift/Basic/LLVM.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace swift {
+
+enum class BlockListAction: uint8_t {
+  ShouldUseBinaryModule = 0,
+  ShouldUseTextualModule,
+};
+
+enum class BlockListKeyKind: uint8_t {
+  ModuleName,
+  ProjectName
+};
+
+class BlockListStore {
+public:
+  struct Implementation;
+  bool hasBlockListAction(StringRef key, BlockListKeyKind keyKind,
+                          BlockListAction action);
+  BlockListStore();
+  ~BlockListStore();
+private:
+  friend class ASTContext;
+  void addConfigureFilePath(StringRef path);
+  Implementation &Impl;
+};
+
+} // namespace swift
+
+#endif // SWIFT_BASIC_BLOCKLIST_H

include/swift/Basic/LangOptions.h

@@ -556,6 +556,9 @@ namespace swift {
     /// The model of concurrency to be used.
     ConcurrencyModel ActiveConcurrencyModel = ConcurrencyModel::Standard;
 
+    /// All block list configuration files to be honored in this compilation.
+    std::vector<std::string> BlocklistConfigFilePath;
+
     bool isConcurrencyModelTaskToThread() const {
       return ActiveConcurrencyModel == ConcurrencyModel::TaskToThread;
     }

include/swift/Option/FrontendOptions.td

@@ -240,6 +240,9 @@ def Raccess_note : Separate<["-"], "Raccess-note">,
 def Raccess_note_EQ : Joined<["-"], "Raccess-note=">,
     Alias<Raccess_note>;
 
+def block_list_file
+  : Separate<["-"], "blocklist-file">, MetaVarName<"<path>">,
+    HelpText<"The path to a blocklist configuration file">;
 } // end let Flags = [FrontendOption, NoDriverOption]
 
 def debug_crash_Group : OptionGroup<"<automatic crashing options>">;

include/swift/SIL/TypeLowering.h

@@ -1260,14 +1260,16 @@ class TypeConverter {
   /// Check the result of
   /// getTypeLowering(AbstractionPattern,Type,TypeExpansionContext).
   void verifyLowering(const TypeLowering &, AbstractionPattern origType,
-                      Type origSubstType, TypeExpansionContext forExpansion);
+                      CanType origSubstType,
+                      TypeExpansionContext forExpansion);
   bool
-  visitAggregateLeaves(Lowering::AbstractionPattern origType, Type substType,
+  visitAggregateLeaves(Lowering::AbstractionPattern origType,
+                       CanType substType,
                        TypeExpansionContext context,
-                       std::function<bool(Type, Lowering::AbstractionPattern,
+                       std::function<bool(CanType, Lowering::AbstractionPattern,
                                           ValueDecl *, Optional<unsigned>)>
                            isLeafAggregate,
-                       std::function<bool(Type, Lowering::AbstractionPattern,
+                       std::function<bool(CanType, Lowering::AbstractionPattern,
                                           ValueDecl *, Optional<unsigned>)>
                            visit);
 #endif

lib/AST/ASTContext.cpp

@@ -713,9 +713,14 @@ ASTContext::ASTContext(
   registerNameLookupRequestFunctions(evaluator);
 
   createModuleToExecutablePluginMap();
+  
   // Provide a default OnDiskOutputBackend if user didn't supply one.
   if (!OutputBackend)
     OutputBackend = llvm::makeIntrusiveRefCnt<llvm::vfs::OnDiskOutputBackend>();
+  // Insert all block list config paths.
+  for (auto path: langOpts.BlocklistConfigFilePath) {
+    blockListConfig.addConfigureFilePath(path);
+  }
 }
 
 ASTContext::~ASTContext() {

lib/ASTGen/Sources/ASTGen/Decls.swift

@@ -89,11 +89,10 @@ extension ASTGenVisitor {
 
     let firstName: UnsafeMutableRawPointer?
     let secondName: UnsafeMutableRawPointer?
-    let type: UnsafeMutableRawPointer?
-
-    if let nodeFirstName = node.firstName,
-       // Swift AST represnts "_" as nil.
-       nodeFirstName.text != "_" {
+    
+    let nodeFirstName = node.firstName
+    if nodeFirstName.text != "_" {
+      // Swift AST represents "_" as nil.
       var text = nodeFirstName.text
       firstName = text.withUTF8 { buf in
         SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count)
@@ -111,11 +110,7 @@ extension ASTGenVisitor {
       secondName = nil
     }
 
-    if let typeSyntax = node.type {
-      type = visit(typeSyntax).rawValue
-    } else {
-      type = nil
-    }
+    let type = visit(node.type).rawValue
 
     return .decl(ParamDecl_create(ctx, loc, loc, firstName, loc, secondName, type, declContext))
   }

lib/ASTGen/Sources/ASTGen/Diagnostics.swift

@@ -110,7 +110,7 @@ func emitDiagnostic(
         message: fixIt.message.message,
         severity: .note,
         position: diagnostic.position,
-        fixItChanges: fixIt.changes.changes
+        fixItChanges: fixIt.changes
     )
   }
 
@@ -231,7 +231,7 @@ extension SourceManager {
           severity: .note,
           node: diagnostic.node,
           position: diagnostic.position,
-          fixItChanges: fixIt.changes.changes
+          fixItChanges: fixIt.changes
       )
     }
 

lib/Basic/BlockList.cpp

@@ -0,0 +1,53 @@
+//===--- BlockList.cpp - BlockList utilities ------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/YAMLParser.h"
+#include "llvm/Support/YAMLTraits.h"
+#include "swift/Basic/BlockList.h"
+#include "swift/Basic/SourceManager.h"
+
+struct swift::BlockListStore::Implementation {
+  llvm::StringMap<std::vector<BlockListAction>> ModuleActionDict;
+  llvm::StringMap<std::vector<BlockListAction>> ProjectActionDict;
+  void addConfigureFilePath(StringRef path);
+  bool hasBlockListAction(StringRef key, BlockListKeyKind keyKind,
+                          BlockListAction action);
+};
+
+swift::BlockListStore::BlockListStore(): Impl(*new Implementation()) {}
+
+swift::BlockListStore::~BlockListStore() { delete &Impl; }
+
+bool swift::BlockListStore::hasBlockListAction(StringRef key,
+    BlockListKeyKind keyKind, BlockListAction action) {
+  return Impl.hasBlockListAction(key, keyKind, action);
+}
+
+void swift::BlockListStore::addConfigureFilePath(StringRef path) {
+  Impl.addConfigureFilePath(path);
+}
+
+bool swift::BlockListStore::Implementation::hasBlockListAction(StringRef key,
+    BlockListKeyKind keyKind, BlockListAction action) {
+  auto *dict = keyKind == BlockListKeyKind::ModuleName ? &ModuleActionDict :
+    &ProjectActionDict;
+  auto it = dict->find(key);
+  if (it == dict->end())
+    return false;
+  return llvm::is_contained(it->second, action);
+}
+
+void swift::BlockListStore::Implementation::addConfigureFilePath(StringRef path) {
+
+}

lib/Basic/CMakeLists.txt

@@ -78,6 +78,7 @@ add_swift_host_library(swiftBasic STATIC
   Unicode.cpp
   UUID.cpp
   Version.cpp
+  BlockList.cpp
 
   ${llvm_revision_inc}
   ${clang_revision_inc}

lib/ClangImporter/ClangModuleDependencyScanner.cpp

@@ -75,12 +75,8 @@ static void addSearchPathInvocationArguments(
 static std::vector<std::string> getClangDepScanningInvocationArguments(
     ASTContext &ctx,
     Optional<StringRef> sourceFileName = None) {
-  std::vector<std::string> commandLineArgs;
-
-  // Form the basic command line.
-  commandLineArgs.push_back("clang");
-  importer::getNormalInvocationArguments(commandLineArgs, ctx);
-  importer::addCommonInvocationArguments(commandLineArgs, ctx);
+  std::vector<std::string> commandLineArgs =
+      ClangImporter::getClangArguments(ctx);
   addSearchPathInvocationArguments(commandLineArgs, ctx);
 
   auto sourceFilePos = std::find(
@@ -114,6 +110,10 @@ static std::vector<std::string> getClangDepScanningInvocationArguments(
     *syntaxOnlyPos = "-c";
   }
 
+  // The Clang modules produced by ClangImporter are always embedded in an
+  // ObjectFilePCHContainer and contain -gmodules debug info.
+  commandLineArgs.push_back("-gmodules");
+
   return commandLineArgs;
 }
 

lib/Frontend/CompilerInvocation.cpp

@@ -438,11 +438,26 @@ enum class CxxCompatMode {
 static CxxCompatMode validateCxxInteropCompatibilityMode(StringRef mode) {
   if (mode == "off")
     return CxxCompatMode::off;
+  if (mode == "default")
+    return CxxCompatMode::enabled;
+  // FIXME: Drop swift-5.9.
   if (mode == "swift-5.9")
     return CxxCompatMode::enabled;
   return CxxCompatMode::invalid;
 }
 
+static void diagnoseCxxInteropCompatMode(Arg *verArg, ArgList &Args,
+                                         DiagnosticEngine &diags) {
+  // General invalid argument error
+  diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
+                 verArg->getAsString(Args), verArg->getValue());
+
+  // Note valid C++ interoperability modes.
+  auto validVers = {llvm::StringRef("off"), llvm::StringRef("default")};
+  auto versStr = "'" + llvm::join(validVers, "', '") + "'";
+  diags.diagnose(SourceLoc(), diag::valid_cxx_interop_modes, versStr);
+}
+
 static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
                           DiagnosticEngine &Diags,
                           const FrontendOptions &FrontendOpts) {
@@ -940,10 +955,8 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     auto interopCompatMode = validateCxxInteropCompatibilityMode(A->getValue());
     Opts.EnableCXXInterop |= (interopCompatMode == CxxCompatMode::enabled);
 
-    if (interopCompatMode == CxxCompatMode::invalid) {
-      Diags.diagnose(SourceLoc(), diag::invalid_interop_compat_mode);
-      Diags.diagnose(SourceLoc(), diag::swift_will_maintain_compat);
-    }
+    if (interopCompatMode == CxxCompatMode::invalid)
+      diagnoseCxxInteropCompatMode(A, Args, Diags);
   }
 
   if (Args.hasArg(OPT_enable_experimental_cxx_interop)) {
@@ -1164,6 +1177,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
 
   Opts.DumpTypeWitnessSystems = Args.hasArg(OPT_dump_type_witness_systems);
 
+  for (auto A : Args.getAllArgValues(options::OPT_block_list_file)) {
+    Opts.BlocklistConfigFilePath.push_back(A);
+  }
   if (const Arg *A = Args.getLastArg(options::OPT_concurrency_model)) {
     Opts.ActiveConcurrencyModel =
         llvm::StringSwitch<ConcurrencyModel>(A->getValue())