---

yaml
---
r: 326618
b: refs/heads/tensorflow
c: 5add168
h: refs/heads/master

Author: xedin

[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: c36993e30cd23782f42c8f2ce8a463ab3c18d591
+refs/heads/tensorflow: 5add16804272b4df917da15c46eb6f28d826d656
 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/ABI/Metadata.h

@@ -2340,6 +2340,12 @@ struct TargetProtocolConformanceDescriptor final
     return TypeRef.getTypeDescriptor(getTypeKind());
   }
 
+  const TargetContextDescriptor<Runtime> **_getTypeDescriptorLocation() const {
+    if (getTypeKind() != TypeReferenceKind::IndirectTypeDescriptor)
+      return nullptr;
+    return TypeRef.IndirectTypeDescriptor.get();
+  }
+
   /// Retrieve the context of a retroactive conformance.
   const TargetContextDescriptor<Runtime> *getRetroactiveContext() const {
     if (!Flags.isRetroactive()) return nullptr;

branches/tensorflow/include/swift/AST/Attr.def

@@ -348,10 +348,7 @@ DECL_ATTR(_restatedObjCConformance, RestatedObjCConformance,
   LongAttribute | RejectByParser |
   NotSerialized, 70)
 // NOTE: 71 is unused
-SIMPLE_DECL_ATTR(_implicitly_unwrapped_optional, ImplicitlyUnwrappedOptional,
-  OnFunc | OnAccessor | OnVar | OnParam | OnSubscript | OnConstructor |
-  RejectByParser,
-  72)
+// NOTE: 72 is unused
 DECL_ATTR(_optimize, Optimize,
   OnAbstractFunction | OnSubscript | OnVar |
   UserInaccessible,

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

@@ -71,6 +71,33 @@ 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/Decl.h

@@ -456,16 +456,16 @@ class alignas(1 << DeclAlignInBits) Decl {
     IsTransparentComputed : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ConstructorDecl, AbstractFunctionDecl, 3+2+1,
+  SWIFT_INLINE_BITFIELD(ConstructorDecl, AbstractFunctionDecl, 3+1+1,
     /// The body initialization kind (+1), or zero if not yet computed.
     ///
     /// This value is cached but is not serialized, because it is a property
     /// of the definition of the constructor that is useful only to semantic
     /// analysis and SIL generation.
     ComputedBodyInitKind : 3,
 
-    /// The failability of this initializer, which is an OptionalTypeKind.
-    Failability : 2,
+    /// Whether this constructor can fail, by building an Optional type.
+    Failable : 1,
 
     /// Whether this initializer is a stub placed into a subclass to
     /// catch invalid delegations to a designated initializer not
@@ -2412,12 +2412,20 @@ class ValueDecl : public Decl {
     /// Whether this declaration is 'final'. A final class can't be subclassed,
     /// a final class member can't be overriden.
     unsigned isFinal : 1;
+
+    /// Whether the "isIUO" bit" has been computed yet.
+    unsigned isIUOComputed : 1;
+
+    /// Whether this declaration produces an implicitly unwrapped
+    /// optional result.
+    unsigned isIUO : 1;
   } LazySemanticInfo = { };
 
   friend class OverriddenDeclsRequest;
   friend class IsObjCRequest;
   friend class IsFinalRequest;
   friend class IsDynamicRequest;
+  friend class IsImplicitlyUnwrappedOptionalRequest;
 
 protected:
   ValueDecl(DeclKind K,
@@ -2686,6 +2694,21 @@ class ValueDecl : public Decl {
   /// Returns true if this decl can be found by id-style dynamic lookup.
   bool canBeAccessedByDynamicLookup() const;
 
+  /// Returns true if this declaration has an implicitly unwrapped optional
+  /// result. The precise meaning depends on the declaration kind:
+  /// - for properties, the value is IUO
+  /// - for subscripts, the element type is IUO
+  /// - for functions, the result type is IUO
+  /// - for constructors, the failability kind is IUO
+  bool isImplicitlyUnwrappedOptional() const;
+
+  /// Should only be set on imported and deserialized declarations; parsed
+  /// declarations compute this lazily via a request.
+  void setImplicitlyUnwrappedOptional(bool isIUO) {
+    LazySemanticInfo.isIUOComputed = 1;
+    LazySemanticInfo.isIUO = isIUO;
+  }
+
   /// Returns the protocol requirements that this decl conforms to.
   ArrayRef<ValueDecl *>
   getSatisfiedProtocolRequirements(bool Sorted = false) const;
@@ -3198,19 +3221,6 @@ class AssociatedTypeDecl : public AbstractTypeParamDecl {
 
 class MemberLookupTable;
 class ConformanceLookupTable;
-
-/// Kinds of optional types.
-enum OptionalTypeKind : unsigned {
-  /// The type is not an optional type.
-  OTK_None = 0,
-
-  /// The type is Optional<T>.
-  OTK_Optional,
-
-  /// The type is ImplicitlyUnwrappedOptional<T>.
-  OTK_ImplicitlyUnwrappedOptional
-};
-enum { NumOptionalTypeKinds = 2 };
 
 // Kinds of pointer types.
 enum PointerTypeKind : unsigned {
@@ -6495,7 +6505,7 @@ class ConstructorDecl : public AbstractFunctionDecl {
 
 public:
   ConstructorDecl(DeclName Name, SourceLoc ConstructorLoc, 
-                  OptionalTypeKind Failability, SourceLoc FailabilityLoc,
+                  bool Failable, SourceLoc FailabilityLoc,
                   bool Throws, SourceLoc ThrowsLoc,
                   ParameterList *BodyParams,
                   GenericParamList *GenericParams, 
@@ -6595,9 +6605,9 @@ class ConstructorDecl : public AbstractFunctionDecl {
     llvm_unreachable("bad CtorInitializerKind");
   }
 
-  /// Determine the failability of the initializer.
-  OptionalTypeKind getFailability() const {
-    return static_cast<OptionalTypeKind>(Bits.ConstructorDecl.Failability);
+  /// Determine if this is a failable initializer.
+  bool isFailable() const {
+    return Bits.ConstructorDecl.Failable;
   }
 
   /// Retrieve the location of the '!' or '?' in a failable initializer.

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

@@ -292,8 +292,7 @@ struct PrintOptions {
   /// List of attribute kinds that should not be printed.
   std::vector<AnyAttrKind> ExcludeAttrList = {DAK_Transparent, DAK_Effects,
                                               DAK_FixedLayout,
-                                              DAK_ShowInInterface,
-                                              DAK_ImplicitlyUnwrappedOptional};
+                                              DAK_ShowInInterface};
 
   /// List of attribute kinds that should be printed exclusively.
   /// Empty means allow all.

branches/tensorflow/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/tensorflow/include/swift/AST/TypeCheckRequests.h

@@ -1031,6 +1031,27 @@ class EmittedMembersRequest :
   void cacheResult(DeclRange value) const;
 };
 
+class IsImplicitlyUnwrappedOptionalRequest :
+    public SimpleRequest<IsImplicitlyUnwrappedOptionalRequest,
+                         bool(ValueDecl *),
+                         CacheKind::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<bool>
+  evaluate(Evaluator &evaluator, ValueDecl *value) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<bool> getCachedResult() const;
+  void cacheResult(bool value) const;
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

branches/tensorflow/include/swift/AST/TypeCheckerTypeIDZone.def

@@ -55,3 +55,4 @@ SWIFT_TYPEID(RequiresOpaqueModifyCoroutineRequest)
 SWIFT_TYPEID(IsAccessorTransparentRequest)
 SWIFT_TYPEID(SynthesizeAccessorRequest)
 SWIFT_TYPEID(EmittedMembersRequest)
+SWIFT_TYPEID(IsImplicitlyUnwrappedOptionalRequest)

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

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

@@ -60,6 +60,19 @@ class TypeDecl;
 class VisibleDeclConsumer;
 enum class SelectorSplitKind;
 
+/// Kinds of optional types.
+enum OptionalTypeKind : unsigned {
+  /// The type is not an optional type.
+  OTK_None = 0,
+
+  /// The type is Optional<T>.
+  OTK_Optional,
+
+  /// The type is ImplicitlyUnwrappedOptional<T>.
+  OTK_ImplicitlyUnwrappedOptional
+};
+enum { NumOptionalTypeKinds = 2 };
+
 /// This interface is implemented by LLDB to serve as a fallback when Clang
 /// modules can't be imported from source in the debugger.
 ///
@@ -71,11 +84,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
@@ -91,7 +106,7 @@ class ClangImporter final : public ClangModuleLoader {
 
   ClangImporter(ASTContext &ctx, const ClangImporterOptions &clangImporterOpts,
                 DependencyTracker *tracker,
-                std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate);
+                DWARFImporterDelegate *dwarfImporterDelegate);
 
   ModuleDecl *loadModuleClang(SourceLoc importLoc,
                               ArrayRef<std::pair<Identifier, SourceLoc>> path);
@@ -117,7 +132,7 @@ class ClangImporter final : public ClangModuleLoader {
   static std::unique_ptr<ClangImporter>
   create(ASTContext &ctx, const ClangImporterOptions &importerOpts,
          std::string swiftPCHHash = "", DependencyTracker *tracker = nullptr,
-         std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate = {});
+         DWARFImporterDelegate *dwarfImporterDelegate = nullptr);
 
   ClangImporter(const ClangImporter &) = delete;
   ClangImporter(ClangImporter &&) = delete;
@@ -172,15 +187,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);
+  void lookupValue(DeclName name, VisibleDeclConsumer &consumer) override;
 
   /// 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);
+                      llvm::function_ref<void(TypeDecl *)> receiver) override;
 
   /// 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,
@@ -193,7 +208,7 @@ class ClangImporter final : public ClangModuleLoader {
   void
   lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
                       StringRef relatedEntityKind,
-                      llvm::function_ref<void(TypeDecl *)> receiver);
+                      llvm::function_ref<void(TypeDecl *)> receiver) override;
 
   /// Look for textually included declarations from the bridging header.
   ///

branches/tensorflow/include/swift/Parse/Parser.h

@@ -1019,7 +1019,6 @@ class Parser {
   ParserStatus parseGetSet(ParseDeclOptions Flags,
                            GenericParamList *GenericParams,
                            ParameterList *Indices,
-                           TypeLoc ElementTy,
                            ParsedAccessors &accessors,
                            AbstractStorageDecl *storage,
                            SourceLoc StaticLoc);