Merge pull request #4073 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

benchmark/utils/ArgParse.swift

@@ -79,7 +79,7 @@ class ArgumentParser<U> {
     private var optionalArgsMap = [String : String]()
 
     /// Argument holds the name of the command line parameter, its help
-    /// desciption and a rule that's applied to process it.
+    /// description and a rule that's applied to process it.
     ///
     /// The the rule is typically a value processing closure used to convert it
     /// into given type and storing it in the parsing result.

include/swift/AST/Decl.h

@@ -106,6 +106,7 @@ namespace swift {
 
   namespace ast_scope {
   class AbstractPatternEntryScope;
+  class GenericParamScope;
   class PatternEntryDeclScope;
   class PatternEntryInitializerScope;
   } // namespace ast_scope
@@ -1565,6 +1566,7 @@ class PatternBindingEntry {
   friend class PatternBindingInitializer;
   friend class PatternBindingDecl;
   friend class ast_scope::AbstractPatternEntryScope;
+  friend class ast_scope::GenericParamScope;
   friend class ast_scope::PatternEntryDeclScope;
   friend class ast_scope::PatternEntryInitializerScope;
 
@@ -2779,6 +2781,16 @@ class OpaqueTypeDecl final :
     return OpaqueInterfaceGenericSignature.getInnermostGenericParams();
   }
 
+  /// Whether the generic parameters of this opaque type declaration were
+  /// explicit, i.e., for named opaque result types.
+  bool hasExplicitGenericParams() const;
+
+  /// When the generic parameters were explicit, returns the generic parameter
+  /// corresponding to the given ordinal.
+  ///
+  /// Otherwise, returns \c nullptr.
+  GenericTypeParamDecl *getExplicitGenericParam(unsigned ordinal) const;
+
   /// Retrieve the buffer containing the opaque return type
   /// representations that correspond to the opaque generic parameters.
   ArrayRef<OpaqueReturnTypeRepr *> getOpaqueReturnTypeReprs() const {

include/swift/AST/DiagnosticsSema.def

@@ -4134,6 +4134,9 @@ ERROR(opaque_type_no_underlying_type_candidates,none,
 ERROR(opaque_type_mismatched_underlying_type_candidates,none,
       "function declares an opaque return type %0, but the return statements "
       "in its body do not have matching underlying types", (TypeRepr *))
+ERROR(opaque_type_mismatched_underlying_type_candidates_named,none,
+      "function declares an opaque return type %0, but the return statements "
+      "in its body do not have matching underlying types", (Identifier))
 NOTE(opaque_type_underlying_type_candidate_here,none,
      "return statement has underlying type %0", (Type))
 ERROR(opaque_type_self_referential_underlying_type,none,

include/swift/SIL/SILInstruction.h

@@ -368,7 +368,7 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   SILInstructionResultArray getResultsImpl() const;
 
 protected:
-  friend class LibswiftPassInvocation;
+  friend class SwiftPassInvocation;
 
   SILInstruction() {
     NumCreatedInstructions++;

include/swift/SIL/SILInstructionWorklist.h

@@ -67,20 +67,13 @@ template <typename VectorT = std::vector<SILInstruction *>,
 class SILInstructionWorklist : SILInstructionWorklistBase {
   BlotSetVector<SILInstruction *, VectorT, MapT> worklist;
 
-  /// For invoking Swift instruction passes in Swift.
-  LibswiftPassInvocation *libswiftPassInvocation = nullptr;
-
   void operator=(const SILInstructionWorklist &rhs) = delete;
   SILInstructionWorklist(const SILInstructionWorklist &worklist) = delete;
 
 public:
   SILInstructionWorklist(const char *loggingName = "InstructionWorklist")
       : SILInstructionWorklistBase(loggingName) {}
 
-  void setLibswiftPassInvocation(LibswiftPassInvocation *invocation) {
-    libswiftPassInvocation = invocation;
-  }
-
   /// Returns true if the worklist is empty.
   bool isEmpty() const { return worklist.empty(); }
 

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -45,7 +45,7 @@ void executePassPipelinePlan(SILModule *SM, const SILPassPipelinePlan &plan,
                              irgen::IRGenModule *IRMod = nullptr);
 
 /// Utility class to invoke Swift passes.
-class LibswiftPassInvocation {
+class SwiftPassInvocation {
   /// Backlink to the pass manager.
   SILPassManager *passManager;
 
@@ -58,12 +58,14 @@ class LibswiftPassInvocation {
   /// All slabs, allocated by the pass.
   SILModule::SlabList allocatedSlabs;
 
+  void endPassRunChecks();
+
 public:
-  LibswiftPassInvocation(SILPassManager *passManager, SILFunction *function,
+  SwiftPassInvocation(SILPassManager *passManager, SILFunction *function,
                          SILCombiner *silCombiner) :
     passManager(passManager), function(function), silCombiner(silCombiner) {}
 
-  LibswiftPassInvocation(SILPassManager *passManager) :
+  SwiftPassInvocation(SILPassManager *passManager) :
     passManager(passManager) {}
 
   SILPassManager *getPassManager() const { return passManager; }
@@ -81,10 +83,16 @@ class LibswiftPassInvocation {
   void notifyChanges(SILAnalysis::InvalidationKind invalidationKind);
 
   /// Called by the pass manager before the pass starts running.
-  void startPassRun(SILFunction *function);
+  void startFunctionPassRun(SILFunction *function);
+
+  /// Called by the SILCombiner before the instruction pass starts running.
+  void startInstructionPassRun(SILInstruction *inst);
 
   /// Called by the pass manager when the pass has finished.
-  void finishedPassRun();
+  void finishedFunctionPassRun();
+
+  /// Called by the SILCombiner when the instruction pass has finished.
+  void finishedInstructionPassRun();
 };
 
 /// The SIL pass manager.
@@ -126,7 +134,7 @@ class SILPassManager {
   unsigned NumPassesRun = 0;
 
   /// For invoking Swift passes.
-  LibswiftPassInvocation libswiftPassInvocation;
+  SwiftPassInvocation swiftPassInvocation;
 
   /// Change notifications, collected during a bridged pass run.
   SILAnalysis::InvalidationKind changeNotifications =
@@ -201,8 +209,8 @@ class SILPassManager {
   /// pass manager.
   irgen::IRGenModule *getIRGenModule() { return IRMod; }
 
-  LibswiftPassInvocation *getLibswiftPassInvocation() {
-    return &libswiftPassInvocation;
+  SwiftPassInvocation *getSwiftPassInvocation() {
+    return &swiftPassInvocation;
   }
 
   /// Restart the function pass pipeline on the same function
@@ -377,7 +385,7 @@ class SILPassManager {
   void viewCallGraph();
 };
 
-inline void LibswiftPassInvocation::
+inline void SwiftPassInvocation::
 notifyChanges(SILAnalysis::InvalidationKind invalidationKind) {
   passManager->notifyPassChanges(invalidationKind);
 }

lib/AST/ASTMangler.cpp

@@ -1558,7 +1558,17 @@ unsigned ASTMangler::appendBoundGenericArgs(DeclContext *dc,
 
     // If we are generic at this level, emit all of the replacements at
     // this level.
-    if (genericContext->isGeneric()) {
+    bool treatAsGeneric;
+    if (auto opaque = dyn_cast<OpaqueTypeDecl>(decl)) {
+      // For opaque type declarations, the generic parameters of the opaque
+      // type declaration are not part of the mangling, so check whether the
+      // naming declaration has generic parameters.
+      auto namedGenericContext = opaque->getNamingDecl()->getAsGenericContext();
+      treatAsGeneric = namedGenericContext && namedGenericContext->isGeneric();
+    } else {
+      treatAsGeneric = genericContext->isGeneric();
+    }
+    if (treatAsGeneric) {
       auto genericParams = subs.getGenericSignature().getGenericParams();
       unsigned depth = genericParams[currentGenericParamIdx]->getDepth();
       auto replacements = subs.getReplacementTypes();

lib/AST/ASTPrinter.cpp

@@ -4338,9 +4338,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       case PrintOptions::OpaqueReturnTypePrintingMode::Description:
         return true;
       case PrintOptions::OpaqueReturnTypePrintingMode::WithOpaqueKeyword:
-        return false;
+        return opaque->getDecl()->hasExplicitGenericParams();
       case PrintOptions::OpaqueReturnTypePrintingMode::WithoutOpaqueKeyword:
-        return isSimpleUnderPrintOptions(opaque->getExistentialType());
+        return opaque->getDecl()->hasExplicitGenericParams() ||
+            isSimpleUnderPrintOptions(opaque->getExistentialType());
       }
       llvm_unreachable("bad opaque-return-type printing mode");
     }
@@ -5410,11 +5411,28 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   }
 
   void visitOpaqueTypeArchetypeType(OpaqueTypeArchetypeType *T) {
+    // Try to print a named opaque type.
+    auto printNamedOpaque = [&] {
+      if (auto genericParam =
+              T->getDecl()->getExplicitGenericParam(T->getOrdinal())) {
+        visit(genericParam->getDeclaredInterfaceType());
+        return true;
+      }
+
+      return false;
+    };
+
     switch (Options.OpaqueReturnTypePrinting) {
     case PrintOptions::OpaqueReturnTypePrintingMode::WithOpaqueKeyword:
+      if (printNamedOpaque())
+        return;
+
       Printer.printKeyword("some", Options, /*Suffix=*/" ");
       LLVM_FALLTHROUGH;
     case PrintOptions::OpaqueReturnTypePrintingMode::WithoutOpaqueKeyword: {
+      if (printNamedOpaque())
+        return;
+
       visit(T->getExistentialType());
       return;
     }

lib/AST/ASTScopeCreation.cpp

@@ -708,6 +708,26 @@ PatternEntryDeclScope::expandAScopeThatCreatesANewInsertionPoint(
   // Initializers come before VarDecls, e.g. PCMacro/didSet.swift 19
   auto patternEntry = getPatternEntry();
 
+  // If the pattern type is for a named opaque result type, introduce the
+  // generic type parameters based on the first variable we find.
+  ASTScopeImpl *leaf = this;
+  auto pattern = patternEntry.getPattern();
+  if (auto typedPattern = dyn_cast<TypedPattern>(pattern)) {
+    if (auto namedOpaque =
+            dyn_cast_or_null<NamedOpaqueReturnTypeRepr>(
+              typedPattern->getTypeRepr())) {
+      bool addedOpaqueResultTypeScope = false;
+      pattern->forEachVariable([&](VarDecl *var) {
+        if (addedOpaqueResultTypeScope)
+          return;
+
+        leaf = scopeCreator.addNestedGenericParamScopesToTree(
+            var, namedOpaque->getGenericParams(), leaf);
+        addedOpaqueResultTypeScope = true;
+      });
+    }
+  }
+
   // Create a child for the initializer, if present.
   // Cannot trust the source range given in the ASTScopeImpl for the end of the
   // initializer (because of InterpolatedLiteralStrings and EditorPlaceHolders),
@@ -724,7 +744,7 @@ PatternEntryDeclScope::expandAScopeThatCreatesANewInsertionPoint(
         "Original inits are always after the '='");
     scopeCreator
         .constructExpandAndInsert<PatternEntryInitializerScope>(
-            this, decl, patternEntryIndex);
+            leaf, decl, patternEntryIndex);
   }
 
   // If this pattern binding entry was created by the debugger, it will always
@@ -741,12 +761,12 @@ PatternEntryDeclScope::expandAScopeThatCreatesANewInsertionPoint(
         "inits are always after the '='");
     scopeCreator
         .constructExpandAndInsert<PatternEntryInitializerScope>(
-            this, decl, patternEntryIndex);
+            leaf, decl, patternEntryIndex);
   }
 
   // Add accessors for the variables in this pattern.
-  patternEntry.getPattern()->forEachVariable([&](VarDecl *var) {
-    scopeCreator.addChildrenForParsedAccessors(var, this);
+  pattern->forEachVariable([&](VarDecl *var) {
+    scopeCreator.addChildrenForParsedAccessors(var, leaf);
   });
 
   // In local context, the PatternEntryDeclScope becomes the insertion point, so
@@ -849,6 +869,20 @@ TopLevelCodeScope::expandAScopeThatCreatesANewInsertionPoint(ScopeCreator &
 
 // Create child scopes for every declaration in a body.
 
+namespace {
+  /// Retrieve the opaque generic parameter list if present, otherwise the normal generic parameter list.
+  template<typename T>
+  GenericParamList *getPotentiallyOpaqueGenericParams(T *decl) {
+    if (auto opaqueRepr = decl->getOpaqueResultTypeRepr()) {
+      if (auto namedOpaque = dyn_cast<NamedOpaqueReturnTypeRepr>(opaqueRepr)) {
+        return namedOpaque->getGenericParams();
+      }
+    }
+
+    return decl->getGenericParams();
+  }
+}
+
 void AbstractFunctionDeclScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
     ScopeCreator &scopeCreator) {
   scopeCreator.addChildrenForKnownAttributes(decl, this);
@@ -860,7 +894,7 @@ void AbstractFunctionDeclScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
 
   if (!isa<AccessorDecl>(decl)) {
     leaf = scopeCreator.addNestedGenericParamScopesToTree(
-        decl, decl->getGenericParams(), leaf);
+        decl, getPotentiallyOpaqueGenericParams(decl), leaf);
 
     auto *params = decl->getParameters();
     if (params->size() > 0) {
@@ -1008,7 +1042,7 @@ void SubscriptDeclScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
     ScopeCreator &scopeCreator) {
   scopeCreator.addChildrenForKnownAttributes(decl, this);
   auto *leaf = scopeCreator.addNestedGenericParamScopesToTree(
-      decl, decl->getGenericParams(), this);
+      decl, getPotentiallyOpaqueGenericParams(decl), this);
   scopeCreator.constructExpandAndInsert<ParameterListScope>(
       leaf, decl->getIndices(), decl->getAccessor(AccessorKind::Get));
   scopeCreator.addChildrenForParsedAccessors(decl, leaf);

lib/AST/ASTScopeLookup.cpp

@@ -266,6 +266,14 @@ bool GenericTypeOrExtensionScope::areMembersVisibleFromWhereClause() const {
 NullablePtr<const ASTScopeImpl>
 PatternEntryInitializerScope::getLookupParent() const {
   auto parent = getParent().get();
+
+  // Skip generic parameter scopes, which occur here due to named opaque
+  // result types.
+  // FIXME: Proper isa/dyn_cast support would be better than a string
+  // comparison here.
+  while (parent->getClassName() == "GenericParamScope")
+    parent = parent->getLookupParent().get();
+
   ASTScopeAssert(parent->getClassName() == "PatternEntryDeclScope",
                  "PatternEntryInitializerScope in unexpected place");
 

lib/AST/ASTScopeSourceRange.cpp

@@ -161,6 +161,15 @@ SourceRange GenericParamScope::getSourceRangeOfThisASTNode(
     return SourceRange(getLocAfterExtendedNominal(ext), ext->getEndLoc());
   }
 
+  // For a variable, the generic parameter is visible throughout the pattern
+  // binding entry.
+  if (auto var = dyn_cast<VarDecl>(holder)) {
+    if (auto patternBinding = var->getParentPatternBinding()) {
+      unsigned index = patternBinding->getPatternEntryIndexForVarDecl(var);
+      return patternBinding->getPatternList()[index].getSourceRange();
+    }
+  }
+
   // For all other declarations, generic parameters are visible everywhere.
   return holder->getSourceRange();
 }

lib/AST/Decl.cpp

@@ -7829,6 +7829,19 @@ bool OpaqueTypeDecl::isOpaqueReturnTypeOfFunction(
   return false;
 }
 
+bool OpaqueTypeDecl::hasExplicitGenericParams() const {
+  return getExplicitGenericParam(0) != nullptr;
+}
+
+GenericTypeParamDecl *OpaqueTypeDecl::getExplicitGenericParam(
+    unsigned ordinal) const {
+  if (ordinal >= getOpaqueGenericParams().size())
+    return nullptr;
+
+  auto genericParamType = getOpaqueGenericParams()[ordinal];
+  return genericParamType->getDecl();
+}
+
 unsigned OpaqueTypeDecl::getAnonymousOpaqueParamOrdinal(
     OpaqueReturnTypeRepr *repr) const {
   assert(NamingDeclAndHasOpaqueReturnTypeRepr.getInt() &&