Merge remote-tracking branch 'origin/swift-4.1-branch' into swift-5.0-branch

Author: bob-wilson

CHANGELOG.md

@@ -33,6 +33,23 @@ Swift 5.0
 Swift 4.1
 ---------
 
+* [SE-0189][]
+
+  If an initializer is declared in a different module from a struct, it must
+  use `self.init(…)` or `self = …` before returning or accessing `self`.
+  Failure to do so will produce a warning in Swift 4 and an error in Swift 5.
+  This is to keep a client app from accidentally depending on a library's
+  implementation details, and matches an existing restriction for classes,
+  where cross-module initializers must be convenience initializers.
+
+  This will most commonly affect code that extends a struct imported from C.
+  However, most imported C structs are given a zeroing no-argument initializer,
+  which can be called as `self.init()` before modifying specific properties.
+
+  Swift library authors who wish to continue allowing initialization on a
+  per-member basis should explicitly declare a public memberwise initializer
+  for clients in other modules to use.
+
 * [SE-0166][] / [SE-0143][]
 
   The standard library now defines the conformances of `Optional`,

README.md

@@ -54,7 +54,7 @@ supported host development operating systems.
 
 #### macOS
 
-To build for macOS, you need [Xcode 9.2](https://developer.apple.com/xcode/downloads/).
+To build for macOS, you need [Xcode 9.3 beta](https://developer.apple.com/xcode/downloads/).
 The required version of Xcode changes frequently, and is often a beta release.
 Check this document or the host information on <https://ci.swift.org> for the
 current required version.

include/swift/AST/DiagnosticsSema.def

@@ -1408,6 +1408,10 @@ NOTE(candidate_types_inheritance_requirement,none,
      (Type, Type, Type, Type, StringRef))
 NOTE(types_not_equal_requirement,none,
      "requirement specified as %0 == %1%2", (Type, Type, StringRef))
+ERROR(type_is_not_a_class,none,
+      "%0 requires that %1 be a class type", (Type, Type, Type))
+NOTE(anyobject_requirement,none,
+     "requirement specified as %0 : 'AnyObject'%2", (Type, Type, StringRef))
 ERROR(non_class_cannot_conform_to_class_protocol,none,
       "non-class type %0 cannot conform to class protocol %1",
       (Type, Type))

include/swift/AST/GenericSignature.h

@@ -147,7 +147,8 @@ class alignas(1 << TypeAlignInBits) GenericSignature final
   /// requirements, first canonicalizing the types.
   static CanGenericSignature getCanonical(
                                       ArrayRef<GenericTypeParamType *> params,
-                                      ArrayRef<Requirement> requirements);
+                                      ArrayRef<Requirement> requirements,
+                                      bool skipValidation = false);
 
   /// Retrieve the generic parameters.
   ArrayRef<GenericTypeParamType *> getGenericParams() const {

include/swift/AST/Types.h

@@ -696,6 +696,16 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// with a class type.
   bool mayHaveSuperclass();
 
+  /// Determine whether this type satisfies a class layout constraint, written
+  /// `T: AnyObject` in the source.
+  ///
+  /// A class layout constraint is satisfied when we have a single retainable
+  /// pointer as the representation, which includes:
+  /// - @objc existentials
+  /// - class constrained archetypes
+  /// - classes
+  bool satisfiesClassConstraint();
+
   /// \brief Determine whether this type can be used as a base type for AST
   /// name lookup, which is the case for nominal types, protocol compositions
   /// and archetypes.

include/swift/SIL/SILLocation.h

@@ -502,6 +502,12 @@ class RegularLocation : public SILLocation {
   }
 };
 
+/// Compiler-generated locations may be applied to instructions without any
+/// clear correspondence to an AST node.
+static inline RegularLocation getCompilerGeneratedLocation() {
+  return {SourceLoc()};
+}
+
 /// Used to represent a return instruction in user code.
 ///
 /// Allowed on an BranchInst, ReturnInst.
@@ -705,7 +711,8 @@ class SILDebugLocation {
   SILLocation Location;
 
 public:
-  SILDebugLocation() : Scope(nullptr), Location(RegularLocation(SourceLoc())) {}
+  SILDebugLocation()
+      : Scope(nullptr), Location(getCompilerGeneratedLocation()) {}
   SILDebugLocation(SILLocation Loc, const SILDebugScope *DS)
       : Scope(DS), Location(Loc) {}
   SILLocation getLocation() const { return Location; }

include/swift/SIL/TypeLowering.h

@@ -259,14 +259,6 @@ class TypeLowering {
 
   enum class LoweringStyle { Shallow, Deep };
 
-  /// Given the result of the expansion heuristic,
-  /// return appropriate lowering style.
-  static LoweringStyle getLoweringStyle(bool shouldExpand) {
-    if (shouldExpand)
-      return TypeLowering::LoweringStyle::Deep;
-    return TypeLowering::LoweringStyle::Shallow;
-  }
-
   //===--------------------------------------------------------------------===//
   // DestroyValue
   //===--------------------------------------------------------------------===//

lib/AST/GenericSignature.cpp

@@ -150,7 +150,8 @@ static unsigned getRequirementKindOrder(RequirementKind kind) {
 
 CanGenericSignature GenericSignature::getCanonical(
                                         ArrayRef<GenericTypeParamType *> params,
-                                        ArrayRef<Requirement> requirements) {
+                                        ArrayRef<Requirement> requirements,
+                                        bool skipValidation) {
   // Canonicalize the parameters and requirements.
   SmallVector<GenericTypeParamType*, 8> canonicalParams;
   canonicalParams.reserve(params.size());
@@ -172,10 +173,14 @@ CanGenericSignature GenericSignature::getCanonical(
                       reqt.getLayoutConstraint()));
   }
 
+  (void)skipValidation;
   auto canSig = get(canonicalParams, canonicalRequirements,
                     /*isKnownCanonical=*/true);
 
 #ifndef NDEBUG
+  if (skipValidation)
+    return CanGenericSignature(canSig);
+
   PrettyStackTraceGenericSignature debugStack("canonicalizing", canSig);
 
   // Check that the signature is canonical.

lib/AST/GenericSignatureBuilder.cpp

@@ -3026,6 +3026,12 @@ ResolvedType GenericSignatureBuilder::maybeResolveEquivalenceClass(
     TypeDecl *nestedTypeDecl;
     SmallVector<TypeDecl *, 4> concreteDecls;
     if (auto assocType = depMemTy->getAssocType()) {
+      // Check whether this associated type references a protocol to which
+      // the base conforms. If not, it's unresolved.
+      if (baseEquivClass->conformsTo.find(assocType->getProtocol())
+            == baseEquivClass->conformsTo.end())
+        return ResolvedType::forUnresolved(baseEquivClass);
+
       nestedTypeDecl = assocType;
     } else {
       nestedTypeDecl =

lib/AST/ProtocolConformance.cpp

@@ -530,8 +530,9 @@ bool NormalProtocolConformance::hasTypeWitness(AssociatedTypeDecl *assocType,
   if (Loader)
     resolveLazyInfo();
 
-  if (TypeWitnesses.find(assocType) != TypeWitnesses.end()) {
-    return true;
+  auto found = TypeWitnesses.find(assocType);
+  if (found != TypeWitnesses.end()) {
+    return !found->getSecond().first.isNull();
   }
   if (resolver) {
     PrettyStackTraceRequirement trace("resolving", this, assocType);
@@ -556,24 +557,25 @@ NormalProtocolConformance::getTypeWitnessAndDecl(AssociatedTypeDecl *assocType,
   if (known != TypeWitnesses.end())
     return known->second;
 
-  // If this conformance is in a state where it is inferring type witnesses,
-  // check tentative witnesses.
-  if (getState() == ProtocolConformanceState::CheckingTypeWitnesses) {
-    // If there is a tentative-type-witness function, use it.
-    if (options.getTentativeTypeWitness) {
-     if (Type witnessType =
-           Type(options.getTentativeTypeWitness(this, assocType)))
-       return { witnessType, nullptr };
-    }
+  // If there is a tentative-type-witness function, use it.
+  if (options.getTentativeTypeWitness) {
+   if (Type witnessType =
+         Type(options.getTentativeTypeWitness(this, assocType)))
+     return { witnessType, nullptr };
+  }
 
-    // Otherwise, we fail; this is the only case in which we can return a
-    // null type.
+  // If this conformance is in a state where it is inferring type witnesses but
+  // we didn't find anything, fail.
+  if (getState() == ProtocolConformanceState::CheckingTypeWitnesses) {
     return { Type(), nullptr };
   }
 
   // Otherwise, resolve the type witness.
   PrettyStackTraceRequirement trace("resolving", this, assocType);
   assert(resolver && "Unable to resolve type witness");
+
+  // Block recursive resolution of this type witness.
+  TypeWitnesses[assocType] = { Type(), nullptr };
   resolver->resolveTypeWitness(this, assocType);
 
   known = TypeWitnesses.find(assocType);
@@ -586,7 +588,9 @@ void NormalProtocolConformance::setTypeWitness(AssociatedTypeDecl *assocType,
                                                TypeDecl *typeDecl) const {
   assert(getProtocol() == cast<ProtocolDecl>(assocType->getDeclContext()) &&
          "associated type in wrong protocol");
-  assert(TypeWitnesses.count(assocType) == 0 && "Type witness already known");
+  assert((TypeWitnesses.count(assocType) == 0 ||
+          TypeWitnesses[assocType].first.isNull()) &&
+         "Type witness already known");
   assert((!isComplete() || isInvalid()) && "Conformance already complete?");
   assert(!type->hasArchetype() && "type witnesses must be interface types");
   TypeWitnesses[assocType] = std::make_pair(type, typeDecl);

lib/AST/Type.cpp

@@ -1385,6 +1385,10 @@ bool TypeBase::mayHaveSuperclass() {
   return is<DynamicSelfType>();
 }
 
+bool TypeBase::satisfiesClassConstraint() {
+  return mayHaveSuperclass() || isObjCExistentialType();
+}
+
 Type TypeBase::getSuperclass() {
   auto *nominalDecl = getAnyNominal();
   auto *classDecl = dyn_cast_or_null<ClassDecl>(nominalDecl);

lib/IDE/TypeReconstruction.cpp

@@ -1719,7 +1719,7 @@ static void VisitNodeInOut(
   VisitNodeResult type_result;
   VisitNode(ast, cur_node->getFirstChild(), type_result);
   if (type_result._types.size() == 1 && type_result._types[0]) {
-    result._types.push_back(Type(LValueType::get(type_result._types[0])));
+    result._types.push_back(Type(InOutType::get(type_result._types[0])));
   } else {
     result._error = "couldn't resolve referent type";
   }

lib/IRGen/ProtocolInfo.h

@@ -227,7 +227,12 @@ class ProtocolInfo final :
       if (witness.matchesFunction(function))
         return getNonBaseWitnessIndex(&witness);
     }
-    llvm_unreachable("didn't find entry for function");
+
+    // FIXME: This should be an "unreachable", but Swift < 4.1 had an
+    // existing bug here that depends on (effectively) getting this
+    // result in non-Asserts builds. Emulate that behavior for now,
+    // but only on the Swift 4.1 branch.
+    return WitnessIndex(0, false);
   }
 
   /// Return the witness index for the type metadata access function

lib/SIL/TypeLowering.cpp

@@ -2298,10 +2298,8 @@ TypeConverter::checkForABIDifferences(SILType type1, SILType type2) {
   // Classes, class-constrained archetypes, and pure-ObjC existential types
   // all have single retainable pointer representation; optionality change
   // is allowed.
-  if ((type1.getSwiftRValueType()->mayHaveSuperclass() ||
-       type1.getSwiftRValueType()->isObjCExistentialType()) &&
-      (type2.getSwiftRValueType()->mayHaveSuperclass() ||
-       type2.getSwiftRValueType()->isObjCExistentialType()))
+  if (type1.getSwiftRValueType()->satisfiesClassConstraint() &&
+      type2.getSwiftRValueType()->satisfiesClassConstraint())
     return ABIDifference::Trivial;
 
   // Function parameters are ABI compatible if their differences are

lib/SILGen/SILGenPattern.cpp

@@ -2315,7 +2315,13 @@ void PatternMatchEmission::emitCaseBody(CaseStmt *caseBlock) {
 
   // Implicitly break out of the pattern match statement.
   if (SGF.B.hasValidInsertionPoint()) {
-    SGF.emitBreakOutOf(CleanupLocation(caseBlock), PatternMatchStmt);
+    // Case blocks without trailing braces have ambiguous cleanup locations.
+    SILLocation cleanupLoc = getCompilerGeneratedLocation();
+    if (auto *braces = dyn_cast<BraceStmt>(caseBlock->getBody()))
+      if (braces->getNumElements() == 1 &&
+          dyn_cast_or_null<DoStmt>(braces->getElement(0).dyn_cast<Stmt *>()))
+        cleanupLoc = CleanupLocation(caseBlock);
+    SGF.emitBreakOutOf(cleanupLoc, PatternMatchStmt);
   }
 }
 

lib/SILGen/SILGenProlog.cpp

@@ -522,7 +522,7 @@ unsigned SILGenFunction::emitProlog(ArrayRef<ParameterList *> paramLists,
   // Record the ArgNo of the artificial $error inout argument. 
   unsigned ArgNo = emitter.getNumArgs();
   if (throws) {
-    RegularLocation Loc{SourceLoc()};
+    RegularLocation Loc = getCompilerGeneratedLocation();
     if (auto *AFD = dyn_cast<AbstractFunctionDecl>(DC))
       Loc = AFD->getThrowsLoc();
     else if (auto *ACE = dyn_cast<AbstractClosureExpr>(DC))

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -2177,7 +2177,7 @@ SILValue LifetimeChecker::handleConditionalInitAssign() {
   // Use an empty location for the alloc_stack. If Loc is variable declaration
   // the alloc_stack would look like the storage of that variable.
   auto *ControlVariableBox =
-      B.createAllocStack(RegularLocation(SourceLoc()), IVType);
+      B.createAllocStack(getCompilerGeneratedLocation(), IVType);
 
   // Find all the return blocks in the function, inserting a dealloc_stack
   // before the return.

lib/SILOptimizer/Transforms/FunctionSignatureOpts.cpp

@@ -979,11 +979,11 @@ static void createArgumentRelease(SILBuilder &Builder, ArgumentDescriptor &AD) {
   if (Arg->getType().isAddress()) {
     assert(AD.PInfo->getConvention() == ParameterConvention::Indirect_In
            && F.getConventions().useLoweredAddresses());
-    Builder.createDestroyAddr(RegularLocation(SourceLoc()),
+    Builder.createDestroyAddr(getCompilerGeneratedLocation(),
                               F.getArguments()[AD.Index]);
     return;
   }
-  Builder.createReleaseValue(RegularLocation(SourceLoc()),
+  Builder.createReleaseValue(getCompilerGeneratedLocation(),
                              F.getArguments()[AD.Index],
                              Builder.getDefaultAtomicity());
 }
@@ -1028,13 +1028,14 @@ OwnedToGuaranteedAddResultRelease(ResultDescriptor &RD, SILBuilder &Builder,
   SILInstruction *Call = findOnlyApply(F);
   if (auto AI = dyn_cast<ApplyInst>(Call)) {
     Builder.setInsertionPoint(&*std::next(SILBasicBlock::iterator(AI)));
-    Builder.createRetainValue(RegularLocation(SourceLoc()), AI,
+    Builder.createRetainValue(getCompilerGeneratedLocation(), AI,
                               Builder.getDefaultAtomicity());
   } else {
     SILBasicBlock *NormalBB = cast<TryApplyInst>(Call)->getNormalBB();
     Builder.setInsertionPoint(&*NormalBB->begin());
-    Builder.createRetainValue(RegularLocation(SourceLoc()),
-                              NormalBB->getArgument(0), Builder.getDefaultAtomicity());
+    Builder.createRetainValue(getCompilerGeneratedLocation(),
+                              NormalBB->getArgument(0),
+                              Builder.getDefaultAtomicity());
   }
 }
 

lib/SILOptimizer/Transforms/SILLowerAggregateInstrs.cpp

@@ -112,17 +112,23 @@ static bool expandCopyAddr(CopyAddrInst *CA) {
     //   retain_value %new : $*T
     IsTake_t IsTake = CA->isTakeOfSrc();
     if (IsTake_t::IsNotTake == IsTake) {
-      TL.emitLoweredCopyValue(Builder, CA->getLoc(), New,
-                              TypeLowering::getLoweringStyle(expand));
+      if (expand) {
+        TL.emitLoweredCopyValueDeep(Builder, CA->getLoc(), New);
+      } else {
+        TL.emitCopyValue(Builder, CA->getLoc(), New);
+      }
     }
 
     // If we are not initializing:
     // strong_release %old : $*T
     //   *or*
     // release_value %old : $*T
     if (Old) {
-      TL.emitLoweredDestroyValue(Builder, CA->getLoc(), Old,
-                                 TypeLowering::getLoweringStyle(expand));
+      if (expand) {
+        TL.emitLoweredDestroyValueDeep(Builder, CA->getLoc(), Old);
+      } else {
+        TL.emitDestroyValue(Builder, CA->getLoc(), Old);
+      }
     }
   }
 
@@ -155,8 +161,11 @@ static bool expandDestroyAddr(DestroyAddrInst *DA) {
     LoadInst *LI = Builder.createLoad(DA->getLoc(), Addr,
                                       LoadOwnershipQualifier::Unqualified);
     auto &TL = Module.getTypeLowering(Type);
-    TL.emitLoweredDestroyValue(Builder, DA->getLoc(), LI,
-                               TypeLowering::getLoweringStyle(expand));
+    if (expand) {
+      TL.emitLoweredDestroyValueDeep(Builder, DA->getLoc(), LI);
+    } else {
+      TL.emitDestroyValue(Builder, DA->getLoc(), LI);
+    }
   }
 
   ++NumExpand;

lib/SILOptimizer/Transforms/SILMem2Reg.cpp

@@ -350,8 +350,12 @@ static void replaceDestroy(DestroyAddrInst *DAI, SILValue NewValue) {
 
   bool expand = shouldExpand(DAI->getModule(),
                              DAI->getOperand()->getType().getObjectType());
-  TL.emitLoweredDestroyValue(Builder, DAI->getLoc(), NewValue,
-                             Lowering::TypeLowering::getLoweringStyle(expand));
+  if (expand) {
+    TL.emitLoweredDestroyValueDeep(Builder, DAI->getLoc(), NewValue);
+  } else {
+    TL.emitDestroyValue(Builder, DAI->getLoc(), NewValue);
+  }
+
   DAI->eraseFromParent();
 }
 

lib/SILOptimizer/Utils/Local.cpp

@@ -50,7 +50,7 @@ swift::createIncrementBefore(SILValue Ptr, SILInstruction *InsertPt) {
 
   // Set up the builder we use to insert at our insertion point.
   SILBuilder B(InsertPt);
-  auto Loc = RegularLocation(SourceLoc());
+  auto Loc = getCompilerGeneratedLocation();
 
   // If Ptr is refcounted itself, create the strong_retain and
   // return.
@@ -75,7 +75,7 @@ swift::createDecrementBefore(SILValue Ptr, SILInstruction *InsertPt) {
 
   // Setup the builder we will use to insert at our insertion point.
   SILBuilder B(InsertPt);
-  auto Loc = RegularLocation(SourceLoc());
+  auto Loc = getCompilerGeneratedLocation();
 
   // If Ptr has reference semantics itself, create a strong_release.
   if (Ptr->getType().isReferenceCounted(B.getModule())) {