---

yaml
---
r: 326599
b: refs/heads/tensorflow
c: 4641792
h: refs/heads/master
i:
  326597: b64473a
  326595: 029db96
  326591: 14b4b3d

Author: Nathan Hawes

[refs]

@@ -816,7 +816,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: 9f6b3e2c658d711e252c9583671842469dd97439
+refs/heads/tensorflow: 4641792fe1903fffddfa8dfb2244d63d9536b34d
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/include/swift/AST/ClangModuleLoader.h

@@ -71,33 +71,6 @@ class ClangModuleLoader : public ModuleLoader {
   virtual bool
   isInOverlayModuleForImportedModule(const DeclContext *overlayDC,
                                      const DeclContext *importedDC) = 0;
-
-  /// Look for declarations associated with the given name.
-  ///
-  /// \param name The name we're searching for.
-  virtual void lookupValue(DeclName name, VisibleDeclConsumer &consumer) = 0;
-
-  /// Look up a type declaration by its Clang name.
-  ///
-  /// Note that this method does no filtering. If it finds the type in a loaded
-  /// module, it returns it. This is intended for use in reflection / debugging
-  /// contexts where access is not a problem.
-  virtual void
-  lookupTypeDecl(StringRef clangName, ClangTypeKind kind,
-                 llvm::function_ref<void(TypeDecl *)> receiver) = 0;
-
-  /// Look up type a declaration synthesized by the Clang importer itself, using
-  /// a "related entity kind" to determine which type it should be. For example,
-  /// this can be used to find the synthesized error struct for an
-  /// NS_ERROR_ENUM.
-  ///
-  /// Note that this method does no filtering. If it finds the type in a loaded
-  /// module, it returns it. This is intended for use in reflection / debugging
-  /// contexts where access is not a problem.
-  virtual void
-  lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
-                      StringRef relatedEntityKind,
-                      llvm::function_ref<void(TypeDecl *)> receiver) = 0;
 };
 
 } // namespace swift

branches/tensorflow/include/swift/AST/Type.h

@@ -374,8 +374,7 @@ class Type {
 class CanType : public Type {
   bool isActuallyCanonicalOrNull() const;
 
-  static bool isReferenceTypeImpl(CanType type, GenericSignature *sig,
-                                  bool functionsCount);
+  static bool isReferenceTypeImpl(CanType type, bool functionsCount);
   static bool isExistentialTypeImpl(CanType type);
   static bool isAnyExistentialTypeImpl(CanType type);
   static bool isObjCExistentialTypeImpl(CanType type);
@@ -409,26 +408,8 @@ 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,
-                               /*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);
+    return isReferenceTypeImpl(*this, /*functions count*/ true);
   }
 
   /// Are values of this type essentially just class references,
@@ -438,13 +419,10 @@ 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,
-                               /*signature*/ nullptr,
-                               /*functions count*/ false);
+    return isReferenceTypeImpl(*this, /*functions count*/ false);
   }
 
   /// Is this type existential?

branches/tensorflow/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(GenericSignature *sig=nullptr);
+  bool allowsOwnership();  
 
   /// Determine whether this type involves a type variable.
   bool hasTypeVariable() const {

branches/tensorflow/include/swift/ClangImporter/ClangImporter.h

@@ -71,13 +71,11 @@ enum class SelectorSplitKind;
 /// Clang AST to ClangImporter to import the type into Swift.
 class DWARFImporterDelegate {
 public:
-  virtual ~DWARFImporterDelegate() = default;
+  virtual ~DWARFImporterDelegate() {}
   /// 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
@@ -174,15 +172,15 @@ class ClangImporter final : public ClangModuleLoader {
   /// Look for declarations associated with the given name.
   ///
   /// \param name The name we're searching for.
-  void lookupValue(DeclName name, VisibleDeclConsumer &consumer) override;
+  void lookupValue(DeclName name, VisibleDeclConsumer &consumer);
 
   /// Look up a type declaration by its Clang name.
   ///
   /// Note that this method does no filtering. If it finds the type in a loaded
   /// module, it returns it. This is intended for use in reflection / debugging
   /// contexts where access is not a problem.
   void lookupTypeDecl(StringRef clangName, ClangTypeKind kind,
-                      llvm::function_ref<void(TypeDecl *)> receiver) override;
+                      llvm::function_ref<void(TypeDecl *)> receiver);
 
   /// Look up type a declaration synthesized by the Clang importer itself, using
   /// a "related entity kind" to determine which type it should be. For example,
@@ -195,7 +193,7 @@ class ClangImporter final : public ClangModuleLoader {
   void
   lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
                       StringRef relatedEntityKind,
-                      llvm::function_ref<void(TypeDecl *)> receiver) override;
+                      llvm::function_ref<void(TypeDecl *)> receiver);
 
   /// Look for textually included declarations from the bridging header.
   ///

branches/tensorflow/lib/AST/ASTDemangler.cpp

@@ -22,14 +22,14 @@
 #include "swift/AST/ASTDemangler.h"
 
 #include "swift/AST/ASTContext.h"
-#include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/GenericSignatureBuilder.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/Types.h"
+#include "swift/ClangImporter/ClangImporter.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/ManglingMacros.h"
 #include "llvm/ADT/StringSwitch.h"
@@ -1069,7 +1069,7 @@ GenericTypeDecl *ASTBuilder::findForeignTypeDecl(StringRef name,
                                                  ForeignModuleKind foreignKind,
                                                  Demangle::Node::Kind kind) {
   // Check to see if we have an importer loaded.
-  auto importer = Ctx.getClangModuleLoader();
+  auto importer = static_cast<ClangImporter *>(Ctx.getClangModuleLoader());
   if (!importer)
     return nullptr;
 

branches/tensorflow/lib/AST/Type.cpp

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

branches/tensorflow/lib/ClangImporter/DWARFImporter.cpp

@@ -15,8 +15,6 @@
 
 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/tensorflow/lib/Parse/SyntaxParsingContext.cpp

@@ -258,13 +258,10 @@ ParsedRawSyntaxNode SyntaxParsingContext::finalizeSourceFile() {
   Parts = Parts.drop_back();
 
   for (auto RawNode : Parts) {
-    if (RawNode.getKind() != SyntaxKind::CodeBlockItem) {
+    if (RawNode.getKind() != SyntaxKind::CodeBlockItem)
       // FIXME: Skip toplevel garbage nodes for now. we shouldn't emit them in
       // the first place.
-      if (RawNode.isRecorded())
-        getSyntaxCreator().finalizeNode(RawNode.getOpaqueNode());
       continue;
-    }
 
     AllTopLevel.push_back(RawNode);
   }

branches/tensorflow/lib/Sema/TypeCheckAttr.cpp

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

branches/tensorflow/lib/Sema/TypeCheckDecl.cpp

@@ -3501,7 +3501,9 @@ void bindFuncDeclToOperator(TypeChecker &TC, FuncDecl *FD) {
       for (DeclContext *CurContext = FD->getLocalContext();
            !isa<SourceFile>(CurContext);
            CurContext = CurContext->getParent()) {
-        insertionLoc = CurContext->getAsDecl()->getStartLoc();
+        // Skip over non-decl contexts (e.g. closure expresssions)
+        if (auto *D = CurContext->getAsDecl())
+            insertionLoc = D->getStartLoc();
       }
     }