Merge branch 'master' of https://github.com/apple/swift

Author: DavidGoldman

CMakeLists.txt

@@ -93,6 +93,15 @@ option(SWIFT_INCLUDE_DOCS
     "Create targets for building docs."
     TRUE)
 
+set(_swift_include_apinotes_default FALSE)
+if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+  set(_swift_include_apinotes_default TRUE)
+endif()
+
+option(SWIFT_INCLUDE_APINOTES
+  "Create targets for installing the remaining apinotes in the built toolchain."
+  ${_swift_include_apinotes_default})
+
 #
 # Miscellaneous User-configurable options.
 #
@@ -1042,12 +1051,8 @@ endif()
 # https://bugs.swift.org/browse/SR-5975
 add_subdirectory(stdlib)
 
-if(SWIFT_BUILD_SDK_OVERLAY)
-  list_intersect("${SWIFT_APPLE_PLATFORMS}" "${SWIFT_SDKS}"
-                 building_darwin_sdks)
-  if(building_darwin_sdks)
-    add_subdirectory(apinotes)
-  endif()
+if(SWIFT_INCLUDE_APINOTES)
+  add_subdirectory(apinotes)
 endif()
 
 add_subdirectory(include)

apinotes/CMakeLists.txt

@@ -28,10 +28,6 @@ add_custom_target("copy_apinotes"
     COMMENT "Copying API notes to ${output_dir}"
     SOURCES "${sources}")
 
-# This is treated as an OPTIONAL target because if we don't build the SDK
-# overlay, the files will be missing anyway. It also allows us to build
-# single overlays without installing the API notes.
 swift_install_in_component(DIRECTORY "${output_dir}"
                            DESTINATION "lib/swift/"
-                           COMPONENT sdk-overlay
-                           OPTIONAL)
+                           COMPONENT compiler)

include/swift/ABI/Metadata.h

@@ -457,6 +457,7 @@ template <typename Runtime> struct TargetStructMetadata;
 template <typename Runtime> struct TargetOpaqueMetadata;
 template <typename Runtime> struct TargetValueMetadata;
 template <typename Runtime> struct TargetForeignClassMetadata;
+template <typename Runtime> struct TargetContextDescriptor;
 template <typename Runtime> class TargetTypeContextDescriptor;
 template <typename Runtime> class TargetClassDescriptor;
 template <typename Runtime> class TargetValueTypeDescriptor;
@@ -2085,12 +2086,12 @@ struct TargetTypeMetadataRecord {
 private:
   union {
     /// A direct reference to a nominal type descriptor.
-    RelativeDirectPointerIntPair<TargetTypeContextDescriptor<Runtime>,
+    RelativeDirectPointerIntPair<TargetContextDescriptor<Runtime>,
                                  TypeReferenceKind>
       DirectNominalTypeDescriptor;
 
     /// An indirect reference to a nominal type descriptor.
-    RelativeDirectPointerIntPair<TargetTypeContextDescriptor<Runtime> * const,
+    RelativeDirectPointerIntPair<TargetContextDescriptor<Runtime> * const,
                                  TypeReferenceKind>
       IndirectNominalTypeDescriptor;
 
@@ -2103,8 +2104,8 @@ struct TargetTypeMetadataRecord {
     return DirectNominalTypeDescriptor.getInt();
   }
 
-  const TargetTypeContextDescriptor<Runtime> *
-  getTypeContextDescriptor() const {
+  const TargetContextDescriptor<Runtime> *
+  getContextDescriptor() const {
     switch (getTypeKind()) {
     case TypeReferenceKind::DirectTypeDescriptor:
       return DirectNominalTypeDescriptor.getPointer();
@@ -3043,11 +3044,16 @@ struct TargetOpaqueTypeDescriptor final
     return getNumUnderlyingTypeArguments();
   }
 
+  const RelativeDirectPointer<const char> &
+  getUnderlyingTypeArgumentMangledName(unsigned i) const {
+    assert(i < getNumUnderlyingTypeArguments());
+    return (this
+         ->template getTrailingObjects<RelativeDirectPointer<const char>>())[i];
+  }
+  
   StringRef getUnderlyingTypeArgument(unsigned i) const {
     assert(i < getNumUnderlyingTypeArguments());
-    const char *ptr =
-    (this->template getTrailingObjects<RelativeDirectPointer<const char>>())[i];
-    
+    const char *ptr = getUnderlyingTypeArgumentMangledName(i);    
     return Demangle::makeSymbolicMangledNameStringRef(ptr);
   }
 

include/swift/AST/ASTMangler.h

@@ -171,6 +171,8 @@ class ASTMangler : public Mangler {
 
   std::string mangleTypeForDebugger(Type decl, const DeclContext *DC);
 
+  std::string mangleOpaqueTypeDescriptor(const OpaqueTypeDecl *decl);
+  
   std::string mangleDeclType(const ValueDecl *decl);
 
   std::string mangleObjCRuntimeName(const NominalTypeDecl *Nominal);

include/swift/AST/Module.h

@@ -1397,7 +1397,7 @@ class LoadedFile : public FileUnit {
   }
 
   /// Returns the Swift module that overlays a Clang module.
-  virtual ModuleDecl *getAdapterModule() const { return nullptr; }
+  virtual ModuleDecl *getOverlayModule() const { return nullptr; }
 
   virtual bool isSystemModule() const { return false; }
 

include/swift/AST/Types.h

@@ -4803,6 +4803,18 @@ class OpaqueTypeArchetypeType final : public ArchetypeType,
     return T->getKind() == TypeKind::OpaqueTypeArchetype;
   }
 
+  /// Get the ordinal of the type within the declaration's opaque signature.
+  ///
+  /// If a method declared its return type as:
+  ///
+  ///   func foo() -> (some P, some Q)
+  ///
+  /// then the underlying type of `some P` would be ordinal 0, and `some Q` would be ordinal 1.
+  unsigned getOrdinal() const {
+    // TODO: multiple opaque types
+    return 0;
+  }
+  
   static void Profile(llvm::FoldingSetNodeID &ID,
                       OpaqueTypeDecl *OpaqueDecl,
                       SubstitutionMap Substitutions);

include/swift/ClangImporter/ClangImporterOptions.h

@@ -94,8 +94,8 @@ class ClangImporterOptions {
   /// and this is not set, clang will rebuild the module.
   bool DisableModulesValidateSystemHeaders = false;
 
-  /// When set, don't look for or load adapter modules.
-  bool DisableAdapterModules = false;
+  /// When set, don't look for or load overlays.
+  bool DisableOverlayModules = false;
 
   /// When set, don't enforce warnings with -Werror.
   bool DebuggerSupport = false;
@@ -118,7 +118,7 @@ class ClangImporterOptions {
     Code = hash_combine(Code, InferImportAsMember);
     Code = hash_combine(Code, DisableSwiftBridgeAttr);
     Code = hash_combine(Code, DisableModulesValidateSystemHeaders);
-    Code = hash_combine(Code, DisableAdapterModules);
+    Code = hash_combine(Code, DisableOverlayModules);
     return Code;
   }
 };

include/swift/ClangImporter/ClangModule.h

@@ -34,7 +34,7 @@ class ModuleLoader;
 class ClangModuleUnit final : public LoadedFile {
   ClangImporter::Implementation &owner;
   const clang::Module *clangModule;
-  llvm::PointerIntPair<ModuleDecl *, 1, bool> adapterModule;
+  llvm::PointerIntPair<ModuleDecl *, 1, bool> overlayModule;
   mutable ArrayRef<ModuleDecl::ImportedModule> importedModulesForLookup;
   /// The metadata of the underlying Clang module.
   clang::ExternalASTSource::ASTSourceDescriptor ASTSourceDescriptor;
@@ -57,7 +57,7 @@ class ClangModuleUnit final : public LoadedFile {
   bool isTopLevel() const;
 
   /// Returns the Swift module that overlays this Clang module.
-  ModuleDecl *getAdapterModule() const override;
+  ModuleDecl *getOverlayModule() const override;
 
   /// Retrieve the "exported" name of the module, which is usually the module
   /// name, but might be the name of the public module through which this

include/swift/IRGen/Linking.h

@@ -770,9 +770,10 @@ class LinkEntity {
     return entity;
   }
 
-  static LinkEntity forAnonymousDescriptor(DeclContext *dc) {
+  static LinkEntity forAnonymousDescriptor(
+                                    PointerUnion<DeclContext *, VarDecl *> dc) {
     LinkEntity entity;
-    entity.Pointer = const_cast<void*>(static_cast<const void*>(dc));
+    entity.Pointer = dc.getOpaqueValue();
     entity.SecondaryPointer = nullptr;
     entity.Data =
       LINKENTITY_SET_FIELD(Kind, unsigned(Kind::AnonymousDescriptor));
@@ -1015,9 +1016,10 @@ class LinkEntity {
     return reinterpret_cast<ExtensionDecl*>(Pointer);
   }
 
-  const DeclContext *getDeclContext() const {
+  const PointerUnion<DeclContext *, VarDecl *> getAnonymousDeclContext() const {
     assert(getKind() == Kind::AnonymousDescriptor);
-    return reinterpret_cast<DeclContext*>(Pointer);
+    return PointerUnion<DeclContext *, VarDecl *>
+      ::getFromOpaqueValue(reinterpret_cast<void*>(Pointer));
   }
 
   SILFunction *getSILFunction() const {

include/swift/Remote/MetadataReader.h

@@ -724,6 +724,35 @@ class MetadataReader {
       return nullptr;
     return buildContextMangling(context, Dem);
   }
+  
+  /// Read the mangled underlying type from an opaque type descriptor.
+  BuiltType
+  readUnderlyingTypeForOpaqueTypeDescriptor(StoredPointer contextAddr,
+                                            unsigned ordinal) {
+    auto context = readContextDescriptor(contextAddr);
+    if (!context)
+      return BuiltType();
+    if (context->getKind() != ContextDescriptorKind::OpaqueType)
+      return BuiltType();
+    
+    auto opaqueType =
+      reinterpret_cast<const TargetOpaqueTypeDescriptor<Runtime> *>(
+                                                      context.getLocalBuffer());
+
+    if (ordinal >= opaqueType->getNumUnderlyingTypeArguments())
+      return BuiltType();
+    
+    auto nameAddr = resolveRelativeField(context,
+                     opaqueType->getUnderlyingTypeArgumentMangledName(ordinal));
+    
+    Demangle::Demangler Dem;
+    auto node = readMangledName(RemoteAddress(nameAddr),
+                                MangledNameKind::Type, Dem);
+    if (!node)
+      return BuiltType();
+    
+    return decodeMangledType(node);
+  }
 
   bool isTaggedPointer(StoredPointer objectAddress) {
     if (getTaggedPointerEncoding() != TaggedPointerEncodingKind::Extended)
@@ -1396,6 +1425,12 @@ class MetadataReader {
     case ContextDescriptorKind::Protocol:
       baseSize = sizeof(TargetProtocolDescriptor<Runtime>);
       break;
+    case ContextDescriptorKind::OpaqueType:
+      baseSize = sizeof(TargetOpaqueTypeDescriptor<Runtime>);
+      metadataInitSize =
+        sizeof(typename Runtime::template RelativeDirectPointer<const char>)
+          * flags.getKindSpecificFlags();
+      break;
     default:
       // We don't know about this kind of context.
       return nullptr;
@@ -2076,6 +2111,29 @@ class MetadataReader {
       // contexts; just create the node directly here and return.
       return dem.createNode(nodeKind, std::move(moduleName));
     }
+        
+    case ContextDescriptorKind::OpaqueType: {
+      // The opaque type may have a named anonymous context for us to map
+      // back to its defining decl.
+      if (!parentDescriptorResult)
+        return nullptr;
+      auto anonymous =
+        dyn_cast_or_null<TargetAnonymousContextDescriptor<Runtime>>(
+                                    parentDescriptorResult->getLocalBuffer());
+      if (!anonymous)
+        return nullptr;
+      
+      auto mangledNode =
+                    demangleAnonymousContextName(*parentDescriptorResult, dem);
+      if (!mangledNode)
+        return nullptr;
+      if (mangledNode->getKind() == Node::Kind::Global)
+        mangledNode = mangledNode->getChild(0);
+      
+      auto opaqueNode = dem.createNode(Node::Kind::OpaqueReturnTypeOf);
+      opaqueNode->addChild(mangledNode, dem);
+      return opaqueNode;
+    }
 
     default:
       // Not a kind of context we know about.