---

yaml
---
r: 349393
b: refs/heads/master-next
c: d58a1d5
h: refs/heads/master
i:
  349391: 13a628a

Author: swift-ci

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: 4801938d366cbc4f1f7bdb63598f619a40c96c4e
+refs/heads/master-next: d58a1d5c0d5fcc0710c42d23e5edc09abd626bc6
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/include/swift/AST/Type.h

@@ -374,7 +374,8 @@ class Type {
 class CanType : public Type {
   bool isActuallyCanonicalOrNull() const;
 
-  static bool isReferenceTypeImpl(CanType type, bool functionsCount);
+  static bool isReferenceTypeImpl(CanType type, GenericSignature *sig,
+                                  bool functionsCount);
   static bool isExistentialTypeImpl(CanType type);
   static bool isAnyExistentialTypeImpl(CanType type);
   static bool isObjCExistentialTypeImpl(CanType type);
@@ -408,8 +409,26 @@ class CanType : public Type {
   // Provide a few optimized accessors that are really type-class queries.
 
   /// Do values of this type have reference semantics?
+  ///
+  /// This includes isAnyClassReferenceType(), as well as function types.
   bool hasReferenceSemantics() const {
-    return isReferenceTypeImpl(*this, /*functions count*/ true);
+    return isReferenceTypeImpl(*this,
+                               /*signature*/ nullptr,
+                               /*functions count*/ true);
+  }
+
+  /// Are variables of this type permitted to have
+  /// ownership attributes?
+  ///
+  /// This includes:
+  ///   - class types, generic or not
+  ///   - archetypes with class or class protocol bounds
+  ///   - existentials with class or class protocol bounds
+  /// But not:
+  ///   - function types
+  bool allowsOwnership(GenericSignature *sig) const {
+    return isReferenceTypeImpl(*this, sig,
+                               /*functions count*/ false);
   }
 
   /// Are values of this type essentially just class references,
@@ -419,10 +438,13 @@ class CanType : public Type {
   ///   - a class type
   ///   - a bound generic class type
   ///   - a class-bounded archetype type
+  ///   - a class-bounded type parameter
   ///   - a class-bounded existential type
   ///   - a dynamic Self type
   bool isAnyClassReferenceType() const {
-    return isReferenceTypeImpl(*this, /*functions count*/ false);
+    return isReferenceTypeImpl(*this,
+                               /*signature*/ nullptr,
+                               /*functions count*/ false);
   }
 
   /// Is this type existential?

branches/master-next/include/swift/AST/Types.h

@@ -541,7 +541,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
 
   /// allowsOwnership() - Are variables of this type permitted to have
   /// ownership attributes?
-  bool allowsOwnership();  
+  bool allowsOwnership(GenericSignature *sig=nullptr);
 
   /// Determine whether this type involves a type variable.
   bool hasTypeVariable() const {

branches/master-next/include/swift/ClangImporter/ClangImporter.h

@@ -71,11 +71,13 @@ enum class SelectorSplitKind;
 /// Clang AST to ClangImporter to import the type into Swift.
 class DWARFImporterDelegate {
 public:
-  virtual ~DWARFImporterDelegate() {}
+  virtual ~DWARFImporterDelegate() = default;
   /// Perform a qualified lookup of a Clang type with this name.
   /// \param kind  Only return results with this type kind.
   virtual void lookupValue(StringRef name, llvm::Optional<ClangTypeKind> kind,
                            SmallVectorImpl<clang::Decl *> &results) {}
+  /// vtable anchor.
+  virtual void anchor();
 };
 
 /// Class that imports Clang modules into Swift, mapping directly

branches/master-next/lib/AST/Type.cpp

@@ -161,7 +161,8 @@ bool TypeBase::isAnyClassReferenceType() {
   return getCanonicalType().isAnyClassReferenceType();
 }
 
-bool CanType::isReferenceTypeImpl(CanType type, bool functionsCount) {
+bool CanType::isReferenceTypeImpl(CanType type, GenericSignature *sig,
+                                  bool functionsCount) {
   switch (type->getKind()) {
 #define SUGARED_TYPE(id, parent) case TypeKind::id:
 #define TYPE(id, parent)
@@ -180,7 +181,7 @@ bool CanType::isReferenceTypeImpl(CanType type, bool functionsCount) {
   // For Self types, recur on the underlying type.
   case TypeKind::DynamicSelf:
     return isReferenceTypeImpl(cast<DynamicSelfType>(type).getSelfType(),
-                               functionsCount);
+                               sig, functionsCount);
 
   // Archetypes and existentials are only class references if class-bounded.
   case TypeKind::PrimaryArchetype:
@@ -231,13 +232,14 @@ bool CanType::isReferenceTypeImpl(CanType type, bool functionsCount) {
 
   case TypeKind::GenericTypeParam:
   case TypeKind::DependentMember:
-    llvm_unreachable("Dependent types can't answer reference-semantics query");
+    assert(sig && "dependent types can't answer reference semantics query");
+    return sig->requiresClass(type);
   }
 
   llvm_unreachable("Unhandled type kind!");
 }
 
-/// hasOwnership - Are variables of this type permitted to have
+/// Are variables of this type permitted to have
 /// ownership attributes?
 ///
 /// This includes:
@@ -246,8 +248,8 @@ bool CanType::isReferenceTypeImpl(CanType type, bool functionsCount) {
 ///   - existentials with class or class protocol bounds
 /// But not:
 ///   - function types
-bool TypeBase::allowsOwnership() {
-  return getCanonicalType().isAnyClassReferenceType();
+bool TypeBase::allowsOwnership(GenericSignature *sig) {
+  return getCanonicalType().allowsOwnership(sig);
 }
 
 ExistentialLayout::ExistentialLayout(ProtocolType *type) {

branches/master-next/lib/ClangImporter/DWARFImporter.cpp

@@ -15,6 +15,8 @@
 
 using namespace swift;
 
+void DWARFImporterDelegate::anchor() {}
+
 /// Represents a Clang module that was "imported" from debug info. Since all the
 /// loading of types is done on demand, this class is effectively empty.
 class DWARFModuleUnit final : public LoadedFile {

branches/master-next/lib/Sema/TypeCheckAttr.cpp

@@ -133,6 +133,7 @@ class AttributeEarlyChecker : public AttributeVisitor<AttributeEarlyChecker> {
   IGNORED_ATTR(DisfavoredOverload)
   IGNORED_ATTR(FunctionBuilder)
   IGNORED_ATTR(ProjectedValueProperty)
+  IGNORED_ATTR(ReferenceOwnership)
 #undef IGNORED_ATTR
 
   void visitAlignmentAttr(AlignmentAttr *attr) {
@@ -175,10 +176,6 @@ class AttributeEarlyChecker : public AttributeVisitor<AttributeEarlyChecker> {
   void visitConsumingAttr(ConsumingAttr *attr) { visitMutationAttr(attr); }
   void visitDynamicAttr(DynamicAttr *attr);
 
-  void visitReferenceOwnershipAttr(ReferenceOwnershipAttr *attr) {
-    TC.checkReferenceOwnershipAttr(cast<VarDecl>(D), attr);
-  }
-
   void visitFinalAttr(FinalAttr *attr) {
     // Reject combining 'final' with 'open'.
     if (auto accessAttr = D->getAttrs().getAttribute<AccessControlAttr>()) {
@@ -2642,26 +2639,13 @@ void TypeChecker::checkDeclAttributes(Decl *D) {
   }
 }
 
-void TypeChecker::checkTypeModifyingDeclAttributes(VarDecl *var) {
-  if (!var->hasType())
-    return;
-
-  if (auto *attr = var->getAttrs().getAttribute<ReferenceOwnershipAttr>())
-    checkReferenceOwnershipAttr(var, attr);
-}
-
-void TypeChecker::checkReferenceOwnershipAttr(VarDecl *var,
+Type TypeChecker::checkReferenceOwnershipAttr(VarDecl *var, Type type,
                                               ReferenceOwnershipAttr *attr) {
-  // Don't check ownership attribute if the declaration is already marked invalid.
-  if (var->isInvalid())
-    return;
+  auto *dc = var->getDeclContext();
 
-  Type type = var->getType();
-  Type interfaceType = var->getInterfaceType();
-
-  // Just stop if we've already processed this declaration.
-  if (type->is<ReferenceStorageType>())
-    return;
+  // Don't check ownership attribute if the type is invalid.
+  if (attr->isInvalid() || type->is<ErrorType>())
+    return type;
 
   auto ownershipKind = attr->get();
 
@@ -2713,11 +2697,12 @@ void TypeChecker::checkReferenceOwnershipAttr(VarDecl *var,
   if (!underlyingType)
     underlyingType = type;
 
-  if (!underlyingType->allowsOwnership()) {
+  auto *sig = var->getDeclContext()->getGenericSignatureOfContext();
+  if (!underlyingType->allowsOwnership(sig)) {
     auto D = diag::invalid_ownership_type;
 
     if (underlyingType->isExistentialType() ||
-        underlyingType->is<ArchetypeType>()) {
+        underlyingType->isTypeParameter()) {
       // Suggest the possibility of adding a class bound.
       D = diag::invalid_ownership_protocol_type;
     }
@@ -2735,7 +2720,7 @@ void TypeChecker::checkReferenceOwnershipAttr(VarDecl *var,
     attr->setInvalid();
   }
 
-  auto PDC = dyn_cast<ProtocolDecl>((var->getDeclContext()));
+  auto PDC = dyn_cast<ProtocolDecl>(dc);
   if (PDC && !PDC->isObjC()) {
     // Ownership does not make sense in protocols, except for "weak" on
     // properties of Objective-C protocols.
@@ -2748,13 +2733,10 @@ void TypeChecker::checkReferenceOwnershipAttr(VarDecl *var,
   }
 
   if (attr->isInvalid())
-    return;
+    return type;
 
   // Change the type to the appropriate reference storage type.
-  var->setType(ReferenceStorageType::get(
-      type, ownershipKind, Context));
-  var->setInterfaceType(ReferenceStorageType::get(
-      interfaceType, ownershipKind, Context));
+  return ReferenceStorageType::get(type, ownershipKind, Context);
 }
 
 Optional<Diag<>>

branches/master-next/lib/Sema/TypeCheckPattern.cpp

@@ -838,8 +838,7 @@ bool TypeChecker::typeCheckParameterList(ParameterList *PL,
     } else {
       param->setInterfaceType(type);
     }
-    
-    checkTypeModifyingDeclAttributes(param);
+
     if (!hadError) {
       auto *nestedRepr = typeRepr;
 
@@ -1125,19 +1124,25 @@ bool TypeChecker::coercePatternToType(Pattern *&P, TypeResolution resolution,
     VarDecl *var = NP->getDecl();
     if (var->isInvalid())
       type = ErrorType::get(Context);
-    var->setType(type);
-    // FIXME: wtf
-    if (type->hasTypeParameter())
-      var->setInterfaceType(type);
-    else
-      var->setInterfaceType(type->mapTypeOutOfContext());
 
-    checkTypeModifyingDeclAttributes(var);
-    if (var->getAttrs().hasAttribute<ReferenceOwnershipAttr>())
-      type = var->getType()->getReferenceStorageReferent();
-    else if (!var->isInvalid())
-      type = var->getType();
+    Type interfaceType = type;
+    if (interfaceType->hasArchetype())
+      interfaceType = interfaceType->mapTypeOutOfContext();
+
+    // In SIL mode, VarDecls are written as having reference storage types.
+    if (type->is<ReferenceStorageType>()) {
+      assert(interfaceType->is<ReferenceStorageType>());
+      type = type->getReferenceStorageReferent();
+    } else {
+      if (auto *attr = var->getAttrs().getAttribute<ReferenceOwnershipAttr>())
+        interfaceType = checkReferenceOwnershipAttr(var, interfaceType, attr);
+    }
+
+    // Note that the pattern's type does not include the reference storage type.
     P->setType(type);
+    var->setInterfaceType(interfaceType);
+    var->setType(var->getDeclContext()->mapTypeIntoContext(interfaceType));
+
     var->getTypeLoc() = tyLoc;
     var->getTypeLoc().setType(var->getType());
 
@@ -1663,8 +1668,6 @@ void TypeChecker::coerceParameterListToType(ParameterList *P, ClosureExpr *CE,
       param->setType(ty);
       param->setInterfaceType(ty->mapTypeOutOfContext());
     }
-    
-    checkTypeModifyingDeclAttributes(param);
   };
 
   // Coerce each parameter to the respective type.

branches/master-next/lib/Sema/TypeCheckStorage.cpp

@@ -251,12 +251,6 @@ static void validatePatternBindingEntry(TypeChecker &tc,
                                                    ? Property : GlobalVariable);
     }
   }
-
-  // If we have any type-adjusting attributes, apply them here.
-  assert(binding->getPattern(entryNumber)->hasType() && "Type missing?");
-  if (auto var = binding->getSingleVar()) {
-    tc.checkTypeModifyingDeclAttributes(var);
-  }
 }
 
 /// Validate the entries in the given pattern binding declaration.

branches/master-next/lib/Sema/TypeChecker.h

@@ -989,9 +989,9 @@ class TypeChecker final : public LazyResolver {
   void checkParameterAttributes(ParameterList *params);
   void checkDynamicReplacementAttribute(ValueDecl *D);
   static ValueDecl *findReplacedDynamicFunction(const ValueDecl *d);
-  void checkTypeModifyingDeclAttributes(VarDecl *var);
 
-  void checkReferenceOwnershipAttr(VarDecl *D, ReferenceOwnershipAttr *attr);
+  Type checkReferenceOwnershipAttr(VarDecl *D, Type interfaceType,
+                                   ReferenceOwnershipAttr *attr);
 
   /// Check the default arguments that occur within this value decl.
   void checkDefaultArguments(ParameterList *params, ValueDecl *VD);