---

yaml
---
r: 326652
b: refs/heads/tensorflow
c: dd4c605
h: refs/heads/master

Author: gregomni

[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: 586327ac33cdc250ad222dca00cff8207f019fbe
+refs/heads/tensorflow: dd4c6053a7c73f09eb889d0f629b7a06d4fa5b74
 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,12 +2340,6 @@ 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,7 +348,10 @@ DECL_ATTR(_restatedObjCConformance, RestatedObjCConformance,
   LongAttribute | RejectByParser |
   NotSerialized, 70)
 // NOTE: 71 is unused
-// NOTE: 72 is unused
+SIMPLE_DECL_ATTR(_implicitly_unwrapped_optional, ImplicitlyUnwrappedOptional,
+  OnFunc | OnAccessor | OnVar | OnParam | OnSubscript | OnConstructor |
+  RejectByParser,
+  72)
 DECL_ATTR(_optimize, Optimize,
   OnAbstractFunction | OnSubscript | OnVar |
   UserInaccessible,

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/Decl.h

@@ -456,16 +456,16 @@ class alignas(1 << DeclAlignInBits) Decl {
     IsTransparentComputed : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ConstructorDecl, AbstractFunctionDecl, 3+1+1,
+  SWIFT_INLINE_BITFIELD(ConstructorDecl, AbstractFunctionDecl, 3+2+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,
 
-    /// Whether this constructor can fail, by building an Optional type.
-    Failable : 1,
+    /// The failability of this initializer, which is an OptionalTypeKind.
+    Failability : 2,
 
     /// Whether this initializer is a stub placed into a subclass to
     /// catch invalid delegations to a designated initializer not
@@ -2412,20 +2412,12 @@ 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,
@@ -2694,21 +2686,6 @@ 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;
@@ -3221,6 +3198,19 @@ 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 {
@@ -6505,7 +6495,7 @@ class ConstructorDecl : public AbstractFunctionDecl {
 
 public:
   ConstructorDecl(DeclName Name, SourceLoc ConstructorLoc, 
-                  bool Failable, SourceLoc FailabilityLoc,
+                  OptionalTypeKind Failability, SourceLoc FailabilityLoc,
                   bool Throws, SourceLoc ThrowsLoc,
                   ParameterList *BodyParams,
                   GenericParamList *GenericParams, 
@@ -6605,9 +6595,9 @@ class ConstructorDecl : public AbstractFunctionDecl {
     llvm_unreachable("bad CtorInitializerKind");
   }
 
-  /// Determine if this is a failable initializer.
-  bool isFailable() const {
-    return Bits.ConstructorDecl.Failable;
+  /// Determine the failability of the initializer.
+  OptionalTypeKind getFailability() const {
+    return static_cast<OptionalTypeKind>(Bits.ConstructorDecl.Failability);
   }
 
   /// Retrieve the location of the '!' or '?' in a failable initializer.

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

@@ -3843,12 +3843,11 @@ class DynamicTypeExpr : public Expr {
 /// node (say, an \c OpenExistentialExpr) and can only be used within the
 /// subexpressions of that AST node.
 class OpaqueValueExpr : public Expr {
-  SourceRange Range;
+  SourceLoc Loc;
 
 public:
-  explicit OpaqueValueExpr(SourceRange Range, Type Ty,
-                           bool isPlaceholder = false)
-      : Expr(ExprKind::OpaqueValue, /*Implicit=*/true, Ty), Range(Range) {
+  explicit OpaqueValueExpr(SourceLoc Loc, Type Ty, bool isPlaceholder = false)
+    : Expr(ExprKind::OpaqueValue, /*Implicit=*/true, Ty), Loc(Loc) {
     Bits.OpaqueValueExpr.IsPlaceholder = isPlaceholder;
   }
 
@@ -3857,8 +3856,8 @@ class OpaqueValueExpr : public Expr {
   /// value to be specified later.
   bool isPlaceholder() const { return Bits.OpaqueValueExpr.IsPlaceholder; }
 
-  SourceRange getSourceRange() const { return Range; }
-
+  SourceRange getSourceRange() const { return Loc; }
+  
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::OpaqueValue; 
   }

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

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

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/TypeCheckRequests.h

@@ -1031,27 +1031,6 @@ 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,4 +55,3 @@ 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(GenericSignature *sig=nullptr);
+  bool allowsOwnership();  
 
   /// Determine whether this type involves a type variable.
   bool hasTypeVariable() const {

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

@@ -60,19 +60,6 @@ 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.
 ///
@@ -84,13 +71,11 @@ enum { NumOptionalTypeKinds = 2 };
 /// 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
@@ -106,8 +91,10 @@ class ClangImporter final : public ClangModuleLoader {
 
   ClangImporter(ASTContext &ctx, const ClangImporterOptions &clangImporterOpts,
                 DependencyTracker *tracker,
-                DWARFImporterDelegate *dwarfImporterDelegate);
+                std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate);
 
+  ModuleDecl *loadModuleClang(SourceLoc importLoc,
+                              ArrayRef<std::pair<Identifier, SourceLoc>> path);
 public:
   /// Create a new Clang importer that can import a suitable Clang
   /// module into the given ASTContext.
@@ -130,7 +117,7 @@ class ClangImporter final : public ClangModuleLoader {
   static std::unique_ptr<ClangImporter>
   create(ASTContext &ctx, const ClangImporterOptions &importerOpts,
          std::string swiftPCHHash = "", DependencyTracker *tracker = nullptr,
-         DWARFImporterDelegate *dwarfImporterDelegate = nullptr);
+         std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate = {});
 
   ClangImporter(const ClangImporter &) = delete;
   ClangImporter(ClangImporter &&) = delete;
@@ -139,9 +126,6 @@ class ClangImporter final : public ClangModuleLoader {
 
   ~ClangImporter();
 
-  /// Only to be used by lldb-moduleimport-test.
-  void setDWARFImporterDelegate(DWARFImporterDelegate &delegate);
-
   /// Create a new clang::DependencyCollector customized to
   /// ClangImporter's specific uses.
   static std::shared_ptr<clang::DependencyCollector>
@@ -188,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,
@@ -209,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.
   ///