---

yaml
---
r: 345583
b: refs/heads/master
c: 34adb2a
h: refs/heads/master
i:
  345581: 7780511
  345579: a7f259a
  345575: a8f2cdd
  345567: 3b2cd33

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 8af6e75e3ffd93fc97601ae5ecfd1cecb2d544da
+refs/heads/master: 34adb2ac74cbd23bb6267360514c2d591057b5c7
 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/GenericSignatureBuilder.h

@@ -1452,6 +1452,11 @@ class GenericSignatureBuilder::FloatingRequirementSource {
   /// Whether this is an explicitly-stated requirement.
   bool isExplicit() const;
 
+  /// Whether this is a top-level requirement written in source.
+  /// FIXME: This is a hack because expandConformanceRequirement()
+  /// is too eager; we should remove this once we fix it properly.
+  bool isTopLevel() const { return kind == Explicit; }
+
   /// Return the "inferred" version of this source, if it isn't already
   /// inferred.
   FloatingRequirementSource asInferred(const TypeRepr *typeRepr) const;

trunk/lib/AST/GenericSignatureBuilder.cpp

@@ -5157,8 +5157,18 @@ ConstraintResult GenericSignatureBuilder::addSameTypeRequirementBetweenConcrete(
     }
   } matcher(*this, source, type1, type2, diagnoseMismatch);
 
-  return matcher.match(type1, type2) ? ConstraintResult::Resolved
-                                     : ConstraintResult::Conflicting;
+  if (matcher.match(type1, type2)) {
+    // Warn if neither side of the requirement contains a type parameter.
+    if (source.isTopLevel() && source.getLoc().isValid()) {
+      Diags.diagnose(source.getLoc(),
+                     diag::requires_no_same_type_archetype,
+                     type1, type2);
+    }
+
+    return ConstraintResult::Resolved;
+  }
+
+  return ConstraintResult::Conflicting;
 }
 
 ConstraintResult GenericSignatureBuilder::addSameTypeRequirement(
@@ -5344,19 +5354,6 @@ GenericSignatureBuilder::addRequirement(const Requirement &req,
   case RequirementKind::SameType: {
     auto secondType = subst(req.getSecondType());
 
-    // Warn if neither side of the requirement contains a type parameter.
-    if (reqRepr &&
-        !req.getFirstType()->hasTypeParameter() &&
-        !req.getSecondType()->hasTypeParameter() &&
-        !req.getFirstType()->hasError() &&
-        !req.getSecondType()->hasError()) {
-      Diags.diagnose(reqRepr->getSeparatorLoc(),
-                     diag::requires_no_same_type_archetype,
-                     req.getFirstType(), req.getSecondType())
-        .highlight(reqRepr->getFirstTypeLoc().getSourceRange())
-        .highlight(reqRepr->getSecondTypeLoc().getSourceRange());
-    }
-
     if (inferForModule) {
       inferRequirements(*inferForModule, firstType,
                         RequirementRepr::getFirstTypeRepr(reqRepr),

trunk/lib/Sema/TypeCheckType.cpp

@@ -215,46 +215,69 @@ Type TypeResolution::resolveDependentMemberType(
   auto lazyResolver = ctx.getLazyResolver();
   if (lazyResolver)
     lazyResolver->resolveDeclSignature(concrete);
-
-  if (auto typeAlias = dyn_cast<TypeAliasDecl>(concrete)) {
-    if (auto protocol = dyn_cast<ProtocolDecl>(typeAlias->getDeclContext())) {
-      // We need to make sure the generic environment of a surrounding protocol
-      // propagates to the typealias, since the former may not have existed when
-      // the typealiases type was first computed.
-      // FIXME: See the comment in the ProtocolDecl case of validateDecl().
-      if (lazyResolver)
-        lazyResolver->resolveProtocolEnvironment(protocol);
-    }
-  }
   if (!concrete->hasInterfaceType())
     return ErrorType::get(ctx);
-  if (baseTy->isTypeParameter()) {
-    if (auto proto = concrete->getDeclContext()->getSelfProtocolDecl()) {
-      // Fast path: if there are no type parameters in the concrete type, just
-      // return it.
-      if (!concrete->getDeclaredInterfaceType()->hasTypeParameter())
-        return concrete->getDeclaredInterfaceType();
 
-      if (lazyResolver)
-        lazyResolver->resolveProtocolEnvironment(proto);
+  if (concrete->getDeclContext()->getSelfClassDecl()) {
+    // We found a member of a class from a protocol or protocol
+    // extension.
+    //
+    // Get the superclass of the 'Self' type parameter.
+    baseTy = (baseEquivClass->concreteType
+              ? baseEquivClass->concreteType
+              : baseEquivClass->superclass);
+    assert(baseTy);
+  }
 
-      auto subMap = SubstitutionMap::getProtocolSubstitutions(
-                      proto, baseTy, ProtocolConformanceRef(proto));
-      return concrete->getDeclaredInterfaceType().subst(subMap);
-    }
+  return TypeChecker::substMemberTypeWithBase(DC->getParentModule(), concrete,
+                                              baseTy);
+}
 
-    Type baseType = baseEquivClass->concreteType ? baseEquivClass->concreteType
-                                                 : baseEquivClass->superclass;
+Type TypeResolution::resolveSelfAssociatedType(Type baseTy,
+                                               DeclContext *DC,
+                                               Identifier name) const {
+  switch (stage) {
+  case TypeResolutionStage::Structural:
+    return DependentMemberType::get(baseTy, name);
 
-    if (baseType) {
-      return baseType->getTypeOfMember(DC->getParentModule(), concrete,
-                                       concrete->getDeclaredInterfaceType());
-    }
+  case TypeResolutionStage::Contextual:
+    llvm_unreachable("Dependent type after archetype substitution");
 
-    llvm_unreachable("shouldn't have a concrete decl here");
+  case TypeResolutionStage::Interface:
+    // Handled below.
+    break;
   }
 
-  return TypeChecker::substMemberTypeWithBase(DC->getParentModule(), concrete,
+  assert(stage == TypeResolutionStage::Interface);
+  auto builder = getGenericSignatureBuilder();
+  auto baseEquivClass =
+    builder->resolveEquivalenceClass(
+                                baseTy,
+                                ArchetypeResolutionKind::CompleteWellFormed);
+  if (!baseEquivClass)
+    return ErrorType::get(baseTy);
+
+  // Look for a nested type with the given name.
+  auto nestedType = baseEquivClass->lookupNestedType(*builder, name);
+  assert(nestedType);
+
+  // If the nested type has been resolved to an associated type, use it.
+  if (auto assocType = dyn_cast<AssociatedTypeDecl>(nestedType)) {
+    return DependentMemberType::get(baseTy, assocType);
+  }
+
+  if (nestedType->getDeclContext()->getSelfClassDecl()) {
+    // We found a member of a class from a protocol or protocol
+    // extension.
+    //
+    // Get the superclass of the 'Self' type parameter.
+    baseTy = (baseEquivClass->concreteType
+              ? baseEquivClass->concreteType
+              : baseEquivClass->superclass);
+    assert(baseTy);
+  }
+
+  return TypeChecker::substMemberTypeWithBase(DC->getParentModule(), nestedType,
                                               baseTy);
 }
 
@@ -279,6 +302,12 @@ bool TypeResolution::areSameType(Type type1, Type type2) const {
 
   // If we have a generic signature, canonicalize using it.
   if (auto genericSig = getGenericSignature()) {
+    // If both are type parameters, we can use a cheaper check
+    // that avoids transforming the type and computing anchors.
+    if (type1->isTypeParameter() &&
+        type2->isTypeParameter()) {
+      return genericSig->areSameTypeParameterInContext(type1, type2);
+    }
     return genericSig->getCanonicalTypeInContext(type1)
       == genericSig->getCanonicalTypeInContext(type2);
   }
@@ -542,20 +571,41 @@ Type TypeChecker::resolveTypeInContext(
     selfType = resolution.mapTypeIntoContext(
       foundDC->getSelfInterfaceType());
 
-    if (selfType->is<GenericTypeParamType>() &&
-        typeDecl->getDeclContext()->getSelfClassDecl()) {
-      // We found a member of a class from a protocol or protocol
-      // extension.
-      //
-      // Get the superclass of the 'Self' type parameter.
-      auto *sig = foundDC->getGenericSignatureOfContext();
-      if (!sig)
-        return ErrorType::get(ctx);
-      auto superclassType = sig->getSuperclassBound(selfType);
-      if (!superclassType)
-        return ErrorType::get(ctx);
+    if (selfType->is<GenericTypeParamType>()) {
+      if (typeDecl->getDeclContext()->getSelfProtocolDecl()) {
+        if (isa<AssociatedTypeDecl>(typeDecl) ||
+            (isa<TypeAliasDecl>(typeDecl) &&
+             !cast<TypeAliasDecl>(typeDecl)->isGeneric())) {
+          // FIXME: We should use this lookup method for the Interface
+          // stage too, but right now that causes problems with
+          // Sequence.SubSequence vs Collection.SubSequence; the former
+          // is more canonical, but if we return that instead of the
+          // latter, we infer the wrong associated type in some cases,
+          // because we use the Sequence.SubSequence default instead of
+          // the Collection.SubSequence default, even when the conforming
+          // type wants to conform to Collection.
+          if (resolution.getStage() == TypeResolutionStage::Structural) {
+            return resolution.resolveSelfAssociatedType(
+              selfType, foundDC, typeDecl->getName());
+          }
+        }
+      }
 
-      selfType = superclassType;
+      // FIXME: Remove this once the above FIXME is addressed.
+      if (typeDecl->getDeclContext()->getSelfClassDecl()) {
+        // We found a member of a class from a protocol or protocol
+        // extension.
+        //
+        // Get the superclass of the 'Self' type parameter.
+        auto *sig = foundDC->getGenericSignatureOfContext();
+        if (!sig)
+          return ErrorType::get(ctx);
+        auto superclassType = sig->getSuperclassBound(selfType);
+        if (!superclassType)
+          return ErrorType::get(ctx);
+
+        selfType = superclassType;
+      }
     }
   }
 

trunk/lib/Sema/TypeCheckType.h

@@ -351,6 +351,11 @@ class TypeResolution {
                                   SourceRange baseRange,
                                   ComponentIdentTypeRepr *ref) const;
 
+  /// Resolve an unqualified reference to an associated type or type alias
+  /// in a protocol.
+  Type resolveSelfAssociatedType(Type baseTy, DeclContext *DC,
+                                 Identifier name) const;
+
   /// Determine whether the given two types are equivalent within this
   /// type resolution context.
   bool areSameType(Type type1, Type type2) const;

trunk/test/Constraints/same_types.swift

@@ -240,6 +240,7 @@ func structuralSameType3<T, U, V, W>(_: T, _: U, _: V, _: W)
   where X1<T, U> == X1<V, W> { }
 // expected-error@-1{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
 // expected-error@-2{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
+// expected-warning@-3{{neither type in same-type constraint ('X1<T, U>' or 'X1<V, W>') refers to a generic parameter or associated type}}
 
 protocol P2 {
   associatedtype Assoc1
@@ -285,6 +286,7 @@ func test9<T: P6, U: P6>(_ t: T, u: U)
 func testMetatypeSameType<T, U>(_ t: T, _ u: U)
   where T.Type == U.Type { }
 // expected-error@-1{{same-type requirement makes generic parameters 'T' and 'U' equivalent}}
+// expected-warning@-2{{neither type in same-type constraint ('T.Type' or 'U.Type') refers to a generic parameter or associated type}}
 
 func testSameTypeCommutativity1<U, T>(_ t: T, _ u: U)
   where T.Type == U { } // Equivalent to U == T.Type

trunk/test/Generics/function_decls.swift

@@ -38,13 +38,13 @@ protocol P {
 
 func f12<T : P>(x: T) -> T.A<Int> {} // expected-error {{cannot specialize non-generic type 'T.A'}}{{29-34=}}
 
-func f13<T : P>(x: T) -> T.B<Int> {} // expected-error {{cannot specialize non-generic type 'P.B' (aka 'Int')}}{{29-34=}}
+func f13<T : P>(x: T) -> T.B<Int> {} // expected-error {{cannot specialize non-generic type 'T.B' (aka 'Int')}}{{29-34=}}
 
 func f14<T : P>(x: T) -> T.C<Int> {}
 
 func f15<T : P>(x: T) -> T.D<Int> {}
 
-func f16<T : P>(x: T) -> T.D {} // expected-error {{reference to generic type 'P.D' (aka 'G') requires arguments in <...>}}
+func f16<T : P>(x: T) -> T.D {} // expected-error {{reference to generic type 'T.D' (aka 'G') requires arguments in <...>}}
 
 func f17<T : P>(x: T) -> T.E<Int> {}
 

trunk/test/Generics/protocol_type_aliases.swift

@@ -35,6 +35,7 @@ func requirementOnConcreteNestedTypeAlias<T>(_: T) where T: Q2, T.C == T.B.X {}
 // CHECK-LABEL: .concreteRequirementOnConcreteNestedTypeAlias@
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Q2, τ_0_0.C == τ_0_0.B.A>
 func concreteRequirementOnConcreteNestedTypeAlias<T>(_: T) where T: Q2, S<T.C> == T.B.X {}
+// expected-warning@-1 {{neither type in same-type constraint ('S<T.C>' or 'S<T.B.A>') refers to a generic parameter or associated type}}
 
 
 // Incompatible concrete typealias types are flagged as such

trunk/test/Generics/same_type_constraints.swift

@@ -376,8 +376,7 @@ func resultTypeSuppress<T: P1>() -> StructTakingP1<T> {
 typealias NotAnInt = Double
 
 extension X11 where NotAnInt == Int { }
-// expected-warning@-1{{neither type in same-type constraint ('NotAnInt' (aka 'Double') or 'Int') refers to a generic parameter or associated type}}
-// expected-error@-2{{generic signature requires types 'NotAnInt' (aka 'Double') and 'Int' to be the same}}
+// expected-error@-1{{generic signature requires types 'NotAnInt' (aka 'Double') and 'Int' to be the same}}
 
 
 struct X12<T> { }

trunk/test/decl/protocol/req/associated_type_ambiguity.swift

@@ -0,0 +1,58 @@
+// RUN: %target-typecheck-verify-swift
+
+// Reference to associated type from 'where' clause should not be
+// ambiguous when there's a typealias with the same name in another
+// protocol.
+//
+// FIXME: The semantics here are still really iffy. There's also a
+// case to be made that type aliases in protocol extensions should
+// only act as defaults and not as same-type constraints. However,
+// if we decide to go down that route, it's important that *both*
+// the unqualified (T) and qualified (Self.T) lookups behave the
+// same.
+protocol P1 {
+  typealias T = Int // expected-note {{found this candidate}}
+}
+
+protocol P2 {
+  associatedtype T // expected-note {{found this candidate}}
+}
+
+// FIXME: This extension's generic signature is still minimized differently from
+// the next one. We need to decide if 'T == Int' is a redundant requirement or
+// not.
+extension P1 where Self : P2, T == Int {
+  func takeT1(_: T) {}
+  func takeT2(_: Self.T) {}
+}
+
+extension P1 where Self : P2 {
+  // FIXME: This doesn't make sense -- either both should
+  // succeed, or both should be ambiguous.
+  func takeT1(_: T) {} // expected-error {{'T' is ambiguous for type lookup in this context}}
+  func takeT2(_: Self.T) {}
+}
+
+// Same as above, but now we have two visible associated types with the same
+// name.
+protocol P3 {
+  associatedtype T
+}
+
+// FIXME: This extension's generic signature is still minimized differently from
+// the next one. We need to decide if 'T == Int' is a redundant requirement or
+// not.
+extension P2 where Self : P3, T == Int {
+  func takeT1(_: T) {}
+  func takeT2(_: Self.T) {}
+}
+
+extension P2 where Self : P3 {
+  func takeT1(_: T) {}
+  func takeT2(_: Self.T) {}
+}
+
+protocol P4 : P2, P3 {
+  func takeT1(_: T)
+  func takeT2(_: Self.T)
+}