Merge pull request swiftlang#21786 from slavapestov/dynamic-self-is-so-broken

slavapestov · web-flow · commit 2c2f8a3574e2 · 2019-01-11T17:15:55.000-05:00
Some fixes for DynamicSelfType
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -4047,9 +4047,15 @@ void SILBoxType::Profile(llvm::FoldingSetNodeID &id, SILLayout *Layout,
   Substitutions.profile(id);
 }
 
-static RecursiveTypeProperties getRecursivePropertiesOfMap(
-                                                      SubstitutionMap subMap) {
+static RecursiveTypeProperties getBoxRecursiveProperties(
+    SILLayout *Layout, SubstitutionMap subMap) {
   RecursiveTypeProperties props;
+  for (auto &field : Layout->getFields()) {
+    auto fieldProps = field.getLoweredType()->getRecursiveProperties();
+    fieldProps.removeHasTypeParameter();
+    fieldProps.removeHasDependentMember();
+    props |= fieldProps;
+  }
   for (auto replacementType : subMap.getReplacementTypes()) {
     if (replacementType) props |= replacementType->getRecursiveProperties();
   }
@@ -4058,7 +4064,8 @@ static RecursiveTypeProperties getRecursivePropertiesOfMap(
 
 SILBoxType::SILBoxType(ASTContext &C,
                        SILLayout *Layout, SubstitutionMap Substitutions)
-  : TypeBase(TypeKind::SILBox, &C, getRecursivePropertiesOfMap(Substitutions)),
+  : TypeBase(TypeKind::SILBox, &C,
+             getBoxRecursiveProperties(Layout, Substitutions)),
     Layout(Layout), Substitutions(Substitutions) {
   assert(Substitutions.isCanonical());
 }
diff --git a/lib/SIL/TypeLowering.cpp b/lib/SIL/TypeLowering.cpp
@@ -1819,7 +1819,7 @@ CanAnyFunctionType TypeConverter::makeConstantInterfaceType(SILDeclRef c) {
 
     FuncDecl *func = cast<FuncDecl>(vd);
     auto funcTy = cast<AnyFunctionType>(
-        func->getInterfaceType()->eraseDynamicSelfType()->getCanonicalType());
+        func->getInterfaceType()->getCanonicalType());
     return getFunctionInterfaceTypeWithCaptures(funcTy, func);
   }
 
@@ -2131,7 +2131,11 @@ TypeConverter::getLoweredLocalCaptures(AnyFunctionRef fn) {
 
           // We're capturing a 'self' value with dynamic 'Self' type;
           // handle it specially.
-          if (captureType->getClassOrBoundGenericClass()) {
+          //
+          // However, only do this if its a 'let'; if the capture is
+          // mutable, we're going to be capturing a box or an address.
+          if (captureType->getClassOrBoundGenericClass() &&
+              capturedVar->isLet()) {
             if (selfCapture)
               selfCapture = selfCapture->mergeFlags(capture);
             else
diff --git a/lib/SILGen/SILGenBridging.cpp b/lib/SILGen/SILGenBridging.cpp
@@ -934,9 +934,11 @@ SILGenFunction::emitBlockToFunc(SILLocation loc,
       loweredFuncTy, loweredFuncTy->getExtInfo().withNoEscape(false),
       loweredFuncTy->getWitnessMethodConformanceOrNone());
 
+  CanType dynamicSelfType;
   auto thunkTy = buildThunkType(loweredBlockTy, loweredFuncTyWithoutNoEscape,
                                 inputSubstType, outputSubstType,
-                                genericEnv, interfaceSubs);
+                                genericEnv, interfaceSubs, dynamicSelfType);
+  assert(!dynamicSelfType && "Not implemented");
 
   auto thunk = SGM.getOrCreateReabstractionThunk(thunkTy,
                                                  loweredBlockTy,
diff --git a/lib/SILGen/SILGenFunction.h b/lib/SILGen/SILGenFunction.h
@@ -1761,6 +1761,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                     CanType &outputSubstType,
                                     GenericEnvironment *&genericEnv,
                                     SubstitutionMap &interfaceSubs,
+                                    CanType &dynamicSelfType,
                                     bool withoutActuallyEscaping=false);
 
   //===--------------------------------------------------------------------===//
diff --git a/lib/SILGen/SILGenPoly.cpp b/lib/SILGen/SILGenPoly.cpp
@@ -466,6 +466,15 @@ ManagedValue Transform::transform(ManagedValue v,
 
   // Subtype conversions:
 
+  // A base class method returning Self can be used in place of a derived
+  // class method returning Self.
+  if (auto outputSelfType = dyn_cast<DynamicSelfType>(outputSubstType)) {
+    if (auto inputSelfType = dyn_cast<DynamicSelfType>(inputSubstType)) {
+      inputSubstType = inputSelfType.getSelfType();
+      outputSubstType = outputSelfType.getSelfType();
+    }
+  }
+
   //  - upcasts for classes
   if (outputSubstType->getClassOrBoundGenericClass() &&
       inputSubstType->getClassOrBoundGenericClass()) {
@@ -482,7 +491,9 @@ ManagedValue Transform::transform(ManagedValue v,
       // Upcast to a superclass.
       return SGF.B.createUpcast(Loc, v, loweredResultTy);
     } else {
-      // Unchecked-downcast to a covariant return type.
+      // FIXME: Should only happen with the DynamicSelfType case above,
+      // except that convenience inits return the static self and not
+      // DynamicSelfType.
       assert(inputSubstType->isExactSuperclassOf(outputSubstType)
              && "should be inheritance relationship between input and output");
       return SGF.B.createUncheckedRefCast(Loc, v, loweredResultTy);
@@ -2806,11 +2817,14 @@ void ResultPlanner::execute(ArrayRef<SILValue> innerDirectResults,
 /// \param inputSubstType Formal AST type of function value being thunked
 /// \param outputOrigType Abstraction pattern of the thunk
 /// \param outputSubstType Formal AST type of the thunk
+/// \param dynamicSelfType If true, the last parameter is a dummy used to pass
+/// DynamicSelfType metadata
 static void buildThunkBody(SILGenFunction &SGF, SILLocation loc,
                            AbstractionPattern inputOrigType,
                            CanAnyFunctionType inputSubstType,
                            AbstractionPattern outputOrigType,
-                           CanAnyFunctionType outputSubstType) {
+                           CanAnyFunctionType outputSubstType,
+                           CanType dynamicSelfType) {
   PrettyStackTraceSILFunction stackTrace("emitting reabstraction thunk in",
                                          &SGF.F);
   auto thunkType = SGF.F.getLoweredFunctionType();
@@ -2820,6 +2834,11 @@ static void buildThunkBody(SILGenFunction &SGF, SILLocation loc,
   SmallVector<ManagedValue, 8> params;
   SGF.collectThunkParams(loc, params);
 
+  // Ignore the self parameter at the SIL level. IRGen will use it to
+  // recover type metadata.
+  if (dynamicSelfType)
+    params.pop_back();
+
   ManagedValue fnValue = params.pop_back_val();
   auto fnType = fnValue.getType().castTo<SILFunctionType>();
   assert(!fnType->isPolymorphic());
@@ -2969,6 +2988,7 @@ CanSILFunctionType SILGenFunction::buildThunkType(
     CanType &outputSubstType,
     GenericEnvironment *&genericEnv,
     SubstitutionMap &interfaceSubs,
+    CanType &dynamicSelfType,
     bool withoutActuallyEscaping) {
   assert(!expectedType->isPolymorphic());
   assert(!sourceType->isPolymorphic());
@@ -3069,6 +3089,18 @@ CanSILFunctionType SILGenFunction::buildThunkType(
                       ? contextConvention
                       : ParameterConvention::Direct_Unowned});
 
+  // If this thunk involves DynamicSelfType in any way, add a capture for it
+  // in case we need to recover metadata.
+  if (sourceType->hasDynamicSelfType() ||
+      expectedType->hasDynamicSelfType()) {
+    dynamicSelfType = F.getSelfMetadataArgument()->getType().getASTType();
+    if (!isa<MetatypeType>(dynamicSelfType)) {
+      dynamicSelfType = CanMetatypeType::get(dynamicSelfType,
+                                             MetatypeRepresentation::Thick);
+    }
+    params.push_back({dynamicSelfType, ParameterConvention::Direct_Unowned});
+  }
+
   // Map the parameter and expected types out of context to get the interface
   // type of the thunk.
   SmallVector<SILParameterInfo, 4> interfaceParams;
@@ -3136,11 +3168,13 @@ static ManagedValue createThunk(SILGenFunction &SGF,
   GenericEnvironment *genericEnv = nullptr;
   auto toType = expectedType->getWithExtInfo(
       expectedType->getExtInfo().withNoEscape(false));
+  CanType dynamicSelfType;
   auto thunkType = SGF.buildThunkType(sourceType, toType,
                                       inputSubstType,
                                       outputSubstType,
                                       genericEnv,
-                                      interfaceSubs);
+                                      interfaceSubs,
+                                      dynamicSelfType);
   auto thunk = SGF.SGM.getOrCreateReabstractionThunk(
                                        thunkType,
                                        sourceType,
@@ -3156,7 +3190,8 @@ static ManagedValue createThunk(SILGenFunction &SGF,
                    inputOrigType,
                    inputSubstType,
                    outputOrigType,
-                   outputSubstType);
+                   outputSubstType,
+                   dynamicSelfType);
   }
 
   CanSILFunctionType substFnType = thunkType;
@@ -3168,10 +3203,18 @@ static ManagedValue createThunk(SILGenFunction &SGF,
 
   // Create it in our current function.
   auto thunkValue = SGF.B.createFunctionRefFor(loc, thunk);
+  SmallVector<ManagedValue, 2> thunkArgs;
+  thunkArgs.push_back(fn.ensurePlusOne(SGF, loc));
+  if (dynamicSelfType) {
+    SILType dynamicSILType = SGF.getLoweredType(dynamicSelfType);
+    SILValue value = SGF.B.createMetatype(loc, dynamicSILType);
+    thunkArgs.push_back(ManagedValue::forUnmanaged(value));
+  }
+
   ManagedValue thunkedFn =
     SGF.B.createPartialApply(loc, thunkValue,
                              SILType::getPrimitiveObjectType(substFnType),
-                             interfaceSubs, fn.ensurePlusOne(SGF, loc),
+                             interfaceSubs, thunkArgs,
                              SILType::getPrimitiveObjectType(toType));
 
   if (!expectedType->isNoEscape()) {
@@ -3193,10 +3236,14 @@ static CanSILFunctionType buildWithoutActuallyEscapingThunkType(
          noEscapingType->getExtInfo().withNoEscape(false));
 
   CanType inputSubstType, outputSubstType;
-  return SGF.buildThunkType(noEscapingType, escapingType,
-                            inputSubstType, outputSubstType,
-                            genericEnv, interfaceSubs,
-                            /*withoutActuallyEscaping=*/true);
+  CanType dynamicSelfType;
+  auto type = SGF.buildThunkType(noEscapingType, escapingType,
+                                 inputSubstType, outputSubstType,
+                                 genericEnv, interfaceSubs,
+                                 dynamicSelfType,
+                                 /*withoutActuallyEscaping=*/true);
+  assert(!dynamicSelfType && "not implemented");
+  return type;
 }
 
 static void buildWithoutActuallyEscapingThunkBody(SILGenFunction &SGF) {
@@ -3973,8 +4020,11 @@ SILGenFunction::emitCanonicalFunctionThunk(SILLocation loc, ManagedValue fn,
   // type
   CanType inputSubstType;
   CanType outputSubstType;
+  CanType dynamicSelfType;
   auto thunkTy = buildThunkType(nonCanonicalTy, canonicalTy, inputSubstType,
-                                outputSubstType, genericEnv, interfaceSubs);
+                                outputSubstType, genericEnv, interfaceSubs,
+                                dynamicSelfType);
+  assert(!dynamicSelfType && "not implemented");
   auto thunk = SGM.getOrCreateReabstractionThunk(thunkTy, nonCanonicalTy,
                                                  canonicalTy, F.isSerialized());
   if (thunk->empty()) {
diff --git a/lib/SILGen/SILGenProlog.cpp b/lib/SILGen/SILGenProlog.cpp
@@ -103,15 +103,22 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
     // Pop the next parameter info.
     auto parameterInfo = parameters.front();
     parameters = parameters.slice(1);
-    assert(
-        argType
-            == parent->getParent()->mapTypeIntoContext(
-                   SGF.getSILType(parameterInfo))
-        && "argument does not have same type as specified by parameter info");
-    (void)parameterInfo;
 
+    auto paramType = SGF.F.mapTypeIntoContext(SGF.getSILType(parameterInfo));
     ManagedValue mv = SGF.B.createInputFunctionArgument(
-        argType, loc.getAsASTNode<ValueDecl>());
+        paramType, loc.getAsASTNode<ValueDecl>());
+
+    if (argType != paramType) {
+      // This is a hack to deal with the fact that Self.Type comes in as a
+      // static metatype, but we have to downcast it to a dynamic Self
+      // metatype to get the right semantics.
+      assert(
+        cast<DynamicSelfType>(
+          argType.castTo<MetatypeType>().getInstanceType())
+            .getSelfType()
+          == paramType.castTo<MetatypeType>().getInstanceType());
+      mv = SGF.B.createUncheckedBitCast(loc, mv, argType);
+    }
 
     if (isInOut)
       return mv;
@@ -216,7 +223,7 @@ struct ArgumentInitHelper {
     assert(ty && "no type?!");
 
     // Create an RValue by emitting destructured arguments into a basic block.
-    CanType canTy = ty->eraseDynamicSelfType()->getCanonicalType();
+    CanType canTy = ty->getCanonicalType();
     EmitBBArguments argEmitter(SGF, parent, l, parameters);
 
     // Note: inouts of tuples are not exploded, so we bypass visit().
@@ -235,17 +242,6 @@ struct ArgumentInitHelper {
 
     if (vd->isInOut()) {
       assert(argrv.getType().isAddress() && "expected inout to be address");
-    } else if (auto *metatypeTy = ty->getAs<MetatypeType>()) {
-      // This is a hack to deal with the fact that Self.Type comes in as a
-      // static metatype, but we have to downcast it to a dynamic Self
-      // metatype to get the right semantics.
-      if (metatypeTy->getInstanceType()->is<DynamicSelfType>()) {
-        auto loweredTy = SGF.getLoweredType(ty);
-        if (loweredTy != argrv.getType()) {
-          argrv = ManagedValue::forUnmanaged(
-            SGF.B.createUncheckedBitCast(loc, argrv.getValue(), loweredTy));
-        }
-      }
     } else {
       assert(vd->isImmutable() && "expected parameter to be immutable!");
       // If the variable is immutable, we can bind the value as is.
@@ -320,10 +316,7 @@ static void makeArgument(Type ty, ParamDecl *decl,
 
 void SILGenFunction::bindParameterForForwarding(ParamDecl *param,
                                      SmallVectorImpl<SILValue> &parameters) {
-  Type type = (param->hasType()
-               ? param->getType()
-               : F.mapTypeIntoContext(param->getInterfaceType()));
-  makeArgument(type->eraseDynamicSelfType(), param, parameters, *this);
+  makeArgument(param->getType(), param, parameters, *this);
 }
 
 void SILGenFunction::bindParametersForForwarding(const ParameterList *params,
diff --git a/lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp b/lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp
@@ -834,7 +834,30 @@ void LifetimeChecker::handleLoadForTypeOfSelfUse(const DIMemoryUse &Use) {
         break;
     }
     assert(valueMetatype);
-    auto metatypeArgument = load->getFunction()->getSelfMetadataArgument();
+    SILValue metatypeArgument = load->getFunction()->getSelfMetadataArgument();
+
+    // SILFunction parameter types never have a DynamicSelfType, since it only
+    // makes sense in the context of a given method's body. Since the
+    // value_metatype instruction might produce a DynamicSelfType we have to
+    // cast the metatype argument.
+    //
+    // FIXME: Semantically, we're "opening" the class metatype here to produce
+    // the "opened" DynamicSelfType. Ideally it would be modeled as an opened
+    // archetype associated with the original metatype or class instance value,
+    // instead of as a "global" type.
+    auto metatypeSelfType = metatypeArgument->getType()
+        .castTo<MetatypeType>().getInstanceType();
+    auto valueSelfType = valueMetatype->getType()
+        .castTo<MetatypeType>().getInstanceType();
+    if (metatypeSelfType != valueSelfType) {
+      assert(metatypeSelfType ==
+             cast<DynamicSelfType>(valueSelfType).getSelfType());
+
+      SILBuilderWithScope B(valueMetatype);
+      metatypeArgument = B.createUncheckedTrivialBitCast(
+          valueMetatype->getLoc(), metatypeArgument,
+          valueMetatype->getType());
+    }
     replaceAllSimplifiedUsesAndErase(valueMetatype, metatypeArgument,
                                      [](SILInstruction*) { });
   }
diff --git a/test/SILGen/dynamic_self.swift b/test/SILGen/dynamic_self.swift
diff --git a/test/SILOptimizer/definite_init_type_of_self_in_convenience_init.swift b/test/SILOptimizer/definite_init_type_of_self_in_convenience_init.swift
