---

yaml
---
r: 345134
b: refs/heads/master
c: 89ee9c6
h: refs/heads/master

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 88c19e1a6e834b97006f701bd45d7e33e06dd1f8
+refs/heads/master: 89ee9c6bcff40e1238d6af5b0b6be806ea4db41d
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/cmake/modules/AddSwift.cmake

@@ -1572,6 +1572,13 @@ function(add_swift_library name)
   endif()
 
   if(SWIFTLIB_TARGET_LIBRARY)
+    # In the standard library and overlays, warn about implicit overrides
+    # as a reminder to consider when inherited protocols need different
+    # behavior for their requirements.
+    if (SWIFTLIB_IS_STDLIB)
+      list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-warn-implicit-overrides")
+    endif()
+
     if(NOT SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER AND NOT BUILD_STANDALONE)
       list(APPEND SWIFTLIB_DEPENDS clang)
     endif()

trunk/include/swift/AST/Attr.def

@@ -240,7 +240,7 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(convenience, Convenience,
   DeclModifier |
   NotSerialized, 43)
 CONTEXTUAL_SIMPLE_DECL_ATTR(override, Override,
-  OnFunc | OnAccessor | OnVar | OnSubscript | OnConstructor |
+  OnFunc | OnAccessor | OnVar | OnSubscript | OnConstructor | OnAssociatedType |
   DeclModifier |
   NotSerialized, 44)
 SIMPLE_DECL_ATTR(sil_stored, SILStored,
@@ -375,6 +375,10 @@ SIMPLE_DECL_ATTR(_hasInitialValue, HasInitialValue,
   OnVar |
   UserInaccessible,
   78)
+SIMPLE_DECL_ATTR(_nonoverride, NonOverride,
+  OnFunc | OnAccessor | OnVar | OnSubscript | OnConstructor | OnAssociatedType |
+  UserInaccessible | NotSerialized,
+  79)
 
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS

trunk/include/swift/AST/Decl.h

@@ -6579,7 +6579,8 @@ inline bool Decl::isPotentiallyOverridable() const {
       isa<SubscriptDecl>(this) ||
       isa<FuncDecl>(this) ||
       isa<DestructorDecl>(this)) {
-    return getDeclContext()->getSelfClassDecl();
+    return getDeclContext()->getSelfClassDecl() ||
+           isa<ProtocolDecl>(getDeclContext());
   } else {
     return false;
   }

trunk/include/swift/AST/DiagnosticsSema.def

@@ -2041,6 +2041,9 @@ NOTE(overridden_here_can_be_objc,none,
 
 ERROR(missing_override,none,
       "overriding declaration requires an 'override' keyword", ())
+WARNING(missing_override_warn,none,
+        "implicit override should be marked with 'override' or suppressed "
+        "with '@_nonoverride'", ())
 
 ERROR(multiple_override,none,
       "%0 has already been overridden", (DeclName))
@@ -2104,6 +2107,10 @@ NOTE(override_type_mismatch_with_fixits_init,none,
      (unsigned, Type))
 ERROR(override_nonclass_decl,none,
       "'override' can only be specified on class members", ())
+ERROR(nonoverride_wrong_decl_context,none,
+      "'@_nonoverride' can only be specified on class or protocol members", ())
+ERROR(nonoverride_and_override_attr,none,
+      "'override' cannot be combined with '@_nonoverride'", ())
 ERROR(override_property_type_mismatch,none,
       "property %0 with type %1 cannot override a property with type %2",
       (Identifier, Type, Type))

trunk/include/swift/Basic/LangOptions.h

@@ -248,6 +248,9 @@ namespace swift {
     Swift3ObjCInferenceWarnings WarnSwift3ObjCInference =
       Swift3ObjCInferenceWarnings::None;
 
+    /// Diagnose implicit 'override'.
+    bool WarnImplicitOverrides = false;
+
     /// Diagnose uses of NSCoding with classes that have unstable mangled names.
     bool EnableNSKeyedArchiverDiagnostics = true;
 

trunk/include/swift/Option/Options.td

@@ -359,6 +359,11 @@ def warn_swift3_objc_inference_minimal :
   Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
   HelpText<"Warn about deprecated @objc inference in Swift 3 based on direct uses of the Objective-C entrypoint">;
 
+def warn_implicit_overrides :
+  Flag<["-"], "warn-implicit-overrides">,
+  Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
+  HelpText<"Warn about implicit overrides of protocol members">;
+
 def typo_correction_limit : Separate<["-"], "typo-correction-limit">,
   Flags<[FrontendOption, HelpHidden]>,
   MetaVarName<"<n>">,

trunk/include/swift/SIL/SILDeclRef.h

@@ -334,6 +334,13 @@ struct SILDeclRef {
   /// entry.
   bool requiresNewVTableEntry() const;
 
+  /// True if the decl ref references a method which introduces a new witness
+  /// table entry.
+  bool requiresNewWitnessTableEntry() const;
+
+  /// True if the decl is a method which introduces a new witness table entry.
+  static bool requiresNewWitnessTableEntry(AbstractFunctionDecl *func);
+
   /// Return a SILDeclRef to the declaration overridden by this one, or
   /// a null SILDeclRef if there is no override.
   SILDeclRef getOverridden() const;
@@ -348,6 +355,10 @@ struct SILDeclRef {
   /// dispatched, will return the least derived method.
   SILDeclRef getOverriddenVTableEntry() const;
 
+  /// Return the original protocol requirement that introduced the witness table
+  /// entry overridden by this method.
+  SILDeclRef getOverriddenWitnessTableEntry() const;
+
   /// True if the referenced entity is some kind of thunk.
   bool isThunk() const;
 

trunk/include/swift/SIL/SILWitnessVisitor.h

@@ -128,8 +128,9 @@ template <class T> class SILWitnessVisitor : public ASTVisitor<T> {
       return;
 
     // Visit the witnesses for the direct members of a protocol.
-    for (Decl *member : protocol->getMembers())
+    for (Decl *member : protocol->getMembers()) {
       ASTVisitor<T>::visit(member);
+    }
   }
 
   /// If true, only the base protocols and associated types will be visited.
@@ -145,12 +146,14 @@ template <class T> class SILWitnessVisitor : public ASTVisitor<T> {
 
   void visitAbstractStorageDecl(AbstractStorageDecl *sd) {
     sd->visitOpaqueAccessors([&](AccessorDecl *accessor) {
-      asDerived().addMethod(SILDeclRef(accessor, SILDeclRef::Kind::Func));
+      if (SILDeclRef::requiresNewWitnessTableEntry(accessor))
+        asDerived().addMethod(SILDeclRef(accessor, SILDeclRef::Kind::Func));
     });
   }
 
   void visitConstructorDecl(ConstructorDecl *cd) {
-    asDerived().addMethod(SILDeclRef(cd, SILDeclRef::Kind::Allocator));
+    if (SILDeclRef::requiresNewWitnessTableEntry(cd))
+      asDerived().addMethod(SILDeclRef(cd, SILDeclRef::Kind::Allocator));
   }
 
   void visitAccessorDecl(AccessorDecl *func) {
@@ -159,7 +162,8 @@ template <class T> class SILWitnessVisitor : public ASTVisitor<T> {
 
   void visitFuncDecl(FuncDecl *func) {
     assert(!isa<AccessorDecl>(func));
-    asDerived().addMethod(SILDeclRef(func, SILDeclRef::Kind::Func));
+    if (SILDeclRef::requiresNewWitnessTableEntry(func))
+      asDerived().addMethod(SILDeclRef(func, SILDeclRef::Kind::Func));
   }
 
   void visitMissingMemberDecl(MissingMemberDecl *placeholder) {

trunk/lib/AST/ASTDumper.cpp

@@ -754,9 +754,18 @@ namespace {
           << getAccessLevelSpelling(VD->getFormalAccess());
       }
 
-      if (auto Overridden = VD->getOverriddenDecl()) {
-        PrintWithColorRAII(OS, OverrideColor) << " override=";
-        Overridden->dumpRef(PrintWithColorRAII(OS, OverrideColor).getOS());
+      if (VD->overriddenDeclsComputed()) {
+        auto overridden = VD->getOverriddenDecls();
+        if (!overridden.empty()) {
+          PrintWithColorRAII(OS, OverrideColor) << " override=";
+          interleave(overridden,
+                     [&](ValueDecl *overridden) {
+                       overridden->dumpRef(
+                                PrintWithColorRAII(OS, OverrideColor).getOS());
+                     }, [&]() {
+                       OS << ", ";
+                     });
+        }
       }
 
       if (VD->isFinal())

trunk/lib/AST/ASTVerifier.cpp

@@ -865,9 +865,10 @@ class Verifier : public ASTWalker {
           D->getAttrs().hasAttribute<OverrideAttr>()) {
         if (!D->isInvalid() && D->hasInterfaceType() &&
             !isa<ClassDecl>(D->getDeclContext()) &&
+            !isa<ProtocolDecl>(D->getDeclContext()) &&
             !isa<ExtensionDecl>(D->getDeclContext())) {
           PrettyStackTraceDecl debugStack("verifying override", D);
-          Out << "'override' attribute outside of a class\n";
+          Out << "'override' attribute outside of a class or protocol\n";
           D->dump(Out);
           abort();
         }

trunk/lib/AST/GenericSignatureBuilder.cpp

@@ -4381,9 +4381,12 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
 
       bool shouldWarnAboutRedeclaration =
         source->kind == RequirementSource::RequirementSignatureSelf &&
+        !assocTypeDecl->getAttrs().hasAttribute<NonOverrideAttr>() &&
+        !assocTypeDecl->getAttrs().hasAttribute<OverrideAttr>() &&
         assocTypeDecl->getDefaultDefinitionLoc().isNull() &&
         (!assocTypeDecl->getInherited().empty() ||
-         assocTypeDecl->getTrailingWhereClause());
+         assocTypeDecl->getTrailingWhereClause() ||
+         getASTContext().LangOpts.WarnImplicitOverrides);
       for (auto inheritedType : knownInherited->second) {
         // If we have inherited associated type...
         if (auto inheritedAssocTypeDecl =

trunk/lib/AST/NameLookup.cpp

@@ -85,6 +85,15 @@ bool swift::removeOverriddenDecls(SmallVectorImpl<ValueDecl*> &decls) {
 
   llvm::SmallPtrSet<ValueDecl*, 8> overridden;
   for (auto decl : decls) {
+    // Don't look at the overrides of operators in protocols. The global
+    // lookup of operators means that we can find overriding operators that
+    // aren't relevant to the types in hand, and will fail to type check.
+    if (isa<ProtocolDecl>(decl->getDeclContext())) {
+      if (auto func = dyn_cast<FuncDecl>(decl))
+        if (func->isOperator())
+          continue;
+    }
+
     while (auto overrides = decl->getOverriddenDecl()) {
       overridden.insert(overrides);
 

trunk/lib/AST/ProtocolConformance.cpp

@@ -403,6 +403,37 @@ ProtocolConformanceRef::getConditionalRequirements() const {
     return {};
 }
 
+ProtocolConformanceRef
+ProtocolConformanceRef::getInheritedConformanceRef(ProtocolDecl *base) const {
+  if (isAbstract()) {
+    assert(getRequirement()->inheritsFrom(base));
+    return ProtocolConformanceRef(base);
+  }
+
+  auto concrete = getConcrete();
+  auto proto = concrete->getProtocol();
+  auto path =
+    proto->getGenericSignature()->getConformanceAccessPath(
+                                            proto->getProtocolSelfType(), base);
+  ProtocolConformanceRef result = *this;
+  Type resultType = concrete->getType();
+  bool first = true;
+  for (const auto &step : path) {
+    if (first) {
+      assert(step.first->isEqual(proto->getProtocolSelfType()));
+      assert(step.second == proto);
+      first = false;
+      continue;
+    }
+
+    result =
+        result.getAssociatedConformance(resultType, step.first, step.second);
+    resultType = result.getAssociatedType(resultType, step.first);
+  }
+
+  return result;
+}
+
 void NormalProtocolConformance::differenceAndStoreConditionalRequirements()
     const {
   switch (CRState) {

trunk/lib/AST/SubstitutionMap.cpp

@@ -505,9 +505,23 @@ SubstitutionMap::getProtocolSubstitutions(ProtocolDecl *protocol,
 }
 
 SubstitutionMap
-SubstitutionMap::getOverrideSubstitutions(const ValueDecl *baseDecl,
-                                          const ValueDecl *derivedDecl,
-                                          Optional<SubstitutionMap> derivedSubs) {
+SubstitutionMap::getOverrideSubstitutions(
+                                      const ValueDecl *baseDecl,
+                                      const ValueDecl *derivedDecl,
+                                      Optional<SubstitutionMap> derivedSubs) {
+  // For overrides within a protocol hierarchy, substitute the Self type.
+  if (auto baseProto = baseDecl->getDeclContext()->getSelfProtocolDecl()) {
+    if (auto derivedProtoSelf =
+          derivedDecl->getDeclContext()->getProtocolSelfType()) {
+      return SubstitutionMap::getProtocolSubstitutions(
+                                             baseProto,
+                                             derivedProtoSelf,
+                                             ProtocolConformanceRef(baseProto));
+    }
+
+    return SubstitutionMap();
+  }
+
   auto *baseClass = baseDecl->getDeclContext()->getSelfClassDecl();
   auto *derivedClass = derivedDecl->getDeclContext()->getSelfClassDecl();
 
@@ -541,6 +555,8 @@ SubstitutionMap::getOverrideSubstitutions(const ClassDecl *baseClass,
     if (derivedSubs)
       derivedClassTy = derivedClassTy.subst(*derivedSubs);
     auto baseClassTy = derivedClassTy->getSuperclassForDecl(baseClass);
+    if (baseClassTy->is<ErrorType>())
+      return SubstitutionMap();
 
     baseSubMap = baseClassTy->getContextSubstitutionMap(M, baseClass);
   }

trunk/lib/AST/Type.cpp

@@ -3349,7 +3349,8 @@ Type TypeBase::adjustSuperclassMemberDeclType(const ValueDecl *baseDecl,
 
   auto type = memberType.subst(subs, SubstFlags::UseErrorType);
 
-  if (isa<AbstractFunctionDecl>(baseDecl)) {
+  if (isa<AbstractFunctionDecl>(baseDecl) &&
+      !baseDecl->getDeclContext()->getSelfProtocolDecl()) {
     type = type->replaceSelfParameterType(this);
     if (auto func = dyn_cast<FuncDecl>(baseDecl)) {
       if (func->hasDynamicSelf()) {

trunk/lib/Driver/ToolChains.cpp

@@ -182,6 +182,7 @@ static void addCommonFrontendArgs(const ToolChain &TC, const OutputInfo &OI,
   inputArgs.AddLastArg(arguments,
                        options::OPT_warn_swift3_objc_inference_minimal,
                        options::OPT_warn_swift3_objc_inference_complete);
+  inputArgs.AddLastArg(arguments, options::OPT_warn_implicit_overrides);
   inputArgs.AddLastArg(arguments, options::OPT_typo_correction_limit);
   inputArgs.AddLastArg(arguments, options::OPT_enable_app_extension);
   inputArgs.AddLastArg(arguments, options::OPT_enable_testing);

trunk/lib/Frontend/CompilerInvocation.cpp

@@ -321,6 +321,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     }
   }
 
+  Opts.WarnImplicitOverrides =
+    Args.hasArg(OPT_warn_implicit_overrides);
+
   Opts.EnableNSKeyedArchiverDiagnostics =
       Args.hasFlag(OPT_enable_nskeyedarchiver_diagnostics,
                    OPT_disable_nskeyedarchiver_diagnostics,

trunk/lib/IRGen/GenProto.cpp

@@ -969,7 +969,13 @@ bool irgen::isDependentConformance(const NormalProtocolConformance *conformance)
     return true;
 
   // Check whether any of the inherited conformances are dependent.
-  for (auto inherited : conformance->getProtocol()->getInheritedProtocols()) {
+  auto proto = conformance->getProtocol();
+  for (const auto &req : proto->getRequirementSignature()) {
+    if (req.getKind() != RequirementKind::Conformance ||
+        !req.getFirstType()->isEqual(proto->getProtocolSelfType()))
+      continue;
+
+    auto inherited = req.getSecondType()->castTo<ProtocolType>()->getDecl();
     if (inherited->isObjC())
       continue;
 

trunk/lib/IRGen/IRGenSIL.cpp

@@ -5401,6 +5401,20 @@ void IRGenSILFunction::visitWitnessMethodInst(swift::WitnessMethodInst *i) {
   ProtocolConformanceRef conformance = i->getConformance();
   SILDeclRef member = i->getMember();
 
+  // Find the original entry in the witness table.
+  bool wasOverriding = false;
+  while (auto overridden = member.getOverridden()) {
+    member = overridden;
+    wasOverriding = true;
+  }
+
+  // If the requirement given override another requirement, adjust the
+  // conformance appropriately.
+  if (wasOverriding) {
+    auto memberProto = cast<ProtocolDecl>(member.getDecl()->getDeclContext());
+    conformance = conformance.getInheritedConformanceRef(memberProto);
+  }
+
   if (IGM.isResilient(conformance.getRequirement(),
                       ResilienceExpansion::Maximal)) {
     auto *fnPtr = IGM.getAddrOfDispatchThunk(member, NotForDefinition);