Merge pull request #5409 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -23,10 +23,9 @@ public struct CalleeAnalysis {
         return inst.instruction.isDeinitBarrier(bca.analysis)
       },
       // getMemBehaviorFn
-      { (bridgedCtxt: BridgedPassContext, bridgedApply: BridgedInstruction, observeRetains: Bool) -> swift.MemoryBehavior in
-        let context = FunctionPassContext(_bridged: bridgedCtxt)
+      { (bridgedApply: BridgedInstruction, observeRetains: Bool, bca: BridgedCalleeAnalysis) -> swift.MemoryBehavior in
         let apply = bridgedApply.instruction as! ApplySite
-        let e = context.calleeAnalysis.getSideEffects(of: apply)
+        let e = bca.analysis.getSideEffects(of: apply)
         return e.getMemBehavior(observeRetains: observeRetains)
       }
     )

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -361,10 +361,6 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
     case is ApplyInst, is TryApplyInst, is BeginApplyInst:
       return walkDownCallee(argOp: operand, apply: instruction as! FullApplySite, path: path)
     case let pai as PartialApplyInst:
-      // This is a non-stack closure.
-      // For `stack` closures, `hasRelevantType` in `walkDown` will return false
-      // stopping the walk since they don't escape.
-      
       // Check whether the partially applied argument can escape in the body.
       if walkDownCallee(argOp: operand, apply: pai, path: path.with(knownType: nil)) == .abortWalk {
         return .abortWalk
@@ -376,8 +372,9 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       // 2. something can escape in a destructor when the context is destroyed
       return walkDownUses(ofValue: pai, path: path.with(knownType: nil))
     case let pta as PointerToAddressInst:
-      assert(operand.index == 0)
       return walkDownUses(ofAddress: pta, path: path.with(knownType: nil))
+    case let cv as ConvertFunctionInst:
+      return walkDownUses(ofValue: cv, path: path.with(knownType: nil))
     case let bi as BuiltinInst:
       switch bi.id {
       case .DestroyArray:
@@ -561,6 +558,12 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       return .continueWalk
     }
 
+    if argOp.value.type.isNoEscapeFunction {
+      // Per definition a `partial_apply [on_stack]` cannot escape the callee.
+      // Potential escapes of its captured values are already handled when visiting the `partial_apply`.
+      return .continueWalk
+    }
+
     // Argument effects do not consider any potential stores to the argument (or it's content).
     // Therefore, if we need to track stores, the argument effects do not correctly describe what we need.
     // For example, argument 0 in the following function is marked as not-escaping, although there

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -41,6 +41,7 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
   public var isEnum: Bool { bridged.getEnumOrBoundGenericEnum() != nil }
   public var isFunction: Bool { bridged.isFunction() }
   public var isMetatype: Bool { bridged.isMetatype() }
+  public var isNoEscapeFunction: Bool { bridged.isNoEscapeFunction() }
 
   /// Can only be used if the type is in fact a nominal type (`isNominal` is true).
   public var nominal: NominalTypeDecl {

cmake/modules/SwiftSetIfArchBitness.cmake

@@ -14,6 +14,8 @@ function(set_if_arch_bitness var_name)
      "${SIA_ARCH}" STREQUAL "armv7" OR
      "${SIA_ARCH}" STREQUAL "armv7k" OR
      "${SIA_ARCH}" STREQUAL "arm64_32" OR
+     "${SIA_ARCH}" STREQUAL "armv7m" OR
+     "${SIA_ARCH}" STREQUAL "armv7em" OR
      "${SIA_ARCH}" STREQUAL "armv7s" OR
      "${SIA_ARCH}" STREQUAL "wasm32" OR
      "${SIA_ARCH}" STREQUAL "powerpc")

include/swift/AST/ASTWalker.h

@@ -48,6 +48,7 @@ struct ReferenceMetaData {
   SemaReferenceKind Kind;
   llvm::Optional<AccessKind> AccKind;
   bool isImplicit = false;
+  bool isImplicitCtorType = false;
 
   /// When non-none, this is a custom attribute reference.
   Optional<std::pair<const CustomAttr *, Decl *>> CustomAttrRef;

include/swift/AST/Decl.h

@@ -8876,6 +8876,10 @@ const ParamDecl *getParameterAt(ConcreteDeclRef declRef, unsigned index);
 /// nullptr if the source does not have a parameter list.
 const ParamDecl *getParameterAt(const ValueDecl *source, unsigned index);
 
+/// Retrieve parameter declaration from the given source at given index, or
+/// nullptr if the source does not have a parameter list.
+const ParamDecl *getParameterAt(const DeclContext *source, unsigned index);
+
 void simple_display(llvm::raw_ostream &out,
                     OptionSet<NominalTypeDecl::LookupDirectFlags> options);
 

include/swift/AST/DiagnosticsClangImporter.def

@@ -156,6 +156,7 @@ NOTE(macro_not_imported, none, "macro '%0' unavailable (cannot import)", (String
 
 NOTE(return_type_not_imported, none, "return type unavailable (cannot import)", ())
 NOTE(parameter_type_not_imported, none, "parameter %0 unavailable (cannot import)", (const clang::NamedDecl*))
+NOTE(rvalue_ref_params_not_imported, none, "C++ functions with rvalue reference parameters are unavailable in Swift", ())
 NOTE(incomplete_interface, none, "interface %0 is incomplete", (const clang::NamedDecl*))
 NOTE(incomplete_protocol, none, "protocol %0 is incomplete", (const clang::NamedDecl*))
 NOTE(incomplete_record, none, "record '%0' is not defined (incomplete)", (StringRef))
@@ -195,7 +196,7 @@ NOTE(mark_safe_to_import, none, "annotate method '%0' with 'SWIFT_RETURNS_INDEPE
 NOTE(at_to_subscript, none, "do you want to replace it with a call "
                             "to the subscript operator?",
      ())
-NOTE(get_swift_iterator, none, "do you want to make a Swift iterator instead?",
+NOTE(use_collection_apis, none, "do you want to use a for-in loop instead?",
      ())
 NOTE(replace_with_nil, none, "do you want to compare against 'nil' instead?",
      ())

include/swift/AST/DiagnosticsSema.def

@@ -7123,6 +7123,11 @@ ERROR(moveonly_parameter_missing_ownership, none,
       "noncopyable parameter must specify its ownership", ())
 NOTE(moveonly_parameter_ownership_suggestion, none,
       "add '%0' %1", (StringRef, StringRef))
+ERROR(ownership_specifier_copyable,none,
+      "Copyable types cannot be 'consuming' or 'borrowing' yet", ())
+ERROR(self_ownership_specifier_copyable,none,
+      "%0 is not yet valid on %1s in a Copyable type",
+      (SelfAccessKind, DescriptiveDeclKind))
 
 //------------------------------------------------------------------------------
 // MARK: Runtime discoverable attributes (@runtimeMetadata)

include/swift/AST/TypeCheckRequests.h

@@ -3258,17 +3258,17 @@ void simple_display(llvm::raw_ostream &out,
 class ResolveMacroRequest
     : public SimpleRequest<ResolveMacroRequest,
                            ConcreteDeclRef(UnresolvedMacroReference,
-                                           const Decl *),
+                                           DeclContext *),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  ConcreteDeclRef
-  evaluate(Evaluator &evaluator, UnresolvedMacroReference macroRef,
-           const Decl *decl) const;
+  ConcreteDeclRef evaluate(Evaluator &evaluator,
+                           UnresolvedMacroReference macroRef,
+                           DeclContext *decl) const;
 
 public:
   bool isCached() const { return true; }

include/swift/ClangImporter/ClangImporter.h

@@ -588,6 +588,14 @@ namespace importer {
 /// Returns true if the given module has a 'cplusplus' requirement.
 bool requiresCPlusPlus(const clang::Module *module);
 
+/// Returns the pointee type if the given type is a C++ `const`
+/// reference type, `None` otherwise.
+llvm::Optional<clang::QualType>
+getCxxReferencePointeeTypeOrNone(const clang::Type *type);
+
+/// Returns true if the given type is a C++ `const` reference type.
+bool isCxxConstReferenceType(const clang::Type *type);
+
 } // namespace importer
 
 struct ClangInvocationFileMapping {