Merge pull request #5272 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/DiagnosticsFrontend.def

@@ -271,6 +271,17 @@ REMARK(remark_indexing_system_module,none,
        "%select{|; skipping because of a broken swiftinterface}1",
        (StringRef, bool))
 
+ERROR(error_create_symbolic_interfaces_dir,none,
+      "creating symbolic interfaces directory: %0", (StringRef))
+ERROR(error_symbolic_interfaces_failed_status_check,none,
+      "failed file status check: %0", (StringRef))
+ERROR(error_write_symbolic_interface,none,
+      "writing symbolic interface file: %0", (StringRef))
+REMARK(remark_emitting_symbolic_interface_module,none,
+       "emitting symbolic interface at %0"
+       "%select{|; skipping because it's up to date}1",
+       (StringRef, bool))
+
 ERROR(error_wrong_number_of_arguments,none,
       "wrong number of '%0' arguments (expected %1, got %2)",
       (StringRef, int, int))

include/swift/AST/DiagnosticsSema.def

@@ -6681,6 +6681,8 @@ ERROR(noimplicitcopy_attr_not_allowed_on_moveonlytype,none,
       "'@_noImplicitCopy' has no effect when applied to a move only type", ())
 ERROR(moveonly_enums_do_not_support_indirect,none,
       "move-only enum %0 cannot be marked indirect or have indirect cases yet", (Identifier))
+ERROR(moveonly_cast,none,
+      "move-only types cannot be conditionally cast", ())
 
 //------------------------------------------------------------------------------
 // MARK: Type inference from default expressions

include/swift/AST/PrintOptions.h

@@ -318,6 +318,9 @@ struct PrintOptions {
   /// Suppress emitting @available(*, noasync)
   bool SuppressNoAsyncAvailabilityAttr = false;
 
+  /// Whether to print the \c{/*not inherited*/} comment on factory initializers.
+  bool PrintFactoryInitializerComment = true;
+
   /// How to print opaque return types.
   enum class OpaqueReturnTypePrintingMode {
     /// 'some P1 & P2'.

include/swift/Basic/Features.def

@@ -167,6 +167,11 @@ EXPERIMENTAL_FEATURE(BuiltinMacros, false)
 /// declare an attribute which is discoverable and constructable at runtime.
 EXPERIMENTAL_FEATURE(RuntimeDiscoverableAttrs, false)
 
+/// Import C++ class templates as semantically-meaningless symbolic
+/// Swift types and C++ methods as symbolic functions with blank
+/// signatures.
+EXPERIMENTAL_FEATURE(ImportSymbolicCXXDecls, false)
+
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE
 #undef SUPPRESSIBLE_LANGUAGE_FEATURE

include/swift/ClangImporter/ClangImporter.h

@@ -555,6 +555,9 @@ class ClangImporter final : public ClangModuleLoader {
   /// Emit diagnostics for declarations named name that are members
   /// of the provided baseType.
   void diagnoseMemberValue(const DeclName &name, const Type &baseType) override;
+
+  /// Enable the symbolic import experimental feature for the given callback.
+  void withSymbolicFeatureEnabled(llvm::function_ref<void(void)> callback);
 };
 
 ImportDecl *createImportDecl(ASTContext &Ctx, DeclContext *DC, ClangNode ClangN,
@@ -569,6 +572,13 @@ getModuleCachePathFromClang(const clang::CompilerInstance &Instance);
 /// Whether the given parameter name identifies a completion handler.
 bool isCompletionHandlerParamName(StringRef paramName);
 
+namespace importer {
+
+/// Returns true if the given module has a 'cplusplus' requirement.
+bool requiresCPlusPlus(const clang::Module *module);
+
+} // namespace importer
+
 } // end namespace swift
 
 #endif

include/swift/IDE/ModuleInterfacePrinting.h

@@ -19,6 +19,10 @@
 #include <string>
 #include <vector>
 
+namespace clang {
+class Module;
+}
+
 namespace swift {
 class ASTContext;
 class ASTPrinter;
@@ -68,6 +72,10 @@ void printHeaderInterface(StringRef Filename, ASTContext &Ctx,
 void printSwiftSourceInterface(SourceFile &File, ASTPrinter &Printer,
                                const PrintOptions &Options);
 
+/// Print the symbolic Swift interface for a given imported clang module.
+void printSymbolicSwiftClangModuleInterface(ModuleDecl *M, ASTPrinter &Printer,
+                                            const clang::Module *clangModule);
+
 } // namespace ide
 
 } // namespace swift

include/swift/Runtime/Bincompat.h

@@ -38,6 +38,9 @@ bool useLegacyOptionalNilInjectionInCasting();
 /// Obj-C interop
 bool useLegacyObjCBoxingInCasting();
 
+/// Whether to use legacy semantics when unboxing __SwiftValue
+bool useLegacySwiftValueUnboxingInCasting();
+
 } // namespace bincompat
 
 } // namespace runtime

include/swift/Runtime/Concurrency.h

@@ -729,6 +729,13 @@ void swift_task_enqueueGlobalWithDeadline(long long sec, long long nsec,
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_enqueueMainExecutor(Job *job);
 
+/// Return true if the caller is running in a Task on the passed Executor.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+bool swift_task_isOnExecutor(
+    HeapObject * executor,
+    const Metadata *selfType,
+    const SerialExecutorWitnessTable *wtable);
+
 #if SWIFT_CONCURRENCY_ENABLE_DISPATCH
 
 /// Enqueue the given job on the main executor.
@@ -766,6 +773,17 @@ SWIFT_CC(swift) void (*swift_task_enqueueGlobalWithDeadline_hook)(
     int clock, Job *job,
     swift_task_enqueueGlobalWithDeadline_original original);
 
+typedef SWIFT_CC(swift) bool (*swift_task_isOnExecutor_original)(
+    HeapObject *executor,
+    const Metadata *selfType,
+    const SerialExecutorWitnessTable *wtable);
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swift) bool (*swift_task_isOnExecutor_hook)(
+    HeapObject *executor,
+    const Metadata *selfType,
+    const SerialExecutorWitnessTable *wtable,
+    swift_task_isOnExecutor_original original);
+
 /// A hook to take over main executor enqueueing.
 typedef SWIFT_CC(swift) void (*swift_task_enqueueMainExecutor_original)(
     Job *job);

include/swift/SIL/OwnershipUtils.h

@@ -9,36 +9,6 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-///
-/// Terminology:
-///
-/// Simple liveness:
-/// - Ends at lifetime-ending operations.
-/// - Transitively follows guaranteed forwarding operations and address uses
-///   within the current scope.
-/// - Assumes inner scopes are complete, including borrow and address scopes
-/// - Rarely returns AddressUseKind::PointerEscape.
-/// - Per-definition dominance holds
-/// - Insulates outer scopes from inner scope details. Maintains the
-///   invariant that inlining cannot pessimize optimization.
-///
-/// Transitive liveness
-/// - Transitively follows uses within inner scopes, including forwarding
-///   operations and address uses.
-/// - Much more likely to returns AddressUseKind::PointerEscape
-/// - Per-definition dominance holds
-/// - Does not assume that any scopes are complete.
-///
-/// Extended liveness (copy-extension and reborrow-extension)
-/// - Extends a live range across lifetime-ending operations
-/// - Depending on context: owned values are extended across copies or
-///   guaranteed values are extended across reborrows
-/// - Copy-extension is used to canonicalize an OSSA lifetime
-/// - Reborrow-extension is used to check borrow scopes relative to its inner
-///   uses and outer lifetime
-/// - Per-definition dominance does not hold
-///
-//===----------------------------------------------------------------------===//
 
 #ifndef SWIFT_SIL_OWNERSHIPUTILS_H
 #define SWIFT_SIL_OWNERSHIPUTILS_H
@@ -255,6 +225,10 @@ bool findUsesOfSimpleValue(SILValue value,
 bool visitGuaranteedForwardingPhisForSSAValue(
     SILValue value, function_ref<bool(Operand *)> func);
 
+//===----------------------------------------------------------------------===//
+//                                Abstractions
+//===----------------------------------------------------------------------===//
+
 /// An operand that forwards ownership to one or more results.
 class ForwardingOperand {
   Operand *use = nullptr;
@@ -1312,13 +1286,16 @@ void visitExtendedGuaranteedForwardingPhiBaseValuePairs(
 bool visitForwardedGuaranteedOperands(
   SILValue value, function_ref<void(Operand *)> visitOperand);
 
-/// Visit the phis in the same block as \p phi which are reborrows of a borrow
-/// of one of the values reaching \p phi.
+
+/// Return true of the lifetime of \p innerPhiVal depends on \p outerPhiVal.
+bool isInnerAdjacentPhi(SILArgument *innerPhiVal, SILArgument *outerPhiVal);
+
+/// Visit the phis in the same block as \p phi whose lifetime depends on \p phi.
 ///
 /// If the visitor returns false, stops visiting and returns false.  Otherwise,
 /// returns true.
-bool visitAdjacentReborrowsOfPhi(SILPhiArgument *phi,
-                                 function_ref<bool(SILPhiArgument *)> visitor);
+bool visitInnerAdjacentPhis(SILArgument *phi,
+                            function_ref<bool(SILArgument *)> visitor);
 
 /// Visit each definition of a scope that immediately encloses a guaranteed
 /// value. The guaranteed value effectively keeps these scopes alive.

include/swift/SIL/SILBuilder.h

@@ -1975,6 +1975,22 @@ class SILBuilder {
                               packIndex, openedElementEnvironment));
   }
 
+  PackElementGetInst *
+  createPackElementGet(SILLocation loc, SILValue packIndex,
+                       SILValue pack, SILType elementType) {
+    return insert(PackElementGetInst::create(getFunction(),
+                              getSILDebugLocation(loc),
+                              packIndex, pack, elementType));
+  }
+
+  PackElementSetInst *
+  createPackElementSet(SILLocation loc, SILValue elementValue,
+                       SILValue packIndex, SILValue pack) {
+    return insert(new (getModule()) PackElementSetInst(
+                              getSILDebugLocation(loc),
+                              elementValue, packIndex, pack));
+  }
+
   ProjectBlockStorageInst *createProjectBlockStorage(SILLocation Loc,
                                                      SILValue Storage) {
     auto CaptureTy = Storage->getType()

include/swift/SIL/SILCloner.h

@@ -2515,6 +2515,30 @@ void SILCloner<ImplClass>::visitOpenPackElementInst(
       Inst, getBuilder().createOpenPackElement(loc, newIndexValue, newEnv));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitPackElementGetInst(PackElementGetInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  auto loc = getOpLocation(Inst->getLoc());
+  auto newIndex = getOpValue(Inst->getIndex());
+  auto newPack = getOpValue(Inst->getPack());
+  auto newElementType = getOpType(Inst->getElementType());
+  recordClonedInstruction(
+      Inst, getBuilder().createPackElementGet(loc, newIndex, newPack,
+                                              newElementType));
+}
+
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitPackElementSetInst(PackElementSetInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  auto loc = getOpLocation(Inst->getLoc());
+  auto newElementValue = getOpValue(Inst->getValue());
+  auto newIndex = getOpValue(Inst->getIndex());
+  auto newPack = getOpValue(Inst->getPack());
+  recordClonedInstruction(
+      Inst, getBuilder().createPackElementSet(loc, newElementValue,
+                                              newIndex, newPack));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitCopyBlockInst(CopyBlockInst *Inst) {

include/swift/SIL/SILInstruction.h

@@ -7654,6 +7654,99 @@ class OpenPackElementInst final
   }
 };
 
+/// Get the value previously stored in a pack by pack_element_set.
+class PackElementGetInst final
+  : public InstructionBaseWithTrailingOperands<
+                           SILInstructionKind::PackElementGetInst,
+                           PackElementGetInst, SingleValueInstruction> {
+public:
+  enum {
+    IndexOperand = 0,
+    PackOperand = 1
+  };
+
+private:
+  friend SILBuilder;
+
+  PackElementGetInst(SILDebugLocation debugLoc,
+                     ArrayRef<SILValue> allOperands,
+                     SILType elementType)
+      : InstructionBaseWithTrailingOperands(allOperands, debugLoc,
+                                            elementType) {}
+
+  static PackElementGetInst *create(SILFunction &F,
+                                    SILDebugLocation debugLoc,
+                                    SILValue indexOperand,
+                                    SILValue packOperand,
+                                    SILType elementType);
+
+public:
+  SILValue getIndex() const {
+    return getAllOperands()[IndexOperand].get();
+  }
+
+  SILValue getPack() const {
+    return getAllOperands()[PackOperand].get();
+  }
+
+  CanSILPackType getPackType() const {
+    return getPack()->getType().castTo<SILPackType>();
+  }
+
+  SILType getElementType() const {
+    return getType();
+  }
+};
+
+/// Set the value stored in a pack.
+class PackElementSetInst
+  : public InstructionBase<SILInstructionKind::PackElementSetInst,
+                           NonValueInstruction> {
+public:
+  enum {
+    ValueOperand = 0,
+    IndexOperand = 1,
+    PackOperand = 2
+  };
+
+private:
+  friend SILBuilder;
+
+  FixedOperandList<3> Operands;
+
+  PackElementSetInst(SILDebugLocation debugLoc,
+                     SILValue valueOperand, SILValue indexOperand,
+                     SILValue packOperand)
+      : InstructionBase(debugLoc),
+        Operands(this, valueOperand, indexOperand, packOperand) {
+    assert(packOperand->getType().is<SILPackType>());
+  }
+
+public:
+  ArrayRef<Operand> getAllOperands() const { return Operands.asArray(); }
+  MutableArrayRef<Operand> getAllOperands() { return Operands.asArray(); }
+
+  SILValue getValue() const {
+    return getAllOperands()[ValueOperand].get();
+  }
+
+  SILValue getIndex() const {
+    return getAllOperands()[IndexOperand].get();
+  }
+
+  SILValue getPack() const {
+    return getAllOperands()[PackOperand].get();
+  }
+
+  CanSILPackType getPackType() const {
+    return getPack()->getType().castTo<SILPackType>();
+  }
+
+  SILType getElementType() const {
+    return getValue()->getType();
+  }
+};
+
 /// Projects the capture storage address from a @block_storage address.
 class ProjectBlockStorageInst
   : public UnaryInstructionBase<SILInstructionKind::ProjectBlockStorageInst,

include/swift/SIL/SILNodes.def

@@ -550,6 +550,8 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
                     SingleValueInstruction, None, DoesNotRelease)
   SINGLE_VALUE_INST(TupleElementAddrInst, tuple_element_addr,
                     SingleValueInstruction, None, DoesNotRelease)
+  SINGLE_VALUE_INST(PackElementGetInst, pack_element_get,
+                    SingleValueInstruction, None, DoesNotRelease)
   SINGLE_VALUE_INST(StructInst, struct,
                     SingleValueInstruction, None, DoesNotRelease)
   SINGLE_VALUE_INST(StructExtractInst, struct_extract,
@@ -816,6 +818,8 @@ NON_VALUE_INST(EndApplyInst, end_apply,
                SILInstruction, MayHaveSideEffects, MayRelease)
 NON_VALUE_INST(AbortApplyInst, abort_apply,
                SILInstruction, MayHaveSideEffects, MayRelease)
+NON_VALUE_INST(PackElementSetInst, pack_element_set,
+               SILInstruction, MayHaveSideEffects, DoesNotRelease)
 
 // Runtime failure
 // FIXME: Special MemBehavior for runtime failure?

lib/AST/ASTPrinter.cpp

@@ -3169,6 +3169,8 @@ static bool usesFeatureBuiltinMacros(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureImportSymbolicCXXDecls(Decl *decl) { return false; }
+
 static void
 suppressingFeatureNoAsyncAvailability(PrintOptions &options,
                                       llvm::function_ref<void()> action) {
@@ -4373,7 +4375,9 @@ void PrintAST::visitConstructorDecl(ConstructorDecl *decl) {
              "unexpected convenience initializer");
     }
   } else if (decl->getInitKind() == CtorInitializerKind::Factory) {
-    Printer << "/*not inherited*/ ";
+    if (Options.PrintFactoryInitializerComment) {
+      Printer << "/*not inherited*/ ";
+    }
   }
 
   printContextIfNeeded(decl);