Merge remote-tracking branch 'apple/main' into katei/merge-main-2022-06-09

Author: kateinoigakukun

SwiftCompilerSources/CMakeLists.txt

@@ -204,6 +204,19 @@ else()
       message(FATAL_ERROR "Need a swift toolchain building swift compiler sources")
     endif()
 
+    if(${BOOTSTRAPPING_MODE} STREQUAL "HOSTTOOLS")
+      if(NOT SWIFT_EXEC_FOR_SWIFT_MODULES STREQUAL CMAKE_Swift_COMPILER)
+        message(FATAL_ERROR "The Swift compiler (${CMAKE_Swift_COMPILER}) differs from the Swift compiler in SWIFT_NATIVE_SWIFT_TOOLS_PATH (${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/swiftc).")
+      endif()
+
+      set(min_supported_swift_version 5.5)
+      if(CMAKE_Swift_COMPILER_VERSION VERSION_LESS "${min_supported_swift_version}")
+        message(FATAL_ERROR
+            "Outdated Swift compiler: building with host tools requires Swift ${min_supported_swift_version} or newer. "
+            "Please update your Swift toolchain or switch BOOTSTRAPPING_MODE to BOOTSTRAPPING(-WITH-HOSTLIBS)? or OFF.")
+      endif()
+    endif()
+
     add_swift_compiler_modules_library(swiftCompilerModules
       SWIFT_EXEC "${SWIFT_EXEC_FOR_SWIFT_MODULES}")
 

include/swift/SIL/Dominance.h

@@ -92,14 +92,12 @@ class DominanceInfo : public DominatorTreeBase {
 ///
 /// Precondition: no critical edges (OSSA)
 ///
-/// Postcondition: each block in \p frontier is dominated by \p root and either
-/// exits the function or has a single successor that is not dominated by \p
-/// root.
-///
-/// With no critical edges, the dominance frontier is identified simply by leaf
-/// blocks in the dominance subtree.
-void computeDominanceFrontier(SILBasicBlock *root, DominanceInfo *domTree,
-                              SmallVectorImpl<SILBasicBlock *> &frontier);
+/// Postcondition: each block in \p boundary is dominated by \p root and either
+/// exits the function or has a single successor which has a predecessor that is
+/// not dominated by \p root.
+
+void computeDominatedBoundaryBlocks(SILBasicBlock *root, DominanceInfo *domTree,
+                                    SmallVectorImpl<SILBasicBlock *> &boundary);
 
 /// Helper class for visiting basic blocks in dominance order, based on a
 /// worklist algorithm. Example usage:

include/swift/SIL/SILType.h

@@ -86,6 +86,8 @@ enum class SILValueCategory : uint8_t {
   Address,
 };
 
+class SILPrinter;
+
 /// SILType - A Swift type that has been lowered to a SIL representation type.
 /// In addition to the Swift type system, SIL adds "address" types that can
 /// reference any Swift type (but cannot take the address of an address). *T
@@ -113,6 +115,8 @@ class SILType {
 
   friend class Lowering::TypeConverter;
   friend struct llvm::DenseMapInfo<SILType>;
+  friend class SILPrinter;
+
 public:
   SILType() = default;
 
@@ -184,8 +188,11 @@ class SILType {
   ///    type. This is done under the assumption that in all cases where we are
   ///    performing these AST queries on SILType, we are not interested in the
   ///    move only-ness of the value (which we can query separately anyways).
-  CanType getASTType() const { return withoutMoveOnly().getRawASTType(); }
+  CanType getASTType() const {
+    return removingMoveOnlyWrapper().getRawASTType();
+  }
 
+private:
   /// Returns the canonical AST type references by this SIL type without looking
   /// through move only. Should only be used by internal utilities of SILType.
   CanType getRawASTType() const { return CanType(value.getPointer()); }
@@ -597,33 +604,34 @@ class SILType {
   ///
   /// Canonical way to check if a SILType is move only. Using is/getAs/castTo
   /// will look through moveonly-ness.
-  bool isMoveOnly() const { return getRawASTType()->is<SILMoveOnlyType>(); }
+  bool isMoveOnlyWrapped() const {
+    return getRawASTType()->is<SILMoveOnlyType>();
+  }
 
-  /// Return *this if already move only... otherwise, wrap the current type
-  /// within a move only type wrapper and return that. Idempotent!
-  SILType asMoveOnly() const {
-    if (isMoveOnly())
+  /// If this is already a move only wrapped type, return *this. Otherwise, wrap
+  /// the copyable type in the mov eonly wrapper.
+  SILType addingMoveOnlyWrapper() const {
+    if (isMoveOnlyWrapped())
       return *this;
     auto newType = SILMoveOnlyType::get(getRawASTType());
     return SILType::getPrimitiveType(newType, getCategory());
   }
 
-  /// Return this SILType, removing moveonly-ness.
-  ///
-  /// Is idempotent.
-  SILType withoutMoveOnly() const {
-    if (!isMoveOnly())
+  /// If this is already a copyable type, just return *this. Otherwise, if this
+  /// is a move only wrapped copyable type, return the inner type.
+  SILType removingMoveOnlyWrapper() const {
+    if (!isMoveOnlyWrapped())
       return *this;
     auto moveOnly = getRawASTType()->castTo<SILMoveOnlyType>();
     return SILType::getPrimitiveType(moveOnly->getInnerType(), getCategory());
   }
 
-  /// If \p otherType is move only, return this type that is move only as
-  /// well. Otherwise, returns self. Useful for propagating "move only"-ness
+  /// If \p otherType is move only wrapped, return this type that is move only
+  /// as well. Otherwise, returns self. Useful for propagating "move only"-ness
   /// from a parent type to a subtype.
-  SILType copyMoveOnly(SILType otherType) const {
-    if (otherType.isMoveOnly()) {
-      return asMoveOnly();
+  SILType copyingMoveOnlyWrapper(SILType otherType) const {
+    if (otherType.isMoveOnlyWrapped()) {
+      return addingMoveOnlyWrapper();
     }
     return *this;
   }

include/swift/SIL/TypeLowering.h

@@ -821,6 +821,8 @@ class TypeConverter {
 
   llvm::DenseMap<AbstractClosureExpr *, Optional<AbstractionPattern>>
     ClosureAbstractionPatterns;
+  llvm::DenseMap<SILDeclRef, TypeExpansionContext>
+    CaptureTypeExpansionContexts;
 
   CanAnyFunctionType makeConstantInterfaceType(SILDeclRef constant);
 
@@ -1225,6 +1227,7 @@ class TypeConverter {
   /// the abstraction pattern is queried using this function. Once the
   /// abstraction pattern has been asked for, it may not be changed.
   Optional<AbstractionPattern> getConstantAbstractionPattern(SILDeclRef constant);
+  TypeExpansionContext getCaptureTypeExpansionContext(SILDeclRef constant);
 
   /// Set the preferred abstraction pattern for a closure.
   ///
@@ -1234,6 +1237,8 @@ class TypeConverter {
   void setAbstractionPattern(AbstractClosureExpr *closure,
                              AbstractionPattern pattern);
 
+  void setCaptureTypeExpansionContext(SILDeclRef constant,
+                                      SILModule &M);
 private:
   CanType computeLoweredRValueType(TypeExpansionContext context,
                                    AbstractionPattern origType,

include/swift/Sema/CSFix.h

@@ -708,10 +708,13 @@ class TreatArrayLiteralAsDictionary final : public ContextualMismatch {
   }
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
+    return diagnose(*commonFixes.front().first);
+  }
 
-  static TreatArrayLiteralAsDictionary *create(ConstraintSystem &cs,
-                                               Type dictionaryTy, Type arrayTy,
-                                               ConstraintLocator *loc);
+  static TreatArrayLiteralAsDictionary *attempt(ConstraintSystem &cs,
+                                                Type dictionaryTy, Type arrayTy,
+                                                ConstraintLocator *loc);
 
   static bool classof(ConstraintFix *fix) {
     return fix->getKind() == FixKind::TreatArrayLiteralAsDictionary;

lib/AST/ASTPrinter.cpp

@@ -3583,8 +3583,9 @@ void PrintAST::printPrimaryAssociatedTypes(ProtocolDecl *decl) {
       [&](AssociatedTypeDecl *assocType) {
         Printer.callPrintStructurePre(PrintStructureKind::GenericParameter,
                                       assocType);
-        Printer.printName(assocType->getName(),
-                          PrintNameContext::GenericParameter);
+        Printer.printTypeRef(assocType->getDeclaredInterfaceType(), assocType,
+                             assocType->getName(),
+                             PrintNameContext::GenericParameter);
         Printer.printStructurePost(PrintStructureKind::GenericParameter,
                                    assocType);
       },

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -227,8 +227,8 @@ class ConcreteContraction {
 Optional<Type> ConcreteContraction::substTypeParameterRec(
     Type type, Position position) const {
 
-  // If the requirement is of the form 'T == C' or 'T : C', don't
-  // substitute T, since then we end up with 'C == C' or 'C : C',
+  // If we have a superclass (T : C) or same-type requirement (T == C),
+  // don't substitute T, since then we end up with 'C == C' or 'C : C',
   // losing the requirement.
   if (position == Position::BaseType ||
       position == Position::ConformanceRequirement) {
@@ -399,9 +399,10 @@ ConcreteContraction::substRequirement(const Requirement &req) const {
         !module->lookupConformance(substFirstType, proto,
                                    allowMissing, allowUnavailable)) {
       // Handle the case of <T where T : P, T : C> where C is a class and
-      // C does not conform to P by leaving the conformance requirement
-      // unsubstituted.
-      return req;
+      // C does not conform to P and only substitute the parent type of T
+      // by pretending we have a same-type requirement here.
+      substFirstType = substTypeParameter(
+          firstType, Position::SameTypeRequirement);
     }
 
     // Otherwise, replace the generic parameter in the conformance
@@ -418,9 +419,11 @@ ConcreteContraction::substRequirement(const Requirement &req) const {
     if (!substFirstType->isTypeParameter() &&
         !substFirstType->satisfiesClassConstraint() &&
         req.getLayoutConstraint()->isClass()) {
-      // If the concrete type doesn't satisfy the layout constraint,
-      // leave it unsubstituted so that we produce a better diagnostic.
-      return req;
+      // If the concrete type doesn't satisfy the layout constraint, produce
+      // a better diagnostic and only substitute the parent type by pretending
+      // we have a same-type requirement here.
+      substFirstType = substTypeParameter(
+          firstType, Position::SameTypeRequirement);
     }
 
     return Requirement(req.getKind(),

lib/AST/RequirementMachine/MinimalConformances.cpp

@@ -263,6 +263,7 @@ MinimalConformances::decomposeTermIntoConformanceRuleLeftHandSides(
   bool simplified = System.simplify(term, &steps);
   if (!simplified) {
     llvm::errs() << "Term does not conform to protocol: " << term << "\n";
+    System.dump(llvm::errs());
     abort();
   }
 

lib/Basic/ParseableOutput.cpp

@@ -42,6 +42,7 @@ template <> struct ScalarEnumerationTraits<file_types::ID> {
       std::string typeName = file_types::getTypeName(ty).str();
       out.enumCase(value, typeName.c_str(), ty);
     });
+    out.enumCase(value, "unknown", file_types::ID::TY_INVALID);
   }
 };
 

lib/FrontendTool/FrontendTool.cpp

@@ -602,6 +602,7 @@ static swift::file_types::ID computeFileTypeForPath(const StringRef Path) {
     // then iterate over all preceeding possible extension variants.
     while (llvm::sys::path::has_extension(PathStem)) {
       auto NextExtension = llvm::sys::path::extension(PathStem);
+      PathStem = llvm::sys::path::stem(PathStem);
       Extension = NextExtension.str() + Extension;
       FileType = file_types::lookupTypeForExtension(Extension);
       if (FileType != swift::file_types::ID::TY_INVALID)