Merge branch 'master' into uniterator

Author: milseman

CHANGELOG.md

@@ -7259,6 +7259,7 @@ Swift 1.0
 [SE-0224]: <https://github.com/apple/swift-evolution/blob/master/proposals/0224-ifswift-lessthan-operator.md>
 [SE-0225]: <https://github.com/apple/swift-evolution/blob/master/proposals/0225-binaryinteger-iseven-isodd-ismultiple.md>
 [SE-0226]: <https://github.com/apple/swift-evolution/blob/master/proposals/0226-package-manager-target-based-dep-resolution.md>
+[SE-0227]: <https://github.com/apple/swift-evolution/blob/master/proposals/0227-identity-keypath.md>
 
 [SR-106]: <https://bugs.swift.org/browse/SR-106>
 [SR-419]: <https://bugs.swift.org/browse/SR-419>

include/swift/AST/ASTMangler.h

@@ -33,13 +33,12 @@ class ASTMangler : public Mangler {
 protected:
   CanGenericSignature CurGenericSignature;
   ModuleDecl *Mod = nullptr;
-  const DeclContext *DeclCtx = nullptr;
-  GenericEnvironment *GenericEnv = nullptr;
 
   /// Optimize out protocol names if a type only conforms to one protocol.
   bool OptimizeProtocolNames = true;
 
-  /// If enabled, Arche- and Alias types are mangled with context.
+  /// If enabled, non-canonical types are allowed and type alias types get a
+  /// special mangling.
   bool DWARFMangling;
 
   /// If enabled, entities that ought to have names but don't get a placeholder.
@@ -148,8 +147,7 @@ class ASTMangler : public Mangler {
   std::string mangleKeyPathHashHelper(ArrayRef<CanType> indices,
                                       GenericSignature *signature);
 
-  std::string mangleTypeForDebugger(Type decl, const DeclContext *DC,
-                                    GenericEnvironment *GE);
+  std::string mangleTypeForDebugger(Type decl, const DeclContext *DC);
 
   std::string mangleDeclType(const ValueDecl *decl);
 
@@ -269,8 +267,7 @@ class ASTMangler : public Mangler {
   void appendClosureEntity(const AbstractClosureExpr *closure);
 
   void appendClosureComponents(Type Ty, unsigned discriminator, bool isImplicit,
-                               const DeclContext *parentContext,
-                               const DeclContext *localContext);
+                               const DeclContext *parentContext);
 
   void appendDefaultArgumentEntity(const DeclContext *ctx, unsigned index);
 

include/swift/Serialization/DeclTypeRecordNodes.def

@@ -159,10 +159,10 @@ OTHER(DEFAULT_ARGUMENT_INITIALIZER_CONTEXT, 222)
 OTHER(TOP_LEVEL_CODE_DECL_CONTEXT, 223)
 
 OTHER(GENERIC_PARAM_LIST, 230)
-TRAILING_INFO(GENERIC_PARAM)
+OTHER(GENERIC_SIGNATURE, 231)
 TRAILING_INFO(GENERIC_REQUIREMENT)
 TRAILING_INFO(LAYOUT_REQUIREMENT)
-OTHER(GENERIC_SIGNATURE, 234)
+// 234 is unused
 OTHER(SIL_GENERIC_ENVIRONMENT, 235)
 OTHER(SUBSTITUTION_MAP, 236)
 

include/swift/Serialization/ModuleFormat.h

@@ -52,7 +52,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 463; // Last change: enable-private-imports
+const uint16_t SWIFTMODULE_VERSION_MINOR = 464; // Last change: simplify GenericParamLists
 
 using DeclIDField = BCFixed<31>;
 
@@ -1259,13 +1259,8 @@ namespace decls_block {
   >;
 
   using GenericParamListLayout = BCRecordLayout<
-    GENERIC_PARAM_LIST
-    // The actual parameters and requirements trail the record.
-  >;
-
-  using GenericParamLayout = BCRecordLayout<
-    GENERIC_PARAM,
-    DeclIDField // Typealias
+    GENERIC_PARAM_LIST,
+    BCArray<DeclIDField>        // the GenericTypeParamDecls
   >;
 
   using GenericSignatureLayout = BCRecordLayout<

lib/AST/ASTMangler.cpp

@@ -18,7 +18,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/ExistentialLayout.h"
-#include "swift/AST/GenericEnvironment.h"
+#include "swift/AST/GenericSignature.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/Ownership.h"
@@ -378,18 +378,15 @@ std::string ASTMangler::mangleReabstractionThunkHelper(
   return finalize();
 }
 
-std::string ASTMangler::mangleTypeForDebugger(Type Ty, const DeclContext *DC,
-                                              GenericEnvironment *GE) {
+std::string ASTMangler::mangleTypeForDebugger(Type Ty, const DeclContext *DC) {
   PrettyStackTraceType prettyStackTrace(Ty->getASTContext(),
                                         "mangling type for debugger", Ty);
 
-  GenericEnv = GE;
   DWARFMangling = true;
   beginMangling();
 
   if (DC)
     bindGenericParameters(DC);
-  DeclCtx = DC;
 
   if (auto *fnType = Ty->getAs<AnyFunctionType>()) {
     appendFunction(fnType, false);
@@ -682,20 +679,10 @@ static bool shouldMangleAsGeneric(Type type) {
   if (!type)
     return false;
 
-  TypeBase *typePtr = type.getPointer();
-  if (auto typeAlias = dyn_cast<NameAliasType>(typePtr))
+  if (auto typeAlias = dyn_cast<NameAliasType>(type.getPointer()))
     return !typeAlias->getSubstitutionMap().empty();
 
-  if (auto bound = dyn_cast<BoundGenericType>(typePtr))
-    return true;
-
-  if (auto nominal = dyn_cast<NominalType>(typePtr))
-    return shouldMangleAsGeneric(nominal->getParent());
-
-  if (auto unbound = dyn_cast<UnboundGenericType>(typePtr))
-    return shouldMangleAsGeneric(unbound->getParent());
-
-  return false;
+  return type->isSpecialized();
 }
 
 /// Mangle a type into the buffer.
@@ -1113,15 +1100,15 @@ void ASTMangler::appendBoundGenericArgs(Type type, bool &isFirstArgList) {
 
   if (auto *unboundType = dyn_cast<UnboundGenericType>(typePtr)) {
     if (Type parent = unboundType->getParent())
-      appendBoundGenericArgs(parent, isFirstArgList);
+      appendBoundGenericArgs(parent->getDesugaredType(), isFirstArgList);
   } else if (auto *nominalType = dyn_cast<NominalType>(typePtr)) {
     if (Type parent = nominalType->getParent())
-      appendBoundGenericArgs(parent, isFirstArgList);
+      appendBoundGenericArgs(parent->getDesugaredType(), isFirstArgList);
   } else {
     auto boundType = cast<BoundGenericType>(typePtr);
     genericArgs = boundType->getGenericArgs();
     if (Type parent = boundType->getParent())
-      appendBoundGenericArgs(parent, isFirstArgList);
+      appendBoundGenericArgs(parent->getDesugaredType(), isFirstArgList);
   }
   if (isFirstArgList) {
     appendOperator("y");
@@ -2060,29 +2047,24 @@ void ASTMangler::appendAssociatedTypeName(DependentMemberType *dmt) {
 void ASTMangler::appendClosureEntity(
                               const SerializedAbstractClosureExpr *closure) {
   appendClosureComponents(closure->getType(), closure->getDiscriminator(),
-                          closure->isImplicit(), closure->getParent(),
-                          closure->getLocalContext());
+                          closure->isImplicit(), closure->getParent());
 }
 
 void ASTMangler::appendClosureEntity(const AbstractClosureExpr *closure) {
   appendClosureComponents(closure->getType(), closure->getDiscriminator(),
-                          isa<AutoClosureExpr>(closure), closure->getParent(),
-                          closure->getLocalContext());
+                          isa<AutoClosureExpr>(closure), closure->getParent());
 }
 
 void ASTMangler::appendClosureComponents(Type Ty, unsigned discriminator,
-                                      bool isImplicit,
-                                      const DeclContext *parentContext,
-                                      const DeclContext *localContext) {
-  if (!DeclCtx) DeclCtx = localContext;
-
+                                         bool isImplicit,
+                                         const DeclContext *parentContext) {
   assert(discriminator != AbstractClosureExpr::InvalidDiscriminator
          && "closure must be marked correctly with discriminator");
 
   appendContext(parentContext);
 
   if (!Ty)
-    Ty = ErrorType::get(localContext->getASTContext());
+    Ty = ErrorType::get(parentContext->getASTContext());
 
   Ty = Ty->mapTypeOutOfContext();
   appendType(Ty->getCanonicalType());
@@ -2226,7 +2208,6 @@ void ASTMangler::appendAccessorEntity(StringRef accessorKindCode,
 
 void ASTMangler::appendEntity(const ValueDecl *decl, StringRef EntityOp,
                               bool isStatic) {
-  if (!DeclCtx) DeclCtx = decl->getInnermostDeclContext();
   appendContextOf(decl);
   appendDeclName(decl);
   appendDeclType(decl);
@@ -2236,7 +2217,6 @@ void ASTMangler::appendEntity(const ValueDecl *decl, StringRef EntityOp,
 }
 
 void ASTMangler::appendEntity(const ValueDecl *decl) {
-  if (!DeclCtx) DeclCtx = decl->getInnermostDeclContext();
   assert(!isa<ConstructorDecl>(decl));
   assert(!isa<DestructorDecl>(decl));
 

lib/AST/Decl.cpp

@@ -1781,18 +1781,18 @@ bool AbstractStorageDecl::isFormallyResilient() const {
   if (getAttrs().hasAttribute<FixedLayoutAttr>())
     return false;
 
-  // Private and (unversioned) internal variables always have a
-  // fixed layout.
-  if (!getFormalAccessScope(/*useDC=*/nullptr,
-                            /*treatUsableFromInlineAsPublic=*/true).isPublic())
-    return false;
-
   // If we're an instance property of a nominal type, query the type.
   auto *dc = getDeclContext();
   if (!isStatic())
     if (auto *nominalDecl = dc->getSelfNominalTypeDecl())
       return nominalDecl->isResilient();
 
+  // Non-public global and static variables always have a
+  // fixed layout.
+  if (!getFormalAccessScope(/*useDC=*/nullptr,
+                            /*treatUsableFromInlineAsPublic=*/true).isPublic())
+    return false;
+
   return true;
 }
 

lib/AST/USRGeneration.cpp

@@ -35,7 +35,7 @@ static inline StringRef getUSRSpacePrefix() {
 bool ide::printTypeUSR(Type Ty, raw_ostream &OS) {
   assert(!Ty->hasArchetype() && "cannot have contextless archetypes mangled.");
   Mangle::ASTMangler Mangler;
-  OS << Mangler.mangleTypeForDebugger(Ty->getRValueType(), nullptr, nullptr);
+  OS << Mangler.mangleTypeForDebugger(Ty->getRValueType(), nullptr);
   return false;
 }
 

lib/IRGen/GenDecl.cpp

@@ -2428,9 +2428,11 @@ IRGenModule::getAddrOfLLVMVariableOrGOTEquivalent(LinkEntity entity,
   // Handle SILFunctions specially, because unlike other entities they aren't
   // variables and aren't kept in the GlobalVars table.
   if (entity.isSILFunction()) {
-    auto fn = getAddrOfSILFunction(entity.getSILFunction(), NotForDefinition);
-    if (entity.getSILFunction()->isDefinition()
-        && !isAvailableExternally(entity.getSILFunction()->getLinkage())) {
+    auto *silFn = entity.getSILFunction();
+    auto fn = getAddrOfSILFunction(silFn, NotForDefinition);
+    if (silFn->isDefinition() &&
+        !isAvailableExternally(silFn->getLinkage()) &&
+        this == IRGen.getGenModule(silFn)) {
       return {fn, ConstantReference::Direct};
     }
 

lib/IRGen/GenKeyPath.cpp

@@ -120,8 +120,8 @@ getAccessorForComputedComponent(IRGenModule &IGM,
   // If it's only externally available, we need a local thunk to relative-
   // reference.
   if (requirements.empty() &&
-      !LinkEntity::forSILFunction(accessor, false).isAvailableExternally(IGM)) {
-
+      !isAvailableExternally(accessor->getLinkage()) &&
+      &IGM == IGM.IRGen.getGenModule(accessor)) {
     return IGM.getAddrOfSILFunction(accessor, NotForDefinition);
   }
   auto accessorFn = IGM.getAddrOfSILFunction(accessor, NotForDefinition);
@@ -1030,33 +1030,23 @@ emitKeyPathComponent(IRGenModule &IGM,
       fields.add(llvm::ConstantExpr::getTruncOrBitCast(idValue, IGM.Int32Ty));
       break;
     }
-    
-    if (isInstantiableOnce) {
-      // No generic arguments or indexes, so we can invoke the
-      // getter/setter as is.
+
+    // Push the accessors, possibly thunked to marshal generic environment.
+    fields.addRelativeAddress(
+      getAccessorForComputedComponent(IGM, component, Getter,
+                                      genericEnv, requirements,
+                                      hasSubscriptIndices));
+    if (settable)
       fields.addRelativeAddress(
-        IGM.getAddrOfSILFunction(component.getComputedPropertyGetter(),
-                                 NotForDefinition));
-      if (settable)
-        fields.addRelativeAddress(
-          IGM.getAddrOfSILFunction(component.getComputedPropertySetter(),
-                                   NotForDefinition));
-    } else {
+        getAccessorForComputedComponent(IGM, component, Setter,
+                                        genericEnv, requirements,
+                                        hasSubscriptIndices));
+
+    if (!isInstantiableOnce) {
       // If there's generic context or subscript indexes, embed as
       // arguments in the component. Thunk the SIL-level accessors to give the
       // runtime implementation a polymorphically-callable interface.
-      
-      // Push the accessors, possibly thunked to marshal generic environment.
-      fields.addRelativeAddress(
-        getAccessorForComputedComponent(IGM, component, Getter,
-                                        genericEnv, requirements,
-                                        hasSubscriptIndices));
-      if (settable)
-        fields.addRelativeAddress(
-          getAccessorForComputedComponent(IGM, component, Setter,
-                                          genericEnv, requirements,
-                                          hasSubscriptIndices));
-      
+
       fields.addRelativeAddress(
         getLayoutFunctionForComputedComponent(IGM, component,
                                               genericEnv, requirements));

lib/IRGen/IRGenDebugInfo.cpp

@@ -651,7 +651,7 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
 
     Mangle::ASTMangler Mangler;
     std::string Name = Mangler.mangleTypeForDebugger(
-        Ty, DbgTy.getDeclContext(), DbgTy.getGenericEnvironment());
+        Ty, DbgTy.getDeclContext());
     return BumpAllocatedString(Name);
   }