---

yaml
---
r: 348497
b: refs/heads/master
c: a72ef5d
h: refs/heads/master
i:
  348495: 0284823

Author: swift-ci

[refs]

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

trunk/include/swift/AST/DiagnosticsSema.def

@@ -1616,6 +1616,11 @@ ERROR(inferred_opaque_type,none,
 // Extensions
 ERROR(non_nominal_extension,none,
       "non-nominal type %0 cannot be extended", (Type))
+WARNING(composition_in_extended_type,none,
+        "extending a protocol composition is not supported; extending %0 "
+        "instead", (Type))
+NOTE(composition_in_extended_type_alternative,none,
+     "did you mean to extend the most specific type %0 instead?", (Type))
 ERROR(extension_access_with_conformances,none,
       "%0 modifier cannot be used with extensions that declare "
       "protocol conformances", (DeclAttribute))

trunk/lib/AST/NameLookup.cpp

@@ -2123,26 +2123,25 @@ SuperclassDeclRequest::evaluate(Evaluator &evaluator,
 llvm::Expected<NominalTypeDecl *>
 ExtendedNominalRequest::evaluate(Evaluator &evaluator,
                                  ExtensionDecl *ext) const {
-  DirectlyReferencedTypeDecls referenced;
-  ASTContext &ctx = ext->getASTContext();
+  auto typeRepr = ext->getExtendedTypeRepr();
+  if (!typeRepr)
+    // We must've seen 'extension { ... }' during parsing.
+    return nullptr;
 
-  // Prefer syntactic information when we have it.
-  if (auto typeRepr = ext->getExtendedTypeRepr()) {
-    referenced = directReferencesForTypeRepr(evaluator, ctx, typeRepr, ext);
-  } else if (auto type = ext->getExtendedType()) {
-    // Fall back to semantic types.
-    // FIXME: In the long run, we shouldn't need this. Non-syntactic results
-    // should be cached.
-    referenced = directReferencesForType(type);
-  }
+  ASTContext &ctx = ext->getASTContext();
+  DirectlyReferencedTypeDecls referenced =
+    directReferencesForTypeRepr(evaluator, ctx, typeRepr, ext);
 
   // Resolve those type declarations to nominal type declarations.
   SmallVector<ModuleDecl *, 2> modulesFound;
   bool anyObject = false;
   auto nominalTypes
     = resolveTypeDeclsToNominal(evaluator, ctx, referenced, modulesFound,
                                 anyObject);
-  return nominalTypes.empty() ? nullptr : nominalTypes.front();
+
+  // If there is more than 1 element, we will emit a warning or an error
+  // elsewhere, so don't handle that case here.
+  return nominalTypes.empty() ? nullptr : nominalTypes[0];
 }
 
 llvm::Expected<NominalTypeDecl *>

trunk/lib/ClangImporter/ImportDecl.cpp

@@ -30,6 +30,7 @@
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
+#include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/PrettyStackTrace.h"
@@ -4545,10 +4546,10 @@ namespace {
                       Impl.SwiftContext, loc,
                       nullptr,
                       { }, dc, nullptr, decl);
-      Impl.SwiftContext
-          .evaluator
-          .cacheOutput(ExtendedTypeRequest{result},
-                       objcClass->getDeclaredType());
+      Impl.SwiftContext.evaluator.cacheOutput(ExtendedTypeRequest{result},
+                                              objcClass->getDeclaredType());
+      Impl.SwiftContext.evaluator.cacheOutput(ExtendedNominalRequest{result},
+                                              objcClass);
 
       // Determine the type and generic args of the extension.
       if (objcClass->getGenericParams()) {
@@ -8126,6 +8127,8 @@ ClangImporter::Implementation::importDeclContextOf(
                                    getClangModuleForDecl(decl), nullptr);
   SwiftContext.evaluator.cacheOutput(ExtendedTypeRequest{ext},
                                      nominal->getDeclaredType());
+  SwiftContext.evaluator.cacheOutput(ExtendedNominalRequest{ext},
+                                     std::move(nominal));
   ext->setValidationToChecked();
   ext->setMemberLoader(this, reinterpret_cast<uintptr_t>(declSubmodule));
 

trunk/lib/Sema/TypeCheckDecl.cpp

@@ -3057,7 +3057,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     auto nominal = ED->getExtendedNominal();
     if (nominal == nullptr) {
-	  const bool wasAlreadyInvalid = ED->isInvalid();
+      const bool wasAlreadyInvalid = ED->isInvalid();
       ED->setInvalid();
       if (extType && !extType->hasError() && extType->getAnyNominal()) {
         // If we've got here, then we have some kind of extension of a prima
@@ -3075,14 +3075,49 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
           .fixItReplace(ED->getExtendedTypeRepr()->getSourceRange(),
                         canExtType->getString());
       } else if (!wasAlreadyInvalid) {
-		// If nothing else applies, fall back to a generic diagnostic.
+        // If nothing else applies, fall back to a generic diagnostic.
         ED->diagnose(diag::non_nominal_extension, extType);
       }
       return;
     }
 
     TC.validateExtension(ED);
 
+    extType = ED->getExtendedType();
+    if (extType && !extType->hasError()) {
+      // The first condition catches syntactic forms like
+      //     protocol A & B { ... } // may be protocols or typealiases
+      // The second condition also looks through typealiases and catches
+      //    typealias T = P1 & P2 // P2 is a refined protocol of P1
+      //    extension T { ... }
+      // However, it is trickier to catch cases like
+      //    typealias T = P2 & P1 // P2 is a refined protocol of P1
+      //    extension T { ... }
+      // so we don't do that here.
+      auto extTypeRepr = ED->getExtendedTypeRepr();
+      auto *extTypeNominal = extType->getAnyNominal();
+      bool firstNominalIsNotMostSpecific =
+        extTypeNominal && extTypeNominal != nominal;
+      if (isa<CompositionTypeRepr>(extTypeRepr)
+          || firstNominalIsNotMostSpecific) {
+        auto firstNominalType = nominal->getDeclaredType();
+        auto diag = ED->diagnose(diag::composition_in_extended_type,
+                                 firstNominalType);
+        diag.highlight(extTypeRepr->getSourceRange());
+        if (firstNominalIsNotMostSpecific) {
+          diag.flush();
+          Type mostSpecificProtocol = extTypeNominal->getDeclaredType();
+          ED->diagnose(diag::composition_in_extended_type_alternative,
+                       mostSpecificProtocol)
+            .fixItReplace(extTypeRepr->getSourceRange(),
+                          mostSpecificProtocol->getString());
+        } else {
+          diag.fixItReplace(extTypeRepr->getSourceRange(),
+                            firstNominalType->getString());
+        }
+      }
+    }
+
     checkInheritanceClause(ED);
 
     // Check the raw values of an enum, since we might synthesize

trunk/lib/Sema/TypeCheckGeneric.cpp

@@ -15,6 +15,7 @@
 //===----------------------------------------------------------------------===//
 #include "TypeChecker.h"
 #include "TypeCheckType.h"
+#include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericSignatureBuilder.h"

trunk/lib/Serialization/Deserialization.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Initializer.h"
+#include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/PrettyStackTrace.h"
@@ -3688,14 +3689,16 @@ class swift::DeclDeserializer {
 
   Expected<Decl *> deserializeExtension(ArrayRef<uint64_t> scratch,
                                         StringRef blobData) {
-    TypeID baseID;
+    TypeID extendedTypeID;
+    DeclID extendedNominalID;
     DeclContextID contextID;
     bool isImplicit;
     GenericSignatureID genericEnvID;
     unsigned numConformances, numInherited;
     ArrayRef<uint64_t> inheritedAndDependencyIDs;
 
-    decls_block::ExtensionLayout::readRecord(scratch, baseID, contextID,
+    decls_block::ExtensionLayout::readRecord(scratch, extendedTypeID,
+                                             extendedNominalID, contextID,
                                              isImplicit, genericEnvID,
                                              numConformances, numInherited,
                                              inheritedAndDependencyIDs);
@@ -3732,10 +3735,12 @@ class swift::DeclDeserializer {
 
     MF.configureGenericEnvironment(extension, genericEnvID);
 
-    auto baseTy = MF.getType(baseID);
+    auto extendedType = MF.getType(extendedTypeID);
     ctx.evaluator.cacheOutput(ExtendedTypeRequest{extension},
-                              std::move(baseTy));
-    auto nominal = extension->getExtendedNominal();
+                              std::move(extendedType));
+    auto nominal = dyn_cast<NominalTypeDecl>(MF.getDecl(extendedNominalID));
+    ctx.evaluator.cacheOutput(ExtendedNominalRequest{extension},
+                              std::move(nominal));
 
     if (isImplicit)
       extension->setImplicit();

trunk/lib/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 = 517; // better string hash seed
+const uint16_t SWIFTMODULE_VERSION_MINOR = 518; // save extended nominal separately when serializing extensions
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1284,7 +1284,8 @@ namespace decls_block {
 
   using ExtensionLayout = BCRecordLayout<
     EXTENSION_DECL,
-    TypeIDField, // base type
+    TypeIDField, // extended type
+    DeclIDField, // extended nominal
     DeclContextIDField, // context decl
     BCFixed<1>,  // implicit flag
     GenericSignatureIDField,  // generic environment

trunk/lib/Serialization/Serialization.cpp

@@ -2641,8 +2641,8 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
     verifyAttrSerializable(extension);
 
     auto contextID = S.addDeclContextRef(extension->getDeclContext());
-    Type baseTy = extension->getExtendedType();
-    assert(!baseTy->hasArchetype());
+    Type extendedType = extension->getExtendedType();
+    assert(!extendedType->hasArchetype());
 
     // FIXME: Use the canonical type here in order to minimize circularity
     // issues at deserialization time. A known problematic case here is
@@ -2652,12 +2652,7 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
     //
     // We could limit this to only the problematic cases, but it seems like a
     // simpler user model to just always desugar extension types.
-    baseTy = baseTy->getCanonicalType();
-
-    // Make sure the base type has registered itself as a provider of generic
-    // parameters.
-    auto baseNominal = baseTy->getAnyNominal();
-    (void)S.addDeclRef(baseNominal);
+    extendedType = extendedType->getCanonicalType();
 
     auto conformances = extension->getLocalConformances(
                           ConformanceLookupKind::All, nullptr);
@@ -2670,7 +2665,8 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
     size_t numInherited = inheritedAndDependencyTypes.size();
 
     llvm::SmallSetVector<Type, 4> dependencies;
-    collectDependenciesFromType(dependencies, baseTy, /*excluding*/nullptr);
+    collectDependenciesFromType(
+      dependencies, extendedType, /*excluding*/nullptr);
     for (Requirement req : extension->getGenericRequirements()) {
       collectDependenciesFromRequirement(dependencies, req,
                                          /*excluding*/nullptr);
@@ -2679,8 +2675,10 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
       inheritedAndDependencyTypes.push_back(S.addTypeRef(dependencyTy));
 
     unsigned abbrCode = S.DeclTypeAbbrCodes[ExtensionLayout::Code];
+    auto extendedNominal = extension->getExtendedNominal();
     ExtensionLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode,
-                                S.addTypeRef(baseTy),
+                                S.addTypeRef(extendedType),
+                                S.addDeclRef(extendedNominal),
                                 contextID.getOpaqueValue(),
                                 extension->isImplicit(),
                                 S.addGenericEnvironmentRef(
@@ -2690,9 +2688,9 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
                                 inheritedAndDependencyTypes);
 
     bool isClassExtension = false;
-    if (baseNominal) {
-      isClassExtension = isa<ClassDecl>(baseNominal) ||
-                         isa<ProtocolDecl>(baseNominal);
+    if (extendedNominal) {
+      isClassExtension = isa<ClassDecl>(extendedNominal) ||
+                         isa<ProtocolDecl>(extendedNominal);
     }
 
     // Extensions of nested generic types have multiple generic parameter

trunk/test/Sema/Inputs/composition_extensions_usage.swift renamed to trunk/test/Sema/Inputs/composition_extension_usage.swift

@@ -0,0 +1,46 @@
+// RUN: %target-typecheck-verify-swift
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -primary-file %s %S/Inputs/composition_extension_usage.swift -emit-module-path %t/P-partial.swiftmodule -module-name SR11227 -enable-testing
+// RUN: %target-swift-frontend -primary-file %S/Inputs/composition_extension_usage.swift %s -emit-module-path %t/S-partial.swiftmodule -module-name SR11227 -enable-testing
+// RUN: %target-swift-frontend -sil-merge-partial-modules %t/P-partial.swiftmodule %t/S-partial.swiftmodule -emit-module -o %t/SR11227.swiftmodule
+
+protocol P1 {}
+
+protocol P1_1 : P1 {
+  func p1_1()
+}
+
+protocol P2 {}
+
+extension P1 & P1_1 where Self : P2 {
+  // expected-warning@-1 {{extending a protocol composition is not supported; extending 'P1' instead}}
+  // expected-note@-2 {{did you mean to extend the most specific type 'P1_1' instead?}} {{11-20=P1_1}}
+  func p1_1() {}
+}
+
+extension P1_1 & P1 where Self : P2 {
+  // expected-warning@-1 {{extending a protocol composition is not supported; extending 'P1_1' instead}} {{11-20=P1_1}}
+  func p1_1_alt() {}
+}
+
+typealias T1 = P1 & P1_1
+
+extension T1 {
+  // expected-warning@-1 {{extending a protocol composition is not supported; extending 'P1' instead}}
+  // expected-note@-2 {{did you mean to extend the most specific type 'P1_1' instead?}} {{11-13=P1_1}}
+  func t1() {}
+}
+
+typealias T2 = T1
+
+extension T2 {
+  // expected-warning@-1 {{extending a protocol composition is not supported; extending 'P1' instead}}
+  // expected-note@-2 {{did you mean to extend the most specific type 'P1_1' instead?}} {{11-13=P1_1}}
+  func t2() {}
+}
+
+typealias T3 = P1_1 & P1
+
+extension T3 { // Ideally, we should emit a warning here but the current implementation doesn't do that.
+    func t3() {}
+}

trunk/test/Sema/composition_extension.swift

@@ -991,9 +991,7 @@ class BadClass5 : BadProto5 {} // expected-error{{type 'BadClass5' does not conf
 typealias A = BadProto1
 typealias B = BadProto1
 
-extension A & B { // okay
-
-}
+extension A & B {} // expected-warning {{extending a protocol composition is not supported; extending 'BadProto1' instead}}
 
 // Suppress near-miss warning for unlabeled initializers.
 protocol P9 {