Merge pull request #4615 from swiftwasm/release/5.7

[pull] swiftwasm-release/5.7 from release/5.7

Author: kateinoigakukun

include/swift/AST/DiagnosticsSema.def

@@ -3788,8 +3788,6 @@ ERROR(protocol_declares_unknown_primary_assoc_type,none,
       (Identifier, Type))
 ERROR(protocol_declares_duplicate_primary_assoc_type,none,
       "duplicate primary associated type name %0", (Identifier))
-ERROR(parameterized_protocol_not_supported,none,
-      "protocol type with type arguments can only be used as a generic constraint", ())
 ERROR(protocol_does_not_have_primary_assoc_type,none,
       "cannot specialize protocol type %0", (Type))
 ERROR(parameterized_protocol_type_argument_count_mismatch,none,

include/swift/AST/FileUnit.h

@@ -55,6 +55,12 @@ class FileUnit : public DeclContext, public ASTAllocated<FileUnit> {
   /// Returns the synthesized file for this source file, if it exists.
   SynthesizedFileUnit *getSynthesizedFile() const;
 
+  /// Returns the synthesized file for this source file, creating one and
+  /// inserting it into the module if it does not exist.
+  ///
+  /// \warning Because this function mutates the parent module's list of files,
+  ///          it will invalidate the iterators of any upstream callers of
+  ///          \c ModuleDecl::getFiles().
   SynthesizedFileUnit &getOrCreateSynthesizedFile();
 
   /// Look up a (possibly overloaded) value set at top-level scope

include/swift/AST/Types.h

@@ -6752,38 +6752,6 @@ inline TypeBase *TypeBase::getDesugaredType() {
   return cast<SugarType>(this)->getSinglyDesugaredType()->getDesugaredType();
 }
 
-inline bool TypeBase::hasSimpleTypeRepr() const {
-  // NOTE: Please keep this logic in sync with TypeRepr::isSimple().
-  switch (getKind()) {
-  case TypeKind::Function:
-  case TypeKind::GenericFunction:
-    return false;
-
-  case TypeKind::Metatype:
-    return !cast<const AnyMetatypeType>(this)->hasRepresentation();
-
-  case TypeKind::ExistentialMetatype:
-  case TypeKind::Existential:
-    return false;
-
-  case TypeKind::OpaqueTypeArchetype:
-  case TypeKind::OpenedArchetype:
-    return false;
-
-  case TypeKind::ProtocolComposition: {
-    // 'Any', 'AnyObject' and single protocol compositions are simple
-    auto composition = cast<const ProtocolCompositionType>(this);
-    auto memberCount = composition->getMembers().size();
-    if (composition->hasExplicitAnyObject())
-      return memberCount == 0;
-    return memberCount <= 1;
-  }
-
-  default:
-    return true;
-  }
-}
-
 } // end namespace swift
 
 namespace llvm {

include/swift/SILOptimizer/Utils/Existential.h

@@ -33,7 +33,7 @@ namespace swift {
 /// When successfull, ConcreteExistentialInfo can be used to determine the
 /// concrete type of the opened existential.
 struct OpenedArchetypeInfo {
-  ArchetypeType *OpenedArchetype = nullptr;
+  OpenedArchetypeType *OpenedArchetype = nullptr;
   // The opened value.
   SingleValueInstruction *OpenedArchetypeValue;
   // The existential value.

lib/AST/DiagnosticEngine.cpp

@@ -737,7 +737,7 @@ static void formatDiagnosticArgument(StringRef Modifier,
         llvm::SmallString<256> AkaText;
         llvm::raw_svector_ostream OutAka(AkaText);
 
-        OutAka << getAkaTypeForDisplay(type);
+        getAkaTypeForDisplay(type)->print(OutAka, printOptions);
         Out << llvm::format(FormatOpts.AKAFormatString.c_str(),
                             typeName.c_str(), AkaText.c_str());
       } else {

lib/AST/DistributedDecl.cpp

@@ -491,12 +491,14 @@ bool AbstractFunctionDecl::isDistributedActorSystemRemoteCall(bool isVoidReturn)
     return false;
   }
 
-  // --- Check parameter: invocation InvocationEncoder
-  // FIXME: NOT INOUT, but we crash today if not
+  // --- Check parameter: invocation: inout InvocationEncoder
   auto invocationParam = params->get(2);
   if (invocationParam->getArgumentName() != C.Id_invocation) {
     return false;
   }
+  if (!invocationParam->isInOut()) {
+    return false;
+  }
 
   // --- Check parameter: throwing: Err.Type
   auto thrownTypeParam = params->get(3);

lib/AST/Module.cpp

@@ -3055,6 +3055,15 @@ SynthesizedFileUnit &FileUnit::getOrCreateSynthesizedFile() {
       return *thisSynth;
     SynthesizedFile = new (getASTContext()) SynthesizedFileUnit(*this);
     SynthesizedFileAndKind.setPointer(SynthesizedFile);
+    // FIXME: Mutating the module in-flight is not a good idea. Any
+    // callers above us in the stack that are iterating over
+    // the module's files will have their iterators invalidated. There's
+    // a strong chance that whatever analysis led to this function being
+    // called is doing just that!
+    //
+    // Instead we ought to just call ModuleDecl::clearLookupCache() here
+    // and patch out the places looking for synthesized files hanging off of
+    // source files.
     getParentModule()->addFile(*SynthesizedFile);
   }
   return *SynthesizedFile;

lib/AST/Type.cpp

@@ -6222,6 +6222,46 @@ bool TypeBase::isForeignReferenceType() {
   return false;
 }
 
+bool TypeBase::hasSimpleTypeRepr() const {
+  // NOTE: Please keep this logic in sync with TypeRepr::isSimple().
+  switch (getKind()) {
+  case TypeKind::Function:
+  case TypeKind::GenericFunction:
+    return false;
+
+  case TypeKind::Metatype:
+    return !cast<const AnyMetatypeType>(this)->hasRepresentation();
+
+  case TypeKind::ExistentialMetatype:
+  case TypeKind::Existential:
+    return false;
+
+  case TypeKind::OpaqueTypeArchetype:
+  case TypeKind::OpenedArchetype:
+    return false;
+
+  case TypeKind::ProtocolComposition: {
+    // 'Any', 'AnyObject' and single protocol compositions are simple
+    auto composition = cast<const ProtocolCompositionType>(this);
+    auto memberCount = composition->getMembers().size();
+    if (composition->hasExplicitAnyObject())
+      return memberCount == 0;
+    return memberCount <= 1;
+  }
+
+  case TypeKind::GenericTypeParam: {
+    if (auto *decl = cast<const GenericTypeParamType>(this)->getDecl()) {
+      return !decl->isOpaqueType();
+    }
+
+    return true;
+  }
+
+  default:
+    return true;
+  }
+}
+
 bool CanType::isForeignReferenceType() {
   if (auto *classDecl = getPointer()->lookThroughAllOptionalTypes()->getClassOrBoundGenericClass())
     return classDecl->isForeignReferenceType();

lib/Frontend/Frontend.cpp

@@ -1166,8 +1166,13 @@ bool CompilerInstance::loadPartialModulesAndImplicitImports(
 bool CompilerInstance::forEachFileToTypeCheck(
     llvm::function_ref<bool(SourceFile &)> fn) {
   if (isWholeModuleCompilation()) {
-    for (auto fileName : getMainModule()->getFiles()) {
-      auto *SF = dyn_cast<SourceFile>(fileName);
+    // FIXME: Do not refactor this to use an iterator as long as
+    // ModuleDecl::addFile is called during Sema. Synthesized files pushed
+    // during semantic analysis will cause iterator invalidation here.
+    // See notes in SourceFile::getOrCreateSynthesizedFile() for more.
+    unsigned i = 0;
+    while (i < getMainModule()->getFiles().size()) {
+      auto *SF = dyn_cast<SourceFile>(getMainModule()->getFiles()[i++]);
       if (!SF) {
         continue;
       }

lib/FrontendTool/FrontendTool.cpp

@@ -2092,57 +2092,8 @@ int swift::performFrontend(ArrayRef<const char *> Args,
     PDC.setSuppressOutput(true);
   }
 
-  // Because the serialized diagnostics consumer is initialized here,
-  // diagnostics emitted above, within CompilerInvocation::parseArgs, are never
-  // serialized. This is a non-issue because, in nearly all cases, frontend
-  // arguments are generated by the driver, not directly by a user. The driver
-  // is responsible for emitting diagnostics for its own errors. See SR-2683
-  // for details.
-  std::unique_ptr<DiagnosticConsumer> SerializedConsumerDispatcher =
-      createSerializedDiagnosticConsumerIfNeeded(
-        Invocation.getFrontendOptions().InputsAndOutputs);
-  if (SerializedConsumerDispatcher)
-    Instance->addDiagnosticConsumer(SerializedConsumerDispatcher.get());
-
-  std::unique_ptr<DiagnosticConsumer> FixItsConsumer =
-      createJSONFixItDiagnosticConsumerIfNeeded(Invocation);
-  if (FixItsConsumer)
-    Instance->addDiagnosticConsumer(FixItsConsumer.get());
-
-  if (Invocation.getDiagnosticOptions().UseColor)
-    PDC.forceColors();
-
-  PDC.setPrintEducationalNotes(
-      Invocation.getDiagnosticOptions().PrintEducationalNotes);
-
-  PDC.setFormattingStyle(
-      Invocation.getDiagnosticOptions().PrintedFormattingStyle);
-
-  if (Invocation.getFrontendOptions().PrintStats) {
-    llvm::EnableStatistics();
-  }
-
-  const DiagnosticOptions &diagOpts = Invocation.getDiagnosticOptions();
-  bool verifierEnabled = diagOpts.VerifyMode != DiagnosticOptions::NoVerify;
-
-  std::string InstanceSetupError;
-  if (Instance->setup(Invocation, InstanceSetupError)) {
-    return finishDiagProcessing(1, /*verifierEnabled*/ false);
-  }
-
-  // The compiler instance has been configured; notify our observer.
-  if (observer) {
-    observer->configuredCompiler(*Instance);
-  }
-
-  if (verifierEnabled) {
-    // Suppress printed diagnostic output during the compile if the verifier is
-    // enabled.
-    PDC.setSuppressOutput(true);
-  }
-
-  if (Invocation.getFrontendOptions().FrontendParseableOutput) {
-   const auto &IO = Invocation.getFrontendOptions().InputsAndOutputs;
+  auto emitParseableBeganMessage = [&Invocation, &Args]() {
+    const auto &IO = Invocation.getFrontendOptions().InputsAndOutputs;
     const auto OSPid = getpid();
     const auto ProcInfo = sys::TaskProcessInformation(OSPid);
 
@@ -2171,27 +2122,9 @@ int swift::performFrontend(ArrayRef<const char *> Args,
                        constructDetailedTaskDescription(Invocation, IO.getAllInputs(), Args),
                        OSPid, ProcInfo);
     }
-  }
-
-  int ReturnValue = 0;
-  bool HadError = performCompile(*Instance, ReturnValue, observer);
-
-  if (verifierEnabled) {
-    DiagnosticEngine &diags = Instance->getDiags();
-    if (diags.hasFatalErrorOccurred() &&
-        !Invocation.getDiagnosticOptions().ShowDiagnosticsAfterFatalError) {
-      diags.resetHadAnyError();
-      PDC.setSuppressOutput(false);
-      diags.diagnose(SourceLoc(), diag::verify_encountered_fatal);
-      HadError = true;
-    }
-  }
-
-  auto r = finishDiagProcessing(HadError ? 1 : ReturnValue, verifierEnabled);
-  if (auto *StatsReporter = Instance->getStatsReporter())
-    StatsReporter->noteCurrentProcessExitStatus(r);
+  };
 
-  if (Invocation.getFrontendOptions().FrontendParseableOutput) {
+  auto emitParseableFinishedMessage = [&Invocation, &Args, &FileSpecificDiagnostics](int ExitStatus) {
     const auto &IO = Invocation.getFrontendOptions().InputsAndOutputs;
     const auto OSPid = getpid();
     const auto ProcInfo = sys::TaskProcessInformation(OSPid);
@@ -2217,7 +2150,7 @@ int swift::performFrontend(ArrayRef<const char *> Args,
 
         emitFinishedMessage(llvm::errs(),
                             mapFrontendInvocationToAction(Invocation),
-                            JoinedDiags.str(), r, Pid - idx, ProcInfo);
+                            JoinedDiags.str(), ExitStatus, Pid - idx, ProcInfo);
         return false;
       });
     } else {
@@ -2234,10 +2167,88 @@ int swift::performFrontend(ArrayRef<const char *> Args,
                 std::ostream_iterator<std::string>(JoinedDiags, Delim));
       emitFinishedMessage(llvm::errs(),
                           mapFrontendInvocationToAction(Invocation),
-                          JoinedDiags.str(), r, OSPid, ProcInfo);
+                          JoinedDiags.str(), ExitStatus, OSPid, ProcInfo);
     }
+  };
+
+  // Because the serialized diagnostics consumer is initialized here,
+  // diagnostics emitted above, within CompilerInvocation::parseArgs, are never
+  // serialized. This is a non-issue because, in nearly all cases, frontend
+  // arguments are generated by the driver, not directly by a user. The driver
+  // is responsible for emitting diagnostics for its own errors. See SR-2683
+  // for details.
+  std::unique_ptr<DiagnosticConsumer> SerializedConsumerDispatcher =
+      createSerializedDiagnosticConsumerIfNeeded(
+        Invocation.getFrontendOptions().InputsAndOutputs);
+  if (SerializedConsumerDispatcher)
+    Instance->addDiagnosticConsumer(SerializedConsumerDispatcher.get());
+
+  std::unique_ptr<DiagnosticConsumer> FixItsConsumer =
+      createJSONFixItDiagnosticConsumerIfNeeded(Invocation);
+  if (FixItsConsumer)
+    Instance->addDiagnosticConsumer(FixItsConsumer.get());
+
+  if (Invocation.getDiagnosticOptions().UseColor)
+    PDC.forceColors();
+
+  PDC.setPrintEducationalNotes(
+      Invocation.getDiagnosticOptions().PrintEducationalNotes);
+
+  PDC.setFormattingStyle(
+      Invocation.getDiagnosticOptions().PrintedFormattingStyle);
+
+  if (Invocation.getFrontendOptions().PrintStats) {
+    llvm::EnableStatistics();
   }
 
+
+  if (Invocation.getFrontendOptions().FrontendParseableOutput)
+    emitParseableBeganMessage();
+
+  const DiagnosticOptions &diagOpts = Invocation.getDiagnosticOptions();
+  bool verifierEnabled = diagOpts.VerifyMode != DiagnosticOptions::NoVerify;
+
+  std::string InstanceSetupError;
+  if (Instance->setup(Invocation, InstanceSetupError)) {
+    int ReturnCode = 1;
+    if (Invocation.getFrontendOptions().FrontendParseableOutput)
+      emitParseableFinishedMessage(ReturnCode);
+
+    return finishDiagProcessing(ReturnCode, /*verifierEnabled*/ false);
+  }
+
+  // The compiler instance has been configured; notify our observer.
+  if (observer) {
+    observer->configuredCompiler(*Instance);
+  }
+
+  if (verifierEnabled) {
+    // Suppress printed diagnostic output during the compile if the verifier is
+    // enabled.
+    PDC.setSuppressOutput(true);
+  }
+
+  int ReturnValue = 0;
+  bool HadError = performCompile(*Instance, ReturnValue, observer);
+
+  if (verifierEnabled) {
+    DiagnosticEngine &diags = Instance->getDiags();
+    if (diags.hasFatalErrorOccurred() &&
+        !Invocation.getDiagnosticOptions().ShowDiagnosticsAfterFatalError) {
+      diags.resetHadAnyError();
+      PDC.setSuppressOutput(false);
+      diags.diagnose(SourceLoc(), diag::verify_encountered_fatal);
+      HadError = true;
+    }
+  }
+
+  auto r = finishDiagProcessing(HadError ? 1 : ReturnValue, verifierEnabled);
+  if (auto *StatsReporter = Instance->getStatsReporter())
+    StatsReporter->noteCurrentProcessExitStatus(r);
+
+  if (Invocation.getFrontendOptions().FrontendParseableOutput)
+    emitParseableFinishedMessage(r);
+
   return r;
 }