Merge remote-tracking branch 'origin/master' into swift-3-api-guidelines

Author: Max Moiseev

include/swift/AST/DiagnosticsCommon.def

@@ -45,6 +45,8 @@ ERROR(not_implemented,none,
 ERROR(error_opening_output,none,
       "error opening '%0' for output: %1", (StringRef, StringRef))
 
+ERROR(error_no_group_info,none,
+      "no group info found for file: '%0'", (StringRef))
 
 NOTE(previous_decldef,none,
      "previous %select{declaration|definition}0 of %1 is here", 

lib/AST/ASTPrinter.cpp

@@ -272,7 +272,6 @@ struct SynthesizedExtensionAnalyzer::Implementation {
     if (Arg.isNull())
       return GenericType;
     Arguments.push_back(Arg);
-
     auto GenericParams = NTD->getInnermostGenericParamTypes();
     assert(Arguments.size() == GenericParams.size());
     TypeSubstitutionMap Map;
@@ -281,7 +280,8 @@ struct SynthesizedExtensionAnalyzer::Implementation {
       Map[(*It)->getCanonicalType()->castTo<SubstitutableType>()] =
         Arguments[Index];
     }
-    return NTD->getDeclaredTypeInContext().subst(DC->getParentModule(), Map, None);
+    auto MType = NTD->getInterfaceType().subst(DC->getParentModule(), Map, None);
+    return MType->getAs<AnyMetatypeType>()->getInstanceType();
   }
 
   SynthesizedExtensionInfo isApplicable(ExtensionDecl *Ext) {

lib/IDE/CodeCompletion.cpp

@@ -3795,6 +3795,9 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
     if (Reason == DeclVisibilityKind::MemberOfCurrentNominal)
       return;
 
+    if (AvailableAttr::isUnavailable(D))
+      return;
+
     if (D->getAttrs().hasAttribute<FinalAttr>())
       return;
 
@@ -3804,7 +3807,7 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
     bool hasIntroducer = hasFuncIntroducer || hasVarIntroducer;
 
     if (auto *FD = dyn_cast<FuncDecl>(D)) {
-      // We can override operators as members.
+      // We cannot override operators as members.
       if (FD->isBinaryOperator() || FD->isUnaryOperator())
         return;
 

lib/IRGen/GenProto.cpp

@@ -2612,19 +2612,19 @@ void irgen::bindGenericRequirement(IRGenFunction &IGF,
                                    GenericRequirement requirement,
                                    llvm::Value *value,
                                    GetTypeParameterInContextFn getInContext) {
-  // Get the corresponding context archetype.
-  auto archetype = cast<ArchetypeType>(getInContext(requirement.TypeParameter));
+  // Get the corresponding context type.
+  auto type = getInContext(requirement.TypeParameter);
 
   if (auto proto = requirement.Protocol) {
+    assert(isa<ArchetypeType>(type));
     assert(value->getType() == IGF.IGM.WitnessTablePtrTy);
-    setProtocolWitnessTableName(IGF.IGM, value, archetype, proto);
+    setProtocolWitnessTableName(IGF.IGM, value, type, proto);
     auto kind = LocalTypeDataKind::forAbstractProtocolWitnessTable(proto);
-    IGF.setUnscopedLocalTypeData(archetype, kind, value);
+    IGF.setUnscopedLocalTypeData(type, kind, value);
   } else {
     assert(value->getType() == IGF.IGM.TypeMetadataPtrTy);
-    setTypeMetadataName(IGF.IGM, value, archetype);
-    auto kind = LocalTypeDataKind::forTypeMetadata();
-    IGF.setUnscopedLocalTypeData(archetype, kind, value);
+    setTypeMetadataName(IGF.IGM, value, type);
+    IGF.bindLocalTypeDataFromTypeMetadata(type, IsExact, value);
   }
 }
 

lib/SILGen/LValue.h

@@ -258,8 +258,9 @@ class LogicalPathComponent : public PathComponent {
   ///
   /// \param base - always an address, but possibly an r-value
   virtual void writeback(SILGenFunction &gen, SILLocation loc,
-                         ManagedValue base, ManagedValue temporary,
-                         ArrayRef<SILValue> otherInfo, bool isFinal);
+                         ManagedValue base,
+                         MaterializedLValue materialized,
+                         bool isFinal);
 };
 
 inline LogicalPathComponent &PathComponent::asLogical() {

lib/SILGen/SILGenApply.cpp

@@ -4378,7 +4378,7 @@ SILGenFunction::getMaterializeForSetDeclRef(AbstractStorageDecl *storage,
                     /*foreign*/ false);
 }
 
-std::pair<SILValue, SILValue> SILGenFunction::
+MaterializedLValue SILGenFunction::
 emitMaterializeForSetAccessor(SILLocation loc, SILDeclRef materializeForSet,
                               ArrayRef<Substitution> substitutions,
                               ArgumentSource &&selfValue,
@@ -4400,6 +4400,7 @@ emitMaterializeForSetAccessor(SILLocation loc, SILDeclRef materializeForSet,
   bool hasCaptures = callee.hasCaptures();
   bool hasSelf = (bool)selfValue;
   CanAnyFunctionType accessType = callee.getSubstFormalType();
+  CanAnyFunctionType origAccessType = callee.getOrigFormalType();
 
   CallEmission emission(*this, std::move(callee), std::move(writebackScope));
   // Self ->
@@ -4440,7 +4441,16 @@ emitMaterializeForSetAccessor(SILLocation loc, SILDeclRef materializeForSet,
   // Project out the optional callback.
   SILValue optionalCallback = results[1].getUnmanagedValue();
 
-  return { address, optionalCallback };
+  CanType origSelfType = origAccessType->getInput()
+      ->getRValueInstanceType()
+      ->getCanonicalType();
+  CanGenericSignature genericSig;
+  if (auto genericFnType = dyn_cast<GenericFunctionType>(origAccessType))
+    genericSig = genericFnType.getGenericSignature();
+
+  return MaterializedLValue(ManagedValue::forUnmanaged(address),
+                            origSelfType, genericSig,
+                            optionalCallback, callbackStorage);
 }
 
 SILDeclRef SILGenFunction::getAddressorDeclRef(AbstractStorageDecl *storage,

lib/SILGen/SILGenFunction.h

@@ -268,6 +268,34 @@ enum class CaptureEmission {
   PartialApplication,
 };
 
+/// Represents an LValue opened for mutating access.
+///
+/// This is used by LogicalPathComponent::getMaterialized() and
+/// SILGenFunction::emitMaterializeForSetAccessor().
+struct MaterializedLValue {
+  ManagedValue temporary;
+
+  // Only set if a callback is required
+  CanType origSelfType;
+  CanGenericSignature genericSig;
+  SILValue callback;
+  SILValue callbackStorage;
+
+  MaterializedLValue() {}
+  explicit MaterializedLValue(ManagedValue temporary)
+    : temporary(temporary) {}
+  MaterializedLValue(ManagedValue temporary,
+                     CanType origSelfType,
+                     CanGenericSignature genericSig,
+                     SILValue callback,
+                     SILValue callbackStorage)
+    : temporary(temporary),
+      origSelfType(origSelfType),
+      genericSig(genericSig),
+      callback(callback),
+      callbackStorage(callbackStorage) {}
+};
+
 /// SILGenFunction - an ASTVisitor for producing SIL from function bodies.
 class LLVM_LIBRARY_VISIBILITY SILGenFunction
   : public ASTVisitor<SILGenFunction>
@@ -1071,7 +1099,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
 
   SILDeclRef getMaterializeForSetDeclRef(AbstractStorageDecl *decl,
                                          bool isDirectAccessorUse);  
-  std::pair<SILValue, SILValue>
+  MaterializedLValue
   emitMaterializeForSetAccessor(SILLocation loc, SILDeclRef materializeForSet,
                                 ArrayRef<Substitution> substitutions,
                                 ArgumentSource &&optionalSelfValue,

lib/SILGen/SILGenLValue.cpp

@@ -45,8 +45,7 @@ struct LLVM_LIBRARY_VISIBILITY LValueWriteback {
   SILLocation loc;
   std::unique_ptr<LogicalPathComponent> component;
   ManagedValue base;
-  ManagedValue temp;
-  SmallVector<SILValue, 2> ExtraInfo;
+  MaterializedLValue materialized;
   CleanupHandle cleanup;
 
   ~LValueWriteback() {}
@@ -56,13 +55,12 @@ struct LLVM_LIBRARY_VISIBILITY LValueWriteback {
   LValueWriteback() = default;
   LValueWriteback(SILLocation loc,
                   std::unique_ptr<LogicalPathComponent> &&comp,
-                  ManagedValue base, ManagedValue temp,
-                  ArrayRef<SILValue> extraInfo,
+                  ManagedValue base,
+                  MaterializedLValue materialized,
                   CleanupHandle cleanup)
-    : loc(loc), component(std::move(comp)), base(base), temp(temp),
-      cleanup(cleanup) {
-    ExtraInfo.append(extraInfo.begin(), extraInfo.end());
-  }
+    : loc(loc), component(std::move(comp)),
+      base(base), materialized(materialized),
+      cleanup(cleanup) { }
 
   void diagnoseConflict(const LValueWriteback &rhs, SILGenFunction &SGF) const {
     // If the two writebacks we're comparing are of different kinds (e.g.
@@ -82,7 +80,7 @@ struct LLVM_LIBRARY_VISIBILITY LValueWriteback {
 
   void performWriteback(SILGenFunction &gen, bool isFinal) {
     Scope S(gen.Cleanups, CleanupLocation::get(loc));
-    component->writeback(gen, loc, base, temp, ExtraInfo, isFinal);
+    component->writeback(gen, loc, base, materialized, isFinal);
   }
 };
 }
@@ -116,16 +114,16 @@ void SILGenFunction::freeWritebackStack() {
 static void pushWriteback(SILGenFunction &gen,
                           SILLocation loc,
                           std::unique_ptr<LogicalPathComponent> &&comp,
-                          ManagedValue base, ManagedValue temp,
-                          ArrayRef<SILValue> extraInfo) {
+                          ManagedValue base,
+                          MaterializedLValue materialized) {
   assert(gen.InWritebackScope);
 
   // Push a cleanup to execute the writeback consistently.
   auto &stack = gen.getWritebackStack();
   gen.Cleanups.pushCleanup<LValueWritebackCleanup>(stack.size());
   auto cleanup = gen.Cleanups.getTopCleanup();
 
-  stack.emplace_back(loc, std::move(comp), base, temp, extraInfo, cleanup);
+  stack.emplace_back(loc, std::move(comp), base, materialized, cleanup);
 }
 
 //===----------------------------------------------------------------------===//
@@ -244,18 +242,23 @@ ManagedValue LogicalPathComponent::getMaterialized(SILGenFunction &gen,
                                                 std::move(*this));
 
   // Push a writeback for the temporary.
-  pushWriteback(gen, loc, std::move(clonedComponent), base, temporary, {});
+  pushWriteback(gen, loc, std::move(clonedComponent), base,
+                MaterializedLValue(temporary));
   return temporary.borrow();
 }
 
 void LogicalPathComponent::writeback(SILGenFunction &gen, SILLocation loc,
-                                     ManagedValue base, ManagedValue temporary,
-                                     ArrayRef<SILValue> otherInfo, bool isFinal) {
-  assert(otherInfo.empty() && "unexpected otherInfo parameter!");
+                                     ManagedValue base,
+                                     MaterializedLValue materialized,
+                                     bool isFinal) {
+  assert(!materialized.callback &&
+         "unexpected materialized lvalue with callback!");
 
   // Load the value from the temporary unless the type is address-only
   // and this is the final use, in which case we can just consume the
   // value as-is.
+  auto temporary = materialized.temporary;
+
   assert(temporary.getType().isAddress());
   auto &tempTL = gen.getTypeLowering(temporary.getType());
   if (!tempTL.isAddressOnly() || !isFinal) {
@@ -859,52 +862,44 @@ namespace {
 
       auto args = std::move(*this).prepareAccessorArgs(gen, loc, borrowedBase,
                                                        materializeForSet);
-      auto addressAndCallback =
+      MaterializedLValue materialized =
         gen.emitMaterializeForSetAccessor(loc, materializeForSet, substitutions,
                                           std::move(args.base), IsSuper,
                                           IsDirectAccessorUse,
                                           std::move(args.subscripts),
                                           buffer, callbackStorage);
 
-      SILValue address = addressAndCallback.first;
-
       // Mark a value-dependence on the base.  We do this regardless
       // of whether the base is trivial because even a trivial base
       // may be value-dependent on something non-trivial.
       if (base) {
-        address = gen.B.createMarkDependence(loc, address, base.getValue());
+        SILValue temporary = materialized.temporary.getValue();
+        materialized.temporary = ManagedValue::forUnmanaged(
+            gen.B.createMarkDependence(loc, temporary, base.getValue()));
       }
 
-      SILValue extraInfo[] = {
-        addressAndCallback.second,
-        callbackStorage,
-      };
-
       // TODO: maybe needsWriteback should be a thin function pointer
       // to which we pass the base?  That would let us use direct
       // access for stored properties with didSet.
-      pushWriteback(gen, loc, std::move(clonedComponent), base,
-                    ManagedValue::forUnmanaged(address), extraInfo);
+      pushWriteback(gen, loc, std::move(clonedComponent), base, materialized);
 
-      return ManagedValue::forLValue(address);
+      return ManagedValue::forLValue(materialized.temporary.getValue());
     }
 
     void writeback(SILGenFunction &gen, SILLocation loc,
-                   ManagedValue base, ManagedValue temporary,
-                   ArrayRef<SILValue> extraInfo, bool isFinal) override {
-      // If we don't have extraInfo, we don't have to conditionalize
+                   ManagedValue base, MaterializedLValue materialized,
+                   bool isFinal) override {
+      // If we don't have a callback, we don't have to conditionalize
       // the writeback.
-      if (extraInfo.empty()) {
-        LogicalPathComponent::writeback(gen, loc, base, temporary, extraInfo,
+      if (!materialized.callback) {
+        LogicalPathComponent::writeback(gen, loc,
+                                        base, materialized,
                                         isFinal);
         return;
       }
 
-      // Otherwise, extraInfo holds an optional callback and the
+      // Otherwise, 'materialized' holds an optional callback and the
       // callback storage.
-      assert(extraInfo.size() == 2);
-      SILValue optionalCallback = extraInfo[0];
-      SILValue callbackStorage = extraInfo[1];
 
       // Mark the writeback as auto-generated so that we don't get
       // warnings if we manage to devirtualize materializeForSet.
@@ -914,7 +909,7 @@ namespace {
 
       SILBasicBlock *contBB = gen.createBasicBlock();
       SILBasicBlock *writebackBB = gen.createBasicBlock(gen.B.getInsertionBB());
-      gen.B.createSwitchEnum(loc, optionalCallback, /*defaultDest*/ nullptr,
+      gen.B.createSwitchEnum(loc, materialized.callback, /*defaultDest*/ nullptr,
                              { { ctx.getOptionalSomeDecl(), writebackBB },
                                { ctx.getOptionalNoneDecl(), contBB } });
 
@@ -926,8 +921,8 @@ namespace {
           SILType::getPrimitiveObjectType(TupleType::getEmpty(ctx));
 
         SILType callbackSILType = gen.getLoweredType(
-                  optionalCallback->getType().getSwiftRValueType()
-                                            .getAnyOptionalObjectType());
+                  materialized.callback->getType().getSwiftRValueType()
+                                                  .getAnyOptionalObjectType());
 
         // The callback is a BB argument from the switch_enum.
         SILValue callback =
@@ -959,12 +954,14 @@ namespace {
         }
 
         SILValue temporaryPointer =
-          gen.B.createAddressToPointer(loc, temporary.getValue(),
+          gen.B.createAddressToPointer(loc,
+                                       materialized.temporary.getValue(),
                                        SILType::getRawPointerType(ctx));
 
+        // Apply the callback.
         gen.B.createApply(loc, callback, {
                             temporaryPointer,
-                            callbackStorage,
+                            materialized.callbackStorage,
                             baseAddress,
                             baseMetatype
                           }, false);
@@ -1119,8 +1116,9 @@ namespace {
     }
 
     void writeback(SILGenFunction &gen, SILLocation loc,
-                   ManagedValue base, ManagedValue temporary,
-                   ArrayRef<SILValue> otherInfo, bool isFinal) override {
+                   ManagedValue base,
+                   MaterializedLValue materialized,
+                   bool isFinal) override {
       // If this is final, we can consume the owner (stored as
       // 'base').  If it isn't, we actually need to retain it, because
       // we've still got a release active.
@@ -1194,7 +1192,7 @@ namespace {
         std::unique_ptr<LogicalPathComponent>
           component(new UnpinPseudoComponent(getTypeData()));
         pushWriteback(gen, loc, std::move(component), result.second,
-                      ManagedValue(), {});
+                      MaterializedLValue());
         return result.first;
       }
       }