Merge pull request #69224 from etcwilde/rebranch

Author: etcwilde

docs/Android.md

@@ -36,8 +36,8 @@ To follow along with this guide, you'll need:
    instructions in the Swift project README.
 2. The latest build of the Swift compiler for your Linux distro, available at
    https://www.swift.org/download/ or sometimes your distro package manager.
-3. The latest version of the Android LTS NDK (r25c at the time of this writing),
-   available to download here:
+3. The last version of the Android LTS NDK (r25c, the latest LTS NDK 26 at the
+   time of this writing doesn't work yet), available to download here:
    https://developer.android.com/ndk/downloads
 4. An Android device with remote debugging enabled or the emulator. We require
    remote debugging in order to deploy built stdlib products to the device. You

include/swift-c/DependencyScan/DependencyScan.h

@@ -437,17 +437,6 @@ typedef struct swiftscan_cas_options_s *swiftscan_cas_options_t;
 /// ActionCache.
 typedef struct swiftscan_cas_s *swiftscan_cas_t;
 
-/// Enum types for output types for cache key computation.
-/// TODO: complete the list.
-typedef enum {
-  SWIFTSCAN_OUTPUT_TYPE_OBJECT = 0,
-  SWIFTSCAN_OUTPUT_TYPE_SWIFTMODULE = 1,
-  SWIFTSCAN_OUTPUT_TYPE_SWIFTINTERFACE = 2,
-  SWIFTSCAN_OUTPUT_TYPE_SWIFTPRIVATEINTERFACE = 3,
-  SWIFTSCAN_OUTPUT_TYPE_CLANG_MODULE = 4,
-  SWIFTSCAN_OUTPUT_TYPE_CLANG_PCH = 5
-} swiftscan_output_kind_t;
-
 /// Create a \c CASOptions for creating CAS inside scanner specified.
 SWIFTSCAN_PUBLIC swiftscan_cas_options_t swiftscan_cas_options_create(void);
 
@@ -489,13 +478,15 @@ SWIFTSCAN_PUBLIC swiftscan_string_ref_t
 swiftscan_cas_store(swiftscan_cas_t cas, uint8_t *data, unsigned size,
                     swiftscan_string_ref_t *error);
 
-/// Compute \c CacheKey for output of \c kind from the compiler invocation \c
-/// argc and \c argv with \c input. Return \c CacheKey as string.
+/// Compute \c CacheKey for the outputs of a primary input file from a compiler
+/// invocation with command-line \c argc and \c argv. When primary input file
+/// is not available for compilation, e.g., using WMO, primary file is the first
+/// swift input on the command-line by convention. Return \c CacheKey as string.
 /// If error happens, the error message is returned via `error` parameter, and
 /// caller needs to free the error message via `swiftscan_string_dispose`.
-SWIFTSCAN_PUBLIC swiftscan_string_ref_t swiftscan_compute_cache_key(
-    swiftscan_cas_t cas, int argc, const char **argv, const char *input,
-    swiftscan_output_kind_t kind, swiftscan_string_ref_t *error);
+SWIFTSCAN_PUBLIC swiftscan_string_ref_t
+swiftscan_cache_compute_key(swiftscan_cas_t cas, int argc, const char **argv,
+                            const char *input, swiftscan_string_ref_t *error);
 
 //===----------------------------------------------------------------------===//
 

include/swift/AST/ASTScope.h

@@ -29,6 +29,7 @@
 #define SWIFT_AST_AST_SCOPE_H
 
 #include "swift/AST/ASTNode.h"
+#include "swift/AST/CatchNode.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/SimpleRequest.h"
 #include "swift/Basic/Compiler.h"
@@ -85,6 +86,7 @@ class SILGenFunction;
 
 namespace ast_scope {
 class ASTScopeImpl;
+class BraceStmtScope;
 class GenericTypeOrExtensionScope;
 class IterableTypeScope;
 class TypeAliasScope;
@@ -211,6 +213,7 @@ class ASTScopeImpl : public ASTAllocated<ASTScopeImpl> {
 #pragma mark common queries
 public:
   virtual NullablePtr<AbstractClosureExpr> getClosureIfClosureScope() const;
+  virtual NullablePtr<const BraceStmtScope> getAsBraceStmtScope() const;
   virtual ASTContext &getASTContext() const;
   virtual NullablePtr<Decl> getDeclIfAny() const { return nullptr; };
   virtual NullablePtr<Stmt> getStmtIfAny() const { return nullptr; };
@@ -287,10 +290,18 @@ class ASTScopeImpl : public ASTAllocated<ASTScopeImpl> {
       SourceFile *sourceFile, SourceLoc loc,
       llvm::function_ref<bool(ASTScope::PotentialMacro)> consume);
 
+  static CatchNode lookupCatchNode(ModuleDecl *module, SourceLoc loc);
+
   /// Scopes that cannot bind variables may set this to true to create more
   /// compact scope tree in the debug info.
   virtual bool ignoreInDebugInfo() const { return false; }
 
+  /// If this scope node represents a potential catch node, return body the
+  /// AST node describing the catch (a function, closure, or do...catch) and
+  /// the node of it's "body", i.e., the brace statement from which errors
+  /// thrown will be caught by that node.
+  virtual std::pair<CatchNode, const BraceStmtScope *> getCatchNodeBody() const;
+
 #pragma mark - - lookup- starting point
 private:
   static const ASTScopeImpl *findStartingScopeForLookup(SourceFile *,
@@ -824,6 +835,8 @@ class FunctionBodyScope : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   bool ignoreInDebugInfo() const override { return true; }
 
+  std::pair<CatchNode, const BraceStmtScope *> getCatchNodeBody() const override;
+
 protected:
   bool lookupLocalsOrMembers(DeclConsumer) const override;
 
@@ -1069,6 +1082,8 @@ class ClosureParametersScope final : public ASTScopeImpl {
   NullablePtr<AbstractClosureExpr> getClosureIfClosureScope() const override {
     return closureExpr;
   }
+  std::pair<CatchNode, const BraceStmtScope *> getCatchNodeBody() const override;
+
   NullablePtr<Expr> getExprIfAny() const override { return closureExpr; }
   Expr *getExpr() const { return closureExpr; }
   bool ignoreInDebugInfo() const override { return true; }
@@ -1440,6 +1455,8 @@ class DoCatchStmtScope final : public AbstractStmtScope {
   void expandAScopeThatDoesNotCreateANewInsertionPoint(ScopeCreator &);
 
 public:
+  std::pair<CatchNode, const BraceStmtScope *> getCatchNodeBody() const override;
+
   std::string getClassName() const override;
   Stmt *getStmt() const override { return stmt; }
 };
@@ -1648,6 +1665,8 @@ class BraceStmtScope final : public AbstractStmtScope {
   NullablePtr<AbstractClosureExpr> parentClosureIfAny() const; // public??
   Stmt *getStmt() const override { return stmt; }
 
+  NullablePtr<const BraceStmtScope> getAsBraceStmtScope() const override;
+
 protected:
   bool lookupLocalsOrMembers(DeclConsumer) const override;
 };

include/swift/AST/CatchNode.h

@@ -0,0 +1,43 @@
+//===--- CatchNode.h - An AST node that catches errors -----------*- C++-*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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_AST_CATCHNODE_H
+#define SWIFT_AST_CATCHNODE_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/PointerUnion.h"
+#include "swift/AST/Decl.h"
+#include "swift/AST/Expr.h"
+#include "swift/AST/Stmt.h"
+
+namespace swift {
+
+/// An AST node that represents a point where a thrown error can be caught and
+/// or rethrown, which includes functions do...catch statements.
+class CatchNode: public llvm::PointerUnion<
+    AbstractFunctionDecl *, AbstractClosureExpr *, DoCatchStmt *
+  > {
+public:
+  using PointerUnion::PointerUnion;
+
+  /// Determine the thrown error type within the region of this catch node
+  /// where it will catch (and possibly rethrow) errors. All of the errors
+  /// thrown from within that region will be converted to this error type.
+  ///
+  /// Returns the thrown error type for a throwing context, or \c llvm::None
+  /// if this is a non-throwing context.
+  llvm::Optional<Type> getThrownErrorTypeInContext(ASTContext &ctx) const;
+};
+
+} // end namespace swift
+
+#endif // SWIFT_AST_CATCHNODE_H

include/swift/AST/DiagnosticsFrontend.def

@@ -494,7 +494,7 @@ ERROR(error_caching_no_cas_fs, none,
 ERROR(error_prefix_mapping, none, "cannot create scanner prefix mapping: '%0'", (StringRef))
 
 REMARK(replay_output, none, "replay output file '%0': key '%1'", (StringRef, StringRef))
-REMARK(output_cache_miss, none, "cache miss output file '%0': key '%1'", (StringRef, StringRef))
+REMARK(output_cache_miss, none, "cache miss for input file '%0': key '%1'", (StringRef, StringRef))
 
 // CAS related diagnostics
 ERROR(error_invalid_cas_id, none, "invalid CASID '%0' (%1)", (StringRef, StringRef))
@@ -536,9 +536,6 @@ REMARK(warning_in_access_notes_file,none,
        "ignored invalid content in access notes file: %0",
        (StringRef))
 
-WARNING(compiler_plugin_not_loaded,none,
-        "compiler plugin not loaded: %0; loader error: %1", (StringRef, StringRef))
-        
 ERROR(dont_enable_interop_and_compat,none,
       "do not pass both '-enable-experimental-cxx-interop' and "
       "'-cxx-interoperability-mode'; remove '-enable-experimental-cxx-interop'", ())

include/swift/AST/DiagnosticsSema.def

@@ -5304,6 +5304,9 @@ ERROR(local_function_executed_concurrently,none,
 ERROR(sendable_isolated_sync_function,none,
       "%0 synchronous %kind1 cannot be marked as '@Sendable'",
       (ActorIsolation, const ValueDecl *))
+ERROR(nonsendable_instance_method,none,
+      "instance methods of non-Sendable types cannot be marked as '@Sendable'",
+      ())
 ERROR(concurrent_access_of_local_capture,none,
       "%select{mutation of|reference to}0 captured %kind1 in "
       "concurrently-executing code",
@@ -7312,7 +7315,7 @@ ERROR(macro_undefined,PointsToFirstBadToken,
       "no macro named %0", (Identifier))
 ERROR(external_macro_not_found,none,
       "external macro implementation type '%0.%1' could not be found for "
-      "macro %2", (StringRef, StringRef, DeclName))
+      "macro %2; %3", (StringRef, StringRef, DeclName, StringRef))
 ERROR(macro_must_be_defined,none,
       "macro %0 requires a definition", (DeclName))
 ERROR(external_macro_outside_macro_definition,none,

include/swift/AST/MacroDefinition.h

@@ -18,6 +18,7 @@
 #ifndef SWIFT_AST_MACRO_DEFINITION_H
 #define SWIFT_AST_MACRO_DEFINITION_H
 
+#include "swift/Basic/StringExtras.h"
 #include "llvm/ADT/PointerUnion.h"
 
 namespace swift {
@@ -26,14 +27,25 @@ class ASTContext;
 
 /// A reference to an external macro definition that is understood by ASTGen.
 struct ExternalMacroDefinition {
-  enum class PluginKind {
+  enum class PluginKind : int8_t {
     InProcess = 0,
     Executable = 1,
+    Error = -1,
   };
   PluginKind kind;
   /// ASTGen's notion of an macro definition, which is opaque to the C++ part
-  /// of the compiler.
-  void *opaqueHandle = nullptr;
+  /// of the compiler. If 'kind' is 'PluginKind::Error', this is a C-string to
+  /// the error message
+  const void *opaqueHandle = nullptr;
+
+  static ExternalMacroDefinition error(NullTerminatedStringRef message) {
+    return ExternalMacroDefinition{PluginKind::Error,
+                                   static_cast<const void *>(message.data())};
+  }
+  bool isError() const { return kind == PluginKind::Error; }
+  NullTerminatedStringRef getErrorMessage() const {
+    return static_cast<const char *>(opaqueHandle);
+  }
 };
 
 /// A reference to an external macro.

include/swift/AST/NameLookup.h

@@ -18,6 +18,7 @@
 #define SWIFT_AST_NAME_LOOKUP_H
 
 #include "swift/AST/ASTVisitor.h"
+#include "swift/AST/CatchNode.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/Module.h"
@@ -833,6 +834,25 @@ class ASTScope : public ASTAllocated<ASTScope> {
       SourceFile *sourceFile, SourceLoc loc,
       llvm::function_ref<bool(PotentialMacro macro)> consume);
 
+  /// Look up the scope tree for the nearest point at which an error thrown from
+  /// this location can be caught or rethrown.
+  ///
+  /// For example, given this code:
+  ///
+  /// \code
+  /// func f() throws {
+  ///   do {
+  ///     try g() // A
+  ///   } catch {
+  ///     throw ErrorWrapper(error) // B
+  ///   }
+  /// }
+  /// \endcode
+  ///
+  /// At the point marked A, the catch node is the enclosing do...catch
+  /// statement. At the point marked B, the catch node is the function itself.
+  static CatchNode lookupCatchNode(ModuleDecl *module, SourceLoc loc);
+
   SWIFT_DEBUG_DUMP;
   void print(llvm::raw_ostream &) const;
   void dumpOneScopeMapLocation(std::pair<unsigned, unsigned>);

include/swift/AST/PluginLoader.h

@@ -76,14 +76,15 @@ class PluginLoader {
   /// returns a nullptr.
   /// NOTE: This method is idempotent. If the plugin is already loaded, the same
   /// instance is simply returned.
-  LoadedLibraryPlugin *loadLibraryPlugin(llvm::StringRef path);
+  llvm::Expected<LoadedLibraryPlugin *> loadLibraryPlugin(llvm::StringRef path);
 
   /// Launch the specified executable plugin path resolving the path with the
   /// current VFS. If it fails to load the plugin, a diagnostic is emitted, and
   /// returns a nullptr.
   /// NOTE: This method is idempotent. If the plugin is already loaded, the same
   /// instance is simply returned.
-  LoadedExecutablePlugin *loadExecutablePlugin(llvm::StringRef path);
+  llvm::Expected<LoadedExecutablePlugin *>
+  loadExecutablePlugin(llvm::StringRef path);
 };
 
 } // namespace swift

include/swift/AST/PluginRegistry.h

@@ -33,11 +33,19 @@ class LoadedLibraryPlugin {
   /// Cache of loaded symbols.
   llvm::StringMap<void *> resolvedSymbols;
 
+  /// Path to the plugin library.
+  const std::string LibraryPath;
+
 public:
-  LoadedLibraryPlugin(void *handle) : handle(handle) {}
+  LoadedLibraryPlugin(void *handle, StringRef path)
+      : handle(handle), LibraryPath(path) {}
 
   /// Finds the address of the given symbol within the library.
   void *getAddressOfSymbol(const char *symbolName);
+
+  NullTerminatedStringRef getLibraryPath() {
+    return {LibraryPath.c_str(), LibraryPath.size()};
+  }
 };
 
 /// Represent a "resolved" executable plugin.