Merge remote-tracking branch 'upstream/master' into master-next

Author: aschwaighofer

include/swift/AST/ASTTypeIDZone.def

@@ -29,3 +29,6 @@ SWIFT_TYPEID_NAMED(Optional<PropertyWrapperMutability>, PropertyWrapperMutabilit
 SWIFT_TYPEID_NAMED(CustomAttr *, CustomAttr)
 SWIFT_TYPEID_NAMED(TypeAliasDecl *, TypeAliasDecl)
 SWIFT_TYPEID(AncestryFlags)
+SWIFT_TYPEID_NAMED(GenericSignature *, GenericSignature)
+SWIFT_TYPEID_NAMED(GenericTypeParamType *, GenericTypeParamType)
+SWIFT_TYPEID(Requirement)

include/swift/AST/ASTTypeIDs.h

@@ -21,11 +21,14 @@
 namespace swift {
 
 class CustomAttr;
+class GenericSignature;
+class GenericTypeParamType;
 class NominalTypeDecl;
 struct PropertyWrapperBackingPropertyInfo;
 struct PropertyWrapperTypeInfo;
 enum class CtorInitializerKind;
 struct PropertyWrapperMutability;
+class Requirement;
 class Type;
 class VarDecl;
 class TypeAliasDecl;

include/swift/AST/Attr.h

@@ -258,11 +258,9 @@ class DeclAttribute : public AttributeBase {
       ownership : NumReferenceOwnershipBits
     );
 
-    SWIFT_INLINE_BITFIELD_FULL(SpecializeAttr, DeclAttribute, 1+1+32,
+    SWIFT_INLINE_BITFIELD(SpecializeAttr, DeclAttribute, 1+1,
       exported : 1,
-      kind : 1,
-      : NumPadBits,
-      numRequirements : 32
+      kind : 1
     );
 
     SWIFT_INLINE_BITFIELD(SynthesizedProtocolAttr, DeclAttribute,
@@ -1236,39 +1234,29 @@ class SpecializeAttr : public DeclAttribute {
 
 private:
   TrailingWhereClause *trailingWhereClause;
-
-  Requirement *getRequirementsData() {
-    return reinterpret_cast<Requirement *>(this+1);
-  }
+  GenericSignature *specializedSignature;
 
   SpecializeAttr(SourceLoc atLoc, SourceRange Range,
                  TrailingWhereClause *clause, bool exported,
-                 SpecializationKind kind);
-
-  SpecializeAttr(SourceLoc atLoc, SourceRange Range,
-                 ArrayRef<Requirement> requirements,
-                 bool exported,
-                 SpecializationKind kind);
+                 SpecializationKind kind,
+                 GenericSignature *specializedSignature);
 
 public:
   static SpecializeAttr *create(ASTContext &Ctx, SourceLoc atLoc,
                                 SourceRange Range, TrailingWhereClause *clause,
-                                bool exported, SpecializationKind kind);
-
-  static SpecializeAttr *create(ASTContext &Ctx, SourceLoc atLoc,
-                                SourceRange Range,
-                                ArrayRef<Requirement> requirement,
-                                bool exported, SpecializationKind kind);
+                                bool exported, SpecializationKind kind,
+                                GenericSignature *specializedSignature
+                                    = nullptr);
 
   TrailingWhereClause *getTrailingWhereClause() const;
 
-  ArrayRef<Requirement> getRequirements() const;
-
-  MutableArrayRef<Requirement> getRequirements() {
-    return { getRequirementsData(), Bits.SpecializeAttr.numRequirements };
+  GenericSignature *getSpecializedSgnature() const {
+    return specializedSignature;
   }
 
-  void setRequirements(ASTContext &Ctx, ArrayRef<Requirement> requirements);
+  void setSpecializedSignature(GenericSignature *newSig) {
+    specializedSignature = newSig;
+  }
 
   bool isExported() const {
     return Bits.SpecializeAttr.exported;

include/swift/AST/GenericSignature.h

@@ -335,6 +335,8 @@ CanGenericSignature::CanGenericSignature(GenericSignature *Signature)
   assert(!Signature || Signature->isCanonical());
 }
 
+void simple_display(raw_ostream &out, const GenericSignature *sig);
+
 } // end namespace swift
 
 #endif // SWIFT_AST_GENERIC_SIGNATURE_H

include/swift/AST/LayoutConstraint.h

@@ -21,6 +21,7 @@
 #include "swift/Basic/SourceLoc.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringRef.h"
 #include "swift/AST/PrintOptions.h"
 
@@ -290,6 +291,10 @@ class LayoutConstraint {
   /// Return the layout constraint as a string, for use in diagnostics only.
   std::string getString(const PrintOptions &PO = PrintOptions()) const;
 
+  friend llvm::hash_code hash_value(const LayoutConstraint &layout) {
+    return hash_value(layout.getPointer());
+  }
+
   bool operator==(LayoutConstraint rhs) const {
     if (isNull() && rhs.isNull())
       return true;

include/swift/AST/Module.h

@@ -644,7 +644,10 @@ static inline unsigned alignOfFileUnit();
 /// FileUnit is an abstract base class; its subclasses represent different
 /// sorts of containers that can each provide a set of decls, e.g. a source
 /// file. A module can contain several file-units.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnon-virtual-dtor"
 class FileUnit : public DeclContext {
+#pragma clang diagnostic pop
   virtual void anchor();
 
   // FIXME: Stick this in a PointerIntPair.
@@ -655,8 +658,6 @@ class FileUnit : public DeclContext {
     : DeclContext(DeclContextKind::FileUnit, &M), Kind(kind) {
   }
 
-  virtual ~FileUnit() = default;
-
 public:
   FileUnitKind getKind() const {
     return Kind;
@@ -874,10 +875,6 @@ class FileUnit : public DeclContext {
     return getParentModule()->getName().str();
   }
 
-  /// If this is a module imported from a parseable interface, return the path
-  /// to the interface file, otherwise an empty StringRef.
-  virtual StringRef getParseableInterface() const { return {}; }
-
   /// Traverse the decls within this file.
   ///
   /// \returns true if traversal was aborted, false if it completed
@@ -897,13 +894,7 @@ class FileUnit : public DeclContext {
   // Make placement new and vanilla new/delete illegal for FileUnits.
   void *operator new(size_t Bytes) throw() = delete;
   void *operator new(size_t Bytes, void *Mem) throw() = delete;
-
-protected:
-  // Unfortunately we can't remove this altogether because the virtual
-  // destructor requires it to be accessible.
-  void operator delete(void *Data) throw() {
-    llvm_unreachable("Don't use operator delete on a SourceFile");
-  }
+  void operator delete(void *Data) throw() = delete;
 
 public:
   // Only allow allocation of FileUnits using the allocator in ASTContext
@@ -1386,35 +1377,23 @@ class BuiltinUnit final : public FileUnit {
 };
 
 /// Represents an externally-loaded file of some kind.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnon-virtual-dtor"
 class LoadedFile : public FileUnit {
+#pragma clang diagnostic pop
 protected:
-  ~LoadedFile() = default;
   LoadedFile(FileUnitKind Kind, ModuleDecl &M) noexcept
     : FileUnit(Kind, M) {
     assert(classof(this) && "invalid kind");
   }
-
-  /// A map from private/fileprivate decls to the file they were defined in.
-  llvm::DenseMap<const ValueDecl *, Identifier> FilenameForPrivateDecls;
-
 public:
-
   /// Returns an arbitrary string representing the storage backing this file.
   ///
   /// This is usually a filesystem path.
   virtual StringRef getFilename() const;
 
-  void addFilenameForPrivateDecl(const ValueDecl *decl, Identifier id) {
-    assert(!FilenameForPrivateDecls.count(decl) ||
-           FilenameForPrivateDecls[decl] == id);
-    FilenameForPrivateDecls[decl] = id;
-  }
-
-  StringRef getFilenameForPrivateDecl(const ValueDecl *decl) {
-    auto it = FilenameForPrivateDecls.find(decl);
-    if (it == FilenameForPrivateDecls.end())
-      return StringRef();
-    return it->second.str();
+  virtual StringRef getFilenameForPrivateDecl(const ValueDecl *decl) const {
+    return StringRef();
   }
 
   /// Look up an operator declaration.

include/swift/AST/Requirement.h

@@ -18,6 +18,7 @@
 #define SWIFT_AST_REQUIREMENT_H
 
 #include "swift/AST/Type.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/Support/ErrorHandling.h"
 
@@ -119,12 +120,60 @@ class Requirement {
     return SecondLayout;
   }
 
+  /// Whether this requirement is in its canonical form.
+  bool isCanonical() const;
+
+  /// Get the canonical form of this requirement.
+  Requirement getCanonical() const;
+
   void dump() const;
   void dump(raw_ostream &out) const;
   void print(raw_ostream &os, const PrintOptions &opts) const;
   void print(ASTPrinter &printer, const PrintOptions &opts) const;
+
+  friend llvm::hash_code hash_value(const Requirement &requirement) {
+    using llvm::hash_value;
+
+    llvm::hash_code first =
+        hash_value(requirement.FirstTypeAndKind.getOpaqueValue());
+    llvm::hash_code second;
+    switch (requirement.getKind()) {
+    case RequirementKind::Conformance:
+    case RequirementKind::Superclass:
+    case RequirementKind::SameType:
+      second = hash_value(requirement.getSecondType());
+      break;
+
+    case RequirementKind::Layout:
+      second = hash_value(requirement.getLayoutConstraint());
+      break;
+    }
+
+    return llvm::hash_combine(first, second);
+  }
+
+  friend bool operator==(const Requirement &lhs, const Requirement &rhs) {
+    if (lhs.FirstTypeAndKind.getOpaqueValue()
+          != rhs.FirstTypeAndKind.getOpaqueValue())
+      return false;
+
+    switch (lhs.getKind()) {
+    case RequirementKind::Conformance:
+    case RequirementKind::Superclass:
+    case RequirementKind::SameType:
+      return lhs.getSecondType().getPointer() ==
+          rhs.getSecondType().getPointer();
+
+    case RequirementKind::Layout:
+      return lhs.getLayoutConstraint() == rhs.getLayoutConstraint();
+    }
+  }
 };
 
+inline void simple_display(llvm::raw_ostream &out, const Requirement &req) {
+  req.print(out, PrintOptions());
+}
+
 } // end namespace swift
 
 #endif

include/swift/AST/SimpleRequest.h

@@ -261,4 +261,11 @@ class SimpleRequest<Derived, Output(Inputs...), Caching> {
 };
 }
 
+namespace llvm {
+  template <typename T, unsigned N>
+  llvm::hash_code hash_value(const SmallVector<T, N> &vec) {
+    return hash_combine_range(vec.begin(), vec.end());
+  }
+}
+
 #endif // SWIFT_BASIC_SIMPLEREQUEST_H

include/swift/AST/Type.h

@@ -19,6 +19,7 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/STLExtras.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/ArrayRefView.h"
@@ -323,6 +324,11 @@ class Type {
   /// Return the name of the type as a string, for use in diagnostics only.
   std::string getString(const PrintOptions &PO = PrintOptions()) const;
 
+  friend llvm::hash_code hash_value(Type type) {
+    using llvm::hash_value;
+    return hash_value(type.getPointer());
+  }
+
   /// Return the name of the type, adding parens in cases where
   /// appending or prepending text to the result would cause that text
   /// to be appended to only a portion of the returned type. For

include/swift/AST/TypeCheckRequests.h

@@ -30,6 +30,8 @@
 namespace swift {
 
 class AbstractStorageDecl;
+class AccessorDecl;
+enum class AccessorKind;
 class GenericParamList;
 struct PropertyWrapperBackingPropertyInfo;
 struct PropertyWrapperMutability;
@@ -38,8 +40,8 @@ class SpecializeAttr;
 class TypeAliasDecl;
 struct TypeLoc;
 class ValueDecl;
-class AbstractStorageDecl;
 enum class OpaqueReadOwnership: uint8_t;
+class StorageImplInfo;
 
 /// Display a nominal type or extension thereof.
 void simple_display(
@@ -1073,6 +1075,35 @@ class ClassAncestryFlagsRequest :
 
 void simple_display(llvm::raw_ostream &out, AncestryFlags value);
 
+class AbstractGenericSignatureRequest :
+    public SimpleRequest<AbstractGenericSignatureRequest,
+                         GenericSignature *(GenericSignature *,
+                                            SmallVector<GenericTypeParamType *, 2>,
+                                            SmallVector<Requirement, 2>),
+                         CacheKind::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<GenericSignature *>
+  evaluate(Evaluator &evaluator,
+           GenericSignature *baseSignature,
+           SmallVector<GenericTypeParamType *, 2> addedParameters,
+           SmallVector<Requirement, 2> addedRequirements) const;
+
+public:
+  // Separate caching.
+  bool isCached() const;
+
+  /// Abstract generic signature requests never have source-location info.
+  SourceLoc getNearestLoc() const {
+    return SourceLoc();
+  }
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -57,3 +57,4 @@ SWIFT_TYPEID(SynthesizeAccessorRequest)
 SWIFT_TYPEID(EmittedMembersRequest)
 SWIFT_TYPEID(IsImplicitlyUnwrappedOptionalRequest)
 SWIFT_TYPEID(ClassAncestryFlagsRequest)
+SWIFT_TYPEID(AbstractGenericSignatureRequest)

include/swift/Basic/SimpleDisplay.h

@@ -121,6 +121,20 @@ namespace swift {
     }
     out << "}";
   }
+
+  template<typename T>
+  void simple_display(llvm::raw_ostream &out,
+                      const llvm::SmallVectorImpl<T> &vec) {
+    out << "{";
+    bool first = true;
+    for (const T &value : vec) {
+      if (first) first = false;
+      else out << ", ";
+
+      simple_display(out, value);
+    }
+    out << "}";
+  }
 }
 
 #endif // SWIFT_BASIC_SIMPLE_DISPLAY_H

include/swift/ClangImporter/ClangModule.h

@@ -39,8 +39,6 @@ class ClangModuleUnit final : public LoadedFile {
   /// The metadata of the underlying Clang module.
   clang::ExternalASTSource::ASTSourceDescriptor ASTSourceDescriptor;
 
-  ~ClangModuleUnit() = default;
-
 public:
   /// True if the given Module contains an imported Clang module unit.
   static bool hasClangModule(ModuleDecl *M);