Merge remote-tracking branch 'origin/master' into new-integer-protocols

Author: Max Moiseev

docs/ABI.rst

@@ -889,7 +889,7 @@ Entities
   entity-spec ::= decl-name type 'i'                 // subscript ('i'ndex) itself (not the individual accessors)
   entity-spec ::= decl-name type 'v'                 // variable
   entity-spec ::= decl-name type 'f' ACCESSOR
-  entity-spec ::= decl-name type 'fp'                // generic type parameter (not used?)
+  entity-spec ::= decl-name type 'fp'                // generic type parameter
   entity-spec ::= decl-name type 'fo'                // enum element (currently not used)
 
   ACCESSOR ::= 'm'                           // materializeForSet
@@ -958,14 +958,15 @@ Types
 
 ::
 
-  nominal-type ::= substitution
-  nominal-type ::= context decl-name 'C'     // nominal class type
-  nominal-type ::= context decl-name 'O'     // nominal enum type
-  nominal-type ::= context decl-name 'V'     // nominal struct type
-  nominal-type ::= protocol 'P'              // nominal protocol type
+  any-generic-type ::= substitution
+  any-generic-type ::= context decl-name 'C'     // nominal class type
+  any-generic-type ::= context decl-name 'O'     // nominal enum type
+  any-generic-type ::= context decl-name 'V'     // nominal struct type
+  any-generic-type ::= protocol 'P'              // nominal protocol type
+  any-generic-type ::= context decl-name 'a'     // typealias type (used in DWARF and USRs)
 
-  nominal-type ::= 'S' KNOWN-TYPE-KIND       // known nominal type substitution
-  nominal-type ::= 'S' NATURAL KNOWN-TYPE-KIND    // repeated known type substitutions of the same kind
+  any-generic-type ::= 'S' KNOWN-TYPE-KIND       // known nominal type substitution
+  any-generic-type ::= 'S' NATURAL KNOWN-TYPE-KIND    // repeated known type substitutions of the same kind
 
   KNOWN-TYPE-KIND ::= 'a'                    // Swift.Array
   KNOWN-TYPE-KIND ::= 'b'                    // Swift.Bool
@@ -995,7 +996,6 @@ Types
   type ::= 'Bp'                              // Builtin.RawPointer
   type ::= type 'Bv' NATURAL '_'             // Builtin.Vec<n>x<type>
   type ::= 'Bw'                              // Builtin.Word
-  type ::= context decl-name 'a'             // Type alias (DWARF only)
   type ::= function-signature 'c'            // function type
   type ::= function-signature 'X' FUNCTION-KIND // special function type
   type ::= bound-generic-type
@@ -1042,7 +1042,7 @@ Types
 
   type ::= archetype
   type ::= associated-type
-  type ::= nominal-type
+  type ::= any-generic-type
   type ::= protocol-list 'p'                 // existential type
   type ::= protocol-list superclass 'Xc'     // existential type with superclass
   type ::= protocol-list 'Xl'                // existential type with AnyObject

include/swift/AST/ASTMangler.h

@@ -38,6 +38,11 @@ class ASTMangler : public Mangler {
   /// If enabled, Arche- and Alias types are mangled with context.
   bool DWARFMangling;
 
+  /// If enabled, entities that ought to have names but don't get a placeholder.
+  ///
+  /// If disabled, it is an error to try to mangle such an entity.
+  bool AllowNamelessEntities = false;
+
 public:
   enum class SymbolKind {
     Default,
@@ -122,7 +127,7 @@ class ASTMangler : public Mangler {
 
   std::string mangleTypeAsContextUSR(const NominalTypeDecl *type);
 
-  std::string mangleDeclAsUSR(ValueDecl *Decl, StringRef USRPrefix);
+  std::string mangleDeclAsUSR(const ValueDecl *Decl, StringRef USRPrefix);
 
   std::string mangleAccessorEntityAsUSR(AccessorKind kind,
                                         AddressorKind addressorKind,
@@ -167,7 +172,7 @@ class ASTMangler : public Mangler {
 
   void appendProtocolName(const ProtocolDecl *protocol);
 
-  void appendNominalType(const NominalTypeDecl *decl);
+  void appendAnyGenericType(const GenericTypeDecl *decl);
 
   void appendFunctionType(AnyFunctionType *fn, bool forceSingleParam);
 
@@ -207,7 +212,7 @@ class ASTMangler : public Mangler {
 
   void appendDeclType(const ValueDecl *decl, bool isFunctionMangling = false);
 
-  bool tryAppendStandardSubstitution(const NominalTypeDecl *type);
+  bool tryAppendStandardSubstitution(const GenericTypeDecl *type);
 
   void appendConstructorEntity(const ConstructorDecl *ctor, bool isAllocating);
 

include/swift/Basic/Mangler.h

@@ -14,14 +14,13 @@
 #define SWIFT_BASIC_MANGLER_H
 
 #include "swift/Demangling/ManglingUtils.h"
+#include "swift/Basic/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/raw_ostream.h"
 
-using llvm::StringRef;
-using llvm::ArrayRef;
-
 namespace swift {
 namespace Mangle {
 
@@ -39,7 +38,7 @@ class Mangler {
   friend class SubstitutionMerging;
 
   /// The storage for the mangled symbol.
-  llvm::SmallVector<char, 128> Storage;
+  llvm::SmallString<128> Storage;
 
   /// The output stream for the mangled symbol.
   llvm::raw_svector_ostream Buffer;
@@ -106,7 +105,7 @@ class Mangler {
   void finalize(llvm::raw_ostream &stream);
 
   /// Verify that demangling and remangling works.
-  void verify(const std::string &mangledName);
+  static void verify(StringRef mangledName);
 
   /// Appends a mangled identifier string.
   void appendIdentifier(StringRef ident);

include/swift/Demangling/DemangleNodes.def

@@ -149,7 +149,7 @@ NODE(Tuple)
 NODE(TupleElement)
 NODE(TupleElementName)
 NODE(Type)
-NODE(TypeAlias)
+CONTEXT_NODE(TypeAlias)
 NODE(TypeList)
 NODE(TypeMangling)
 NODE(TypeMetadata)

include/swift/Demangling/Demangler.h

@@ -405,8 +405,7 @@ class Demangler : public NodeFactory {
   NodePointer popTypeAndGetChild();
   NodePointer popTypeAndGetNominal();
   NodePointer demangleBuiltinType();
-  NodePointer demangleNominalType(Node::Kind kind);
-  NodePointer demangleTypeAlias();
+  NodePointer demangleAnyGenericType(Node::Kind kind);
   NodePointer demangleExtensionContext();
   NodePointer demanglePlainFunction();
   NodePointer popFunctionType(Node::Kind kind);

include/swift/IDE/APIDigesterData.h

@@ -14,7 +14,9 @@
 #define SWIFT_IDE_APIDIGESTERDATA_H
 
 #include "swift/Basic/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace swift {
@@ -27,26 +29,42 @@ enum class SDKNodeKind: uint8_t {
 #include "DigesterEnums.def"
 };
 
+SDKNodeKind parseSDKNodeKind(StringRef Content);
+
 enum class NodeAnnotation: uint8_t{
 #define NODE_ANNOTATION(NAME) NAME,
 #include "DigesterEnums.def"
 };
 
+NodeAnnotation parseSDKNodeAnnotation(StringRef Content);
+
+enum class APIDiffItemKind: uint8_t{
+#define DIFF_ITEM_KIND(NAME) ADK_##NAME,
+#include "DigesterEnums.def"
+};
+
 // Redefine << so that we can output the name of the annotation kind.
 raw_ostream &operator<<(raw_ostream &Out, const NodeAnnotation Value);
 
 // Redefine << so that we can output the name of the node kind.
 raw_ostream &operator<<(raw_ostream &Out, const SDKNodeKind Value);
 
-// DiffItem describes how an element in SDK evolves in a way that migrator can
-// read conveniently. Each DiffItem corresponds to one JSON element and contains
+struct APIDiffItem {
+  virtual void streamDef(llvm::raw_ostream &S) const = 0;
+  virtual APIDiffItemKind getKind() const = 0;
+  virtual StringRef getKey() const = 0;
+  virtual ~APIDiffItem() = default;
+};
+
+// CommonDiffItem describes how an element in SDK evolves in a way that migrator can
+// read conveniently. Each CommonDiffItem corresponds to one JSON element and contains
 // sub fields explaining how migrator can assist client code to cope with such
 // SDK change. For instance, the following first JSON element describes an unwrap
 // optional change in the first parameter of function "c:@F@CTTextTabGetOptions".
 // Similarly, the second JSON element describes a type parameter down cast in the
 // second parameter of function "c:objc(cs)NSXMLDocument(im)insertChildren:atIndex:".
 // We keep both usrs because in the future this may support auto-rename.
-struct DiffItem {
+struct CommonDiffItem: public APIDiffItem {
   SDKNodeKind NodeKind;
   NodeAnnotation DiffKind;
   StringRef ChildIndex;
@@ -56,15 +74,21 @@ struct DiffItem {
   StringRef RightComment;
   StringRef ModuleName;
 
-  DiffItem(SDKNodeKind NodeKind, NodeAnnotation DiffKind, StringRef ChildIndex,
-           StringRef LeftUsr, StringRef RightUsr, StringRef LeftComment,
-           StringRef RightComment, StringRef ModuleName);
+  CommonDiffItem(SDKNodeKind NodeKind, NodeAnnotation DiffKind,
+                 StringRef ChildIndex, StringRef LeftUsr, StringRef RightUsr,
+                 StringRef LeftComment, StringRef RightComment,
+                 StringRef ModuleName);
 
   static StringRef head();
-  bool operator<(DiffItem Other) const;
+  bool operator<(CommonDiffItem Other) const;
+  static bool classof(const APIDiffItem *D);
   static void describe(llvm::raw_ostream &os);
   static void undef(llvm::raw_ostream &os);
-  void streamDef(llvm::raw_ostream &S) const;
+  void streamDef(llvm::raw_ostream &S) const override;
+  StringRef getKey() const override { return LeftUsr; }
+  APIDiffItemKind getKind() const override {
+    return APIDiffItemKind::ADK_CommonDiffItem;
+  }
 };
 
 
@@ -149,46 +173,95 @@ struct DiffItem {
 //  myColor.components
 //
 //
-struct TypeMemberDiffItem {
+struct TypeMemberDiffItem: public APIDiffItem {
   StringRef usr;
   StringRef newTypeName;
   StringRef newPrintedName;
   Optional<uint8_t> selfIndex;
   StringRef oldPrintedName;
 
+  TypeMemberDiffItem(StringRef usr, StringRef newTypeName,
+                     StringRef newPrintedName, Optional<uint8_t> selfIndex,
+                     StringRef oldPrintedName) : usr(usr),
+    newTypeName(newTypeName), newPrintedName(newPrintedName),
+    selfIndex(selfIndex), oldPrintedName(oldPrintedName) {}
   static StringRef head();
   static void describe(llvm::raw_ostream &os);
   static void undef(llvm::raw_ostream &os);
-  void streamDef(llvm::raw_ostream &os) const;
+  void streamDef(llvm::raw_ostream &os) const override;
   bool operator<(TypeMemberDiffItem Other) const;
+  static bool classof(const APIDiffItem *D);
+  StringRef getKey() const override { return usr; }
+  APIDiffItemKind getKind() const override {
+    return APIDiffItemKind::ADK_TypeMemberDiffItem;
+  }
 };
 
-struct NoEscapeFuncParam {
+struct NoEscapeFuncParam: public APIDiffItem {
   StringRef Usr;
   unsigned Index;
 
   NoEscapeFuncParam(StringRef Usr, unsigned Index) : Usr(Usr), Index(Index) {}
   static StringRef head();
   static void describe(llvm::raw_ostream &os);
   static void undef(llvm::raw_ostream &os);
-  void streamDef(llvm::raw_ostream &os) const;
+  void streamDef(llvm::raw_ostream &os) const override;
   bool operator<(NoEscapeFuncParam Other) const;
+  static bool classof(const APIDiffItem *D);
+  StringRef getKey() const override { return Usr; }
+  APIDiffItemKind getKind() const override {
+    return APIDiffItemKind::ADK_NoEscapeFuncParam;
+  }
 };
 
 /// This info is about functions meet the following criteria:
 ///   - This function is a member function of a type.
 ///   - This function is overloaded.
-struct OverloadedFuncInfo {
+struct OverloadedFuncInfo: public APIDiffItem {
   StringRef Usr;
 
   OverloadedFuncInfo(StringRef Usr) : Usr(Usr) {}
   static StringRef head();
   static void describe(llvm::raw_ostream &os);
   static void undef(llvm::raw_ostream &os);
-  void streamDef(llvm::raw_ostream &os) const;
+  void streamDef(llvm::raw_ostream &os) const override;
   bool operator<(OverloadedFuncInfo Other) const;
+  static bool classof(const APIDiffItem *D);
+  StringRef getKey() const override { return Usr; }
+  APIDiffItemKind getKind() const override {
+    return APIDiffItemKind::ADK_OverloadedFuncInfo;
+  }
+};
+
+/// APIDiffItem store is the interface that migrator should communicates with;
+/// Given a key, usually the usr of the system entity under migration, the store
+/// should return a slice of related changes in the same format of
+/// swift-api-digester. This struct also handles the serialization and
+/// deserialization of all kinds of API diff items declared above.
+struct APIDiffItemStore {
+  struct Implementation;
+  Implementation &Impl;
+  static void serialize(llvm::raw_ostream &os, ArrayRef<APIDiffItem*> Items);
+  APIDiffItemStore();
+  ~APIDiffItemStore();
+  ArrayRef<APIDiffItem*> getDiffItems(StringRef Key) const;
+  ArrayRef<APIDiffItem*> getAllDiffItems() const;
+
+  /// Add a path of a JSON file dumped from swift-api-digester that contains
+  /// API changes we care about. Calling this can be heavy since the procedure
+  /// will parse and index the data inside of the given file.
+  void addStorePath(StringRef Path);
 };
 }
 }
+namespace json {
+template<>
+struct ScalarEnumerationTraits<ide::api::SDKNodeKind> {
+  static void enumeration(Output &out, ide::api::SDKNodeKind &value) {
+#define NODE_KIND(X) out.enumCase(value, #X, ide::api::SDKNodeKind::X);
+#include "swift/IDE/DigesterEnums.def"
+  }
+};
+}
 }
 #endif // SWIFT_IDE_APIDIGESTERDATA_H

include/swift/IDE/DigesterEnums.def

@@ -18,6 +18,14 @@
 #define KNOWN_TYPE(NAME)
 #endif
 
+#ifndef DIFF_ITEM_KIND
+#define DIFF_ITEM_KIND(NAME)
+#endif
+
+#ifndef DIFF_ITEM_KEY_KIND
+#define DIFF_ITEM_KEY_KIND(NAME)
+#endif
+
 NODE_KIND(Root)
 NODE_KIND(TypeDecl)
 NODE_KIND(TypeNominal)
@@ -82,6 +90,41 @@ KNOWN_TYPE(Void)
 KNOWN_TYPE(Unmanaged)
 KNOWN_TYPE(Function)
 
+DIFF_ITEM_KIND(CommonDiffItem)
+DIFF_ITEM_KIND(TypeMemberDiffItem)
+DIFF_ITEM_KIND(NoEscapeFuncParam)
+DIFF_ITEM_KIND(OverloadedFuncInfo)
+
+#ifndef DIFF_ITEM_KEY_KIND_STRING
+#define DIFF_ITEM_KEY_KIND_STRING(NAME) DIFF_ITEM_KEY_KIND(NAME)
+#endif
+
+#ifndef DIFF_ITEM_KEY_KIND_INT
+#define DIFF_ITEM_KEY_KIND_INT(NAME) DIFF_ITEM_KEY_KIND(NAME)
+#endif
+
+DIFF_ITEM_KEY_KIND_STRING(DiffItemKind)
+DIFF_ITEM_KEY_KIND_STRING(NodeKind)
+DIFF_ITEM_KEY_KIND_STRING(NodeAnnotation)
+DIFF_ITEM_KEY_KIND_STRING(Usr)
+DIFF_ITEM_KEY_KIND_STRING(ChildIndex)
+DIFF_ITEM_KEY_KIND_STRING(LeftUsr)
+DIFF_ITEM_KEY_KIND_STRING(LeftComment)
+DIFF_ITEM_KEY_KIND_STRING(RightUsr)
+DIFF_ITEM_KEY_KIND_STRING(RightComment)
+DIFF_ITEM_KEY_KIND_STRING(ModuleName)
+DIFF_ITEM_KEY_KIND_STRING(NewTypeName)
+DIFF_ITEM_KEY_KIND_STRING(NewPrintedName)
+DIFF_ITEM_KEY_KIND_STRING(OldPrintedName)
+
+DIFF_ITEM_KEY_KIND_INT(SelfIndex)
+DIFF_ITEM_KEY_KIND_INT(Index)
+
+#undef DIFF_ITEM_KEY_KIND_INT
+#undef DIFF_ITEM_KEY_KIND_STRING
+
+#undef DIFF_ITEM_KEY_KIND
+#undef DIFF_ITEM_KIND
 #undef KNOWN_TYPE
 #undef KEY
 #undef DECL_ATTR