Merge remote-tracking branch 'upstream/master'

Author: mwyman

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;

include/swift/AST/ASTContext.h

@@ -829,10 +829,6 @@ class ASTContext final {
   /// \param IDC The context whose member decls should be lazily parsed.
   void parseMembers(IterableDeclContext *IDC);
 
-  /// Use the lazy parsers associated with the context to check whether the decl
-  /// context has been parsed.
-  bool hasUnparsedMembers(const IterableDeclContext *IDC) const;
-
   /// Get the lazy function data for the given generic context.
   ///
   /// \param lazyLoader If non-null, the lazy loader to use when creating the

include/swift/AST/ASTScope.h

@@ -177,8 +177,10 @@ class ASTScopeImpl {
   void addChild(ASTScopeImpl *child, ASTContext &);
   std::vector<ASTScopeImpl *> rescueYoungestChildren(unsigned count);
 
-  virtual std::vector<ASTScopeImpl *> rescueScopesToReuse();
-  virtual void addReusedScopes(ArrayRef<ASTScopeImpl *>);
+  /// When reexpanding, do we always create a new body?
+  virtual NullablePtr<ASTScopeImpl> getParentOfRescuedScopes();
+  std::vector<ASTScopeImpl *> rescueScopesToReuse();
+  void addReusedScopes(ArrayRef<ASTScopeImpl *>);
 
 private:
   void removeChildren();
@@ -201,7 +203,8 @@ class ASTScopeImpl {
   /// InterpolatedStringLiteralExprs and EditorPlaceHolders respond to
   /// getSourceRange with the starting point. But we might be asked to lookup an
   /// identifer within one of them. So, find the real source range of them here.
-  ///   /// FIXME: Alter how these are parsed so getSourceRange is enough.
+  ///
+  /// FIXME: Alter how these are parsed so getSourceRange is enough.
   SourceRange getEffectiveSourceRange(ASTNode) const;
 
   void cacheSourceRangeOfMeAndDescendants(bool omitAssertions = false) const;
@@ -303,6 +306,12 @@ class ASTScopeImpl {
   virtual void beCurrent();
   virtual bool isCurrent() const;
 
+  /// Some scopes can be expanded lazily.
+  /// Such scopes must: not change their source ranges after expansion, and
+  /// their expansion must return an insertion point outside themselves.
+  virtual NullablePtr<ASTScopeImpl> insertionPointForDeferredExpansion();
+  virtual SourceRange sourceRangeForDeferredExpansion() const;
+
 public:
   // Some nodes (VarDecls and Accessors) are created directly from
   // pattern scope code and should neither be deferred nor should
@@ -548,6 +557,10 @@ class Portion {
 
   virtual void beCurrent(IterableTypeScope *) const;
   virtual bool isCurrent(const IterableTypeScope *) const;
+  virtual NullablePtr<ASTScopeImpl>
+  insertionPointForDeferredExpansion(IterableTypeScope *) const;
+  virtual SourceRange
+  sourceRangeForDeferredExpansion(const IterableTypeScope *) const;
   };
 
   // For the whole Decl scope of a GenericType or an Extension
@@ -623,6 +636,10 @@ class IterableTypeBodyPortion final
 
   void beCurrent(IterableTypeScope *) const override;
   bool isCurrent(const IterableTypeScope *) const override;
+  NullablePtr<ASTScopeImpl>
+  insertionPointForDeferredExpansion(IterableTypeScope *) const override;
+  SourceRange
+  sourceRangeForDeferredExpansion(const IterableTypeScope *) const override;
 };
 
 /// GenericType or Extension scope
@@ -702,7 +719,6 @@ class IterableTypeScope : public GenericTypeScope {
   /// Because of \c parseDelayedDecl members can get added after the tree is
   /// constructed, and they can be out of order. Detect this happening by
   /// remembering the member count.
-  /// TODO: unify with \c numberOfDeclsAlreadySeen
   unsigned memberCount = 0;
 
 public:
@@ -721,6 +737,8 @@ class IterableTypeScope : public GenericTypeScope {
 public:
   void makeBodyCurrent();
   bool isBodyCurrent() const;
+  NullablePtr<ASTScopeImpl> insertionPointForDeferredExpansion() override;
+  SourceRange sourceRangeForDeferredExpansion() const override;
 };
 
 class NominalTypeScope final : public IterableTypeScope {
@@ -958,8 +976,7 @@ class AbstractFunctionBodyScope : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   static bool isAMethod(const AbstractFunctionDecl *);
 
-  std::vector<ASTScopeImpl *> rescueScopesToReuse() override;
-  void addReusedScopes(ArrayRef<ASTScopeImpl *>) override;
+  NullablePtr<ASTScopeImpl> getParentOfRescuedScopes() override;
 
 protected:
   bool lookupLocalsOrMembers(ArrayRef<const ASTScopeImpl *>,
@@ -1122,7 +1139,6 @@ class PatternEntryDeclScope final : public AbstractPatternEntryScope {
   SourceRange
   getChildlessSourceRange(bool omitAssertions = false) const override;
 
-  static bool isHandledSpecially(const ASTNode n);
   NullablePtr<const void> getReferrent() const override;
 
 protected:
@@ -1372,8 +1388,7 @@ class TopLevelCodeScope final : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   NullablePtr<const void> getReferrent() const override;
 
-  std::vector<ASTScopeImpl *> rescueScopesToReuse() override;
-  void addReusedScopes(ArrayRef<ASTScopeImpl *>) override;
+  NullablePtr<ASTScopeImpl> getParentOfRescuedScopes() override;
 };
 
 /// The \c _@specialize attribute.

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,

include/swift/AST/ClangModuleLoader.h

@@ -14,7 +14,6 @@
 #define SWIFT_AST_CLANG_MODULE_LOADER_H
 
 #include "swift/AST/ModuleLoader.h"
-#include "swift/Demangling/Demangle.h"
 
 namespace clang {
 class ASTContext;
@@ -28,11 +27,24 @@ namespace swift {
 class DeclContext;
 class VisibleDeclConsumer;
 
+/// Represents the different namespaces for types in C.
+///
+/// A simplified version of clang::Sema::LookupKind.
+enum class ClangTypeKind {
+  Typedef,
+  ObjCClass = Typedef,
+  /// Structs, enums, and unions.
+  Tag,
+  ObjCProtocol,
+};
+
 class ClangModuleLoader : public ModuleLoader {
 private:
   virtual void anchor();
+
 protected:
   using ModuleLoader::ModuleLoader;
+
 public:
   virtual clang::ASTContext &getClangASTContext() const = 0;
   virtual clang::Preprocessor &getClangPreprocessor() const = 0;
@@ -56,22 +68,23 @@ class ClangModuleLoader : public ModuleLoader {
   ///
   /// This routine is used for various hacks that are only permitted within
   /// overlays of imported modules, e.g., Objective-C bridging conformances.
-  virtual bool isInOverlayModuleForImportedModule(
-                                            const DeclContext *overlayDC,
-                                            const DeclContext *importedDC) = 0;
+  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) {}
+  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, Demangle::Node::Kind kind,
-                              llvm::function_ref<void(TypeDecl *)> receiver) {}
+  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,
@@ -82,11 +95,11 @@ class ClangModuleLoader : public ModuleLoader {
   /// module, it returns it. This is intended for use in reflection / debugging
   /// contexts where access is not a problem.
   virtual void
-  lookupRelatedEntity(StringRef clangName, StringRef relatedEntityKind,
-                      llvm::function_ref<void(TypeDecl *)> receiver) {}
+  lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
+                      StringRef relatedEntityKind,
+                      llvm::function_ref<void(TypeDecl *)> receiver) = 0;
 };
 
 } // namespace swift
 
 #endif // LLVM_SWIFT_AST_CLANG_MODULE_LOADER_H
-

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
@@ -1523,6 +1523,17 @@ class GenericContext : private _GenericContext, public DeclContext {
 
   /// Determine whether this context has generic parameters
   /// of its own.
+  ///
+  /// \code
+  /// class C<T> {
+  ///   func f1() {}    // isGeneric == false
+  ///   func f2<T>() {} // isGeneric == true
+  /// }
+  ///
+  /// protocol P { // isGeneric == true due to implicit Self param
+  ///   func p()   // isGeneric == false
+  /// }
+  /// \endcode
   bool isGeneric() const { return GenericParams != nullptr; }
 
   /// Retrieve the trailing where clause for this extension, if any.
@@ -2401,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,
@@ -2675,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;
@@ -3187,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 {
@@ -5913,7 +5934,7 @@ class OperatorDecl;
 enum class SelfAccessKind : uint8_t {
   NonMutating,
   Mutating,
-  __Consuming,
+  Consuming,
 };
 
 /// Diagnostic printing of \c SelfAccessKind.
@@ -6016,7 +6037,7 @@ class FuncDecl : public AbstractFunctionDecl {
     return getSelfAccessKind() == SelfAccessKind::NonMutating;
   }
   bool isConsuming() const {
-    return getSelfAccessKind() == SelfAccessKind::__Consuming;
+    return getSelfAccessKind() == SelfAccessKind::Consuming;
   }
 
   SelfAccessKind getSelfAccessKind() const;
@@ -6484,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, 
@@ -6584,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.