Merge pull request #2585 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

include/swift/AST/DiagnosticsSema.def

@@ -719,11 +719,10 @@ ERROR(sema_opening_import,Fatal,
 ERROR(serialization_load_failed,Fatal,
       "failed to load module '%0'", (StringRef))
 ERROR(module_interface_build_failed,Fatal,
-      "failed to %select{build module '%1' from its module interface|verify "
-      "module interface of '%1'}0; %select{the compiler that produced it, "
-      "'%3', may have used features that aren't supported by this compiler, "
-      "'%4'|it may have been damaged or it may have triggered a bug in the "
-      "Swift compiler when it was produced}2",
+      "failed to %select{build module '%1' for importation|"
+      "verify module interface of '%1'}0 due to the errors above; "
+      "the textual interface may be broken by project issues"
+      "%select{, differences between compilers (the producer '%3' and this compiler '%4')|}2 or a compiler bug",
       (bool, StringRef, bool, StringRef, StringRef))
 ERROR(serialization_malformed_module,Fatal,
       "malformed compiled module: %0", (StringRef))

include/swift/AST/PrintOptions.h

@@ -504,7 +504,8 @@ struct PrintOptions {
   }
 
   /// Retrieve the set of options suitable for diagnostics printing.
-  static PrintOptions printForDiagnostics(AccessLevel accessFilter) {
+  static PrintOptions printForDiagnostics(AccessLevel accessFilter,
+                                          bool printFullConvention) {
     PrintOptions result = printVerbose();
     result.PrintAccess = true;
     result.Indent = 4;
@@ -523,12 +524,16 @@ struct PrintOptions {
         QualifyNestedDeclarations::TypesOnly;
     result.PrintDocumentationComments = false;
     result.PrintCurrentMembersOnly = true;
+    if (printFullConvention)
+      result.PrintFunctionRepresentationAttrs =
+          PrintOptions::FunctionRepresentationMode::Full;
     return result;
   }
 
   /// Retrieve the set of options suitable for interface generation.
-  static PrintOptions printInterface() {
-    PrintOptions result = printForDiagnostics(AccessLevel::Public);
+  static PrintOptions printInterface(bool printFullConvention) {
+    PrintOptions result =
+        printForDiagnostics(AccessLevel::Public, printFullConvention);
     result.SkipUnavailable = true;
     result.SkipImplicit = true;
     result.SkipSwiftPrivateClangDecls = true;
@@ -565,8 +570,8 @@ struct PrintOptions {
   /// Retrieve the set of options suitable for "Generated Interfaces", which
   /// are a prettified representation of the public API of a module, to be
   /// displayed to users in an editor.
-  static PrintOptions printModuleInterface();
-  static PrintOptions printTypeInterface(Type T);
+  static PrintOptions printModuleInterface(bool printFullConvention);
+  static PrintOptions printTypeInterface(Type T, bool printFullConvention);
 
   void setBaseType(Type T);
 
@@ -582,16 +587,16 @@ struct PrintOptions {
   }
 
   /// Retrieve the print options that are suitable to print the testable interface.
-  static PrintOptions printTestableInterface() {
-    PrintOptions result = printInterface();
+  static PrintOptions printTestableInterface(bool printFullConvention) {
+    PrintOptions result = printInterface(printFullConvention);
     result.AccessFilter = AccessLevel::Internal;
     return result;
   }
 
   /// Retrieve the print options that are suitable to print interface for a
   /// swift file.
-  static PrintOptions printSwiftFileInterface() {
-    PrintOptions result = printInterface();
+  static PrintOptions printSwiftFileInterface(bool printFullConvention) {
+    PrintOptions result = printInterface(printFullConvention);
     result.AccessFilter = AccessLevel::Internal;
     result.EmptyLineBetweenMembers = true;
     return result;

include/swift/Basic/LangOptions.h

@@ -547,6 +547,9 @@ namespace swift {
     /// Enable experimental support for one-way constraints for the
     /// parameters of closures.
     bool EnableOneWayClosureParameters = false;
+
+    /// See \ref FrontendOptions.PrintFullConvention
+    bool PrintFullConvention = false;
   };
 
   /// Options for controlling the behavior of the Clang importer.

include/swift/SIL/ApplySite.h

@@ -90,30 +90,28 @@ class ApplySite {
 
   SILModule &getModule() const { return Inst->getModule(); }
 
-  static ApplySite isa(SILInstruction *inst) {
-    auto kind = ApplySiteKind::fromNodeKind(inst->getKind());
+  static ApplySite isa(SILNode *node) {
+    auto *i = dyn_cast<SILInstruction>(node);
+    if (!i)
+      return ApplySite();
+
+    auto kind = ApplySiteKind::fromNodeKind(i->getKind());
     if (!kind)
       return ApplySite();
 
     switch (kind.getValue()) {
     case ApplySiteKind::ApplyInst:
-      return ApplySite(cast<ApplyInst>(inst));
+      return ApplySite(cast<ApplyInst>(node));
     case ApplySiteKind::BeginApplyInst:
-      return ApplySite(cast<BeginApplyInst>(inst));
+      return ApplySite(cast<BeginApplyInst>(node));
     case ApplySiteKind::TryApplyInst:
-      return ApplySite(cast<TryApplyInst>(inst));
+      return ApplySite(cast<TryApplyInst>(node));
     case ApplySiteKind::PartialApplyInst:
-      return ApplySite(cast<PartialApplyInst>(inst));
+      return ApplySite(cast<PartialApplyInst>(node));
     }
     llvm_unreachable("covered switch");
   }
 
-  static ApplySite isa(SILValue value) {
-    if (auto *inst = value->getDefiningInstruction())
-      return ApplySite::isa(inst);
-    return ApplySite();
-  }
-
   ApplySiteKind getKind() const { return ApplySiteKind(Inst->getKind()); }
 
   explicit operator bool() const { return Inst != nullptr; }
@@ -183,8 +181,8 @@ class ApplySite {
   /// Calls to (previous_)dynamic_function_ref have a dynamic target function so
   /// we should not optimize them.
   bool canOptimize() const {
-    return !swift::isa<DynamicFunctionRefInst>(getCallee()) &&
-      !swift::isa<PreviousDynamicFunctionRefInst>(getCallee());
+    return !DynamicFunctionRefInst::classof(getCallee()) &&
+      !PreviousDynamicFunctionRefInst::classof(getCallee());
   }
 
   /// Return the type.
@@ -495,27 +493,24 @@ class FullApplySite : public ApplySite {
   FullApplySite(BeginApplyInst *inst) : ApplySite(inst) {}
   FullApplySite(TryApplyInst *inst) : ApplySite(inst) {}
 
-  static FullApplySite isa(SILInstruction *inst) {
-    auto kind = FullApplySiteKind::fromNodeKind(inst->getKind());
+  static FullApplySite isa(SILNode *node) {
+    auto *i = dyn_cast<SILInstruction>(node);
+    if (!i)
+      return FullApplySite();
+    auto kind = FullApplySiteKind::fromNodeKind(i->getKind());
     if (!kind)
       return FullApplySite();
     switch (kind.getValue()) {
     case FullApplySiteKind::ApplyInst:
-      return FullApplySite(cast<ApplyInst>(inst));
+      return FullApplySite(cast<ApplyInst>(node));
     case FullApplySiteKind::BeginApplyInst:
-      return FullApplySite(cast<BeginApplyInst>(inst));
+      return FullApplySite(cast<BeginApplyInst>(node));
     case FullApplySiteKind::TryApplyInst:
-      return FullApplySite(cast<TryApplyInst>(inst));
+      return FullApplySite(cast<TryApplyInst>(node));
     }
     llvm_unreachable("covered switch");
   }
 
-  static FullApplySite isa(SILValue value) {
-    if (auto *inst = value->getDefiningInstruction())
-      return FullApplySite::isa(inst);
-    return FullApplySite();
-  }
-
   FullApplySiteKind getKind() const {
     return FullApplySiteKind(getInstruction()->getKind());
   }

include/swift/SIL/DynamicCasts.h

@@ -158,14 +158,17 @@ struct SILDynamicCastInst {
   SILDynamicCastInst(ID *i) : inst(i) {}
 #include "swift/SIL/SILNodes.def"
 
-  static SILDynamicCastInst getAs(SILInstruction *inst) {
-    auto kind = SILDynamicCastKind::fromNodeKind(inst->getKind());
+  static SILDynamicCastInst getAs(SILNode *node) {
+    auto *i = dyn_cast<SILInstruction>(node);
+    if (!i)
+      return SILDynamicCastInst();
+    auto kind = SILDynamicCastKind::fromNodeKind(i->getKind());
     if (!kind)
       return SILDynamicCastInst();
     switch (kind.getValue()) {
 #define DYNAMICCAST_INST(ID, PARENT)                                           \
   case SILDynamicCastKind::ID:                                                 \
-    return SILDynamicCastInst(cast<ID>(inst));
+    return SILDynamicCastInst(cast<ID>(node));
 #include "swift/SIL/SILNodes.def"
     }
   }

include/swift/SIL/PrettyStackTrace.h

@@ -19,12 +19,12 @@
 #define SWIFT_SIL_PRETTYSTACKTRACE_H
 
 #include "swift/SIL/SILLocation.h"
-#include "swift/SIL/SILNode.h"
 #include "llvm/Support/PrettyStackTrace.h"
 
 namespace swift {
 class ASTContext;
 class SILFunction;
+class SILNode;
 
 void printSILLocationDescription(llvm::raw_ostream &out, SILLocation loc,
                                  ASTContext &ctx);
@@ -74,7 +74,7 @@ class PrettyStackTraceSILNode : public llvm::PrettyStackTraceEntry {
   const char *Action;
 
 public:
-  PrettyStackTraceSILNode(const char *action, SILNodePointer node)
+  PrettyStackTraceSILNode(const char *action, const SILNode *node)
     : Node(node), Action(action) {}
 
   virtual void print(llvm::raw_ostream &OS) const override;

include/swift/SIL/SILArgument.h

@@ -78,7 +78,7 @@ class SILArgument : public ValueBase {
   explicit SILArgument(ValueKind subClassKind, SILType type,
                        ValueOwnershipKind ownershipKind,
                        const ValueDecl *inputDecl = nullptr)
-      : ValueBase(subClassKind, type),
+      : ValueBase(subClassKind, type, IsRepresentative::Yes),
         parentBlock(nullptr), decl(inputDecl) {
     Bits.SILArgument.VOKind = static_cast<unsigned>(ownershipKind);
   }
@@ -106,7 +106,7 @@ class SILArgument : public ValueBase {
 
   static bool classof(const SILInstruction *) = delete;
   static bool classof(const SILUndef *) = delete;
-  static bool classof(SILNodePointer node) {
+  static bool classof(const SILNode *node) {
     return node->getKind() >= SILNodeKind::First_SILArgument &&
            node->getKind() <= SILNodeKind::Last_SILArgument;
   }
@@ -279,7 +279,7 @@ class SILPhiArgument : public SILArgument {
 
   static bool classof(const SILInstruction *) = delete;
   static bool classof(const SILUndef *) = delete;
-  static bool classof(SILNodePointer node) {
+  static bool classof(const SILNode *node) {
     return node->getKind() == SILNodeKind::SILPhiArgument;
   }
 };
@@ -322,7 +322,7 @@ class SILFunctionArgument : public SILArgument {
 
   static bool classof(const SILInstruction *) = delete;
   static bool classof(const SILUndef *) = delete;
-  static bool classof(SILNodePointer node) {
+  static bool classof(const SILNode *node) {
     return node->getKind() == SILNodeKind::SILFunctionArgument;
   }
 };