---

yaml
---
r: 344989
b: refs/heads/master
c: da52325
h: refs/heads/master
i:
  344987: 7b38ec2

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 0b1649287cc250f5e34b4a1d6f79e2bdfc5990a9
+refs/heads/master: da52325f89d652aac035922193b375d6d32a90d8
 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/Decl.h

@@ -1214,6 +1214,22 @@ class RequirementRepr {
                        SecondType.getSourceRange().End);
   }
 
+  /// Retrieve the first or subject type representation from the \c repr,
+  /// or \c nullptr if \c repr is null.
+  static TypeRepr *getFirstTypeRepr(const RequirementRepr *repr) {
+    if (!repr) return nullptr;
+    return repr->FirstType.getTypeRepr();
+  }
+
+  /// Retrieve the second or constraint type representation from the \c repr,
+  /// or \c nullptr if \c repr is null.
+  static TypeRepr *getSecondTypeRepr(const RequirementRepr *repr) {
+    if (!repr) return nullptr;
+    assert(repr->getKind() == RequirementReprKind::TypeConstraint ||
+           repr->getKind() == RequirementReprKind::SameType);
+    return repr->SecondType.getTypeRepr();
+  }
+
   LLVM_ATTRIBUTE_DEPRECATED(
       void dump() const LLVM_ATTRIBUTE_USED,
       "only for use within the debugger");
@@ -6636,6 +6652,9 @@ inline EnumElementDecl *EnumDecl::getUniqueElement(bool hasValue) const {
 std::pair<DefaultArgumentKind, Type>
 getDefaultArgumentInfo(ValueDecl *source, unsigned Index);
 
+/// Display Decl subclasses.
+void simple_display(llvm::raw_ostream &out, const Decl *decl);
+
 /// Display ValueDecl subclasses.
 void simple_display(llvm::raw_ostream &out, const ValueDecl *decl);
 

trunk/include/swift/AST/GenericSignatureBuilder.h

@@ -574,19 +574,8 @@ class GenericSignatureBuilder {
   ///
   /// \returns true if this requirement makes the set of requirements
   /// inconsistent, in which case a diagnostic will have been issued.
-  ConstraintResult addRequirement(const RequirementRepr *req,
-                                  ModuleDecl *inferForModule);
-
-  /// \brief Add a new requirement.
-  ///
-  /// \param inferForModule Infer additional requirements from the types
-  /// relative to the given module.
-  ///
-  /// \returns true if this requirement makes the set of requirements
-  /// inconsistent, in which case a diagnostic will have been issued.
-  ConstraintResult addRequirement(const RequirementRepr *Req,
+  ConstraintResult addRequirement(const Requirement &req,
                                   FloatingRequirementSource source,
-                                  const SubstitutionMap *subMap,
                                   ModuleDecl *inferForModule);
 
   /// \brief Add an already-checked requirement.
@@ -600,7 +589,9 @@ class GenericSignatureBuilder {
   /// \returns true if this requirement makes the set of requirements
   /// inconsistent, in which case a diagnostic will have been issued.
   ConstraintResult addRequirement(const Requirement &req,
+                                  const RequirementRepr *reqRepr,
                                   FloatingRequirementSource source,
+                                  const SubstitutionMap *subMap,
                                   ModuleDecl *inferForModule);
 
   /// \brief Add all of a generic signature's parameters and requirements.
@@ -618,7 +609,9 @@ class GenericSignatureBuilder {
   /// where \c Dictionary requires that its key type be \c Hashable,
   /// the requirement \c K : Hashable is inferred from the parameter type,
   /// because the type \c Dictionary<K,V> cannot be formed without it.
-  void inferRequirements(ModuleDecl &module, TypeLoc type,
+  void inferRequirements(ModuleDecl &module,
+                         Type type,
+                         const TypeRepr *typeRepr,
                          FloatingRequirementSource source);
 
   /// Infer requirements from the given pattern, recursively.
@@ -1744,6 +1737,15 @@ inline bool isErrorResult(GenericSignatureBuilder::ConstraintResult result) {
 /// Canonical ordering for dependent types.
 int compareDependentTypes(Type type1, Type type2);
 
+template<typename T>
+Type GenericSignatureBuilder::Constraint<T>::getSubjectDependentType(
+                      TypeArrayView<GenericTypeParamType> genericParams) const {
+  if (auto type = subject.dyn_cast<Type>())
+    return type;
+
+  return subject.get<PotentialArchetype *>()->getDependentType(genericParams);
+}
+
 } // end namespace swift
 
 #endif

trunk/include/swift/AST/LayoutConstraint.h

@@ -343,6 +343,10 @@ struct LayoutConstraintLoc {
   bool hasLocation() const { return Loc.isValid(); }
   LayoutConstraint getLayoutConstraint() const { return Layout; }
 
+  void setLayoutConstraint(LayoutConstraint value) {
+    Layout = value;
+  }
+
   bool isNull() const { return Layout.isNull(); }
 
   LayoutConstraintLoc clone(ASTContext &ctx) const { return *this; }

trunk/include/swift/AST/LazyResolver.h

@@ -63,9 +63,6 @@ class LazyResolver {
   /// Resolve the generic environment of the given protocol.
   virtual void resolveProtocolEnvironment(ProtocolDecl *proto) = 0;
 
-  /// Resolve the trailing where clause of the given protocol in-place.
-  virtual void resolveTrailingWhereClause(ProtocolDecl *proto) = 0;
-
   /// Bind an extension to its extended type.
   virtual void bindExtension(ExtensionDecl *ext) = 0;
 

trunk/include/swift/AST/TypeCheckRequests.h

@@ -22,10 +22,13 @@
 #include "swift/AST/TypeResolutionStage.h"
 #include "swift/Basic/Statistic.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/TinyPtrVector.h"
 
 namespace swift {
 
+class GenericParamList;
+class RequirementRepr;
 struct TypeLoc;
 
 /// Display a nominal type or extension thereof.
@@ -209,6 +212,85 @@ class IsDynamicRequest :
   void cacheResult(bool value) const;
 };
 
+/// Describes the owner of a where clause, from which we can extract
+/// requirements.
+struct WhereClauseOwner {
+  /// The declaration context in which the where clause will be evaluated.
+  DeclContext *dc;
+
+  /// The source of the where clause, which can be a generic parameter list
+  /// or a declaration that can have a where clause.
+  llvm::PointerUnion<GenericParamList *, Decl *> source;
+
+  WhereClauseOwner(Decl *decl);
+
+  WhereClauseOwner(DeclContext *dc, GenericParamList *genericParams)
+    : dc(dc), source(genericParams) { }
+
+  SourceLoc getLoc() const;
+
+  friend hash_code hash_value(const WhereClauseOwner &owner) {
+    return hash_combine(hash_value(owner.dc), hash_value(owner.source));
+  }
+
+  friend bool operator==(const WhereClauseOwner &lhs,
+                         const WhereClauseOwner &rhs) {
+    return lhs.dc == rhs.dc && lhs.source == rhs.source;
+  }
+
+  friend bool operator!=(const WhereClauseOwner &lhs,
+                         const WhereClauseOwner &rhs) {
+    return !(lhs == rhs);
+  }
+};
+
+void simple_display(llvm::raw_ostream &out, const WhereClauseOwner &owner);
+
+/// Retrieve a requirement from the where clause of the given declaration.
+class RequirementRequest :
+    public SimpleRequest<RequirementRequest,
+                         CacheKind::SeparatelyCached,
+                         Requirement,
+                         WhereClauseOwner,
+                         unsigned,
+                         TypeResolutionStage> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+  /// Retrieve the array of requirements from the given owner.
+  static MutableArrayRef<RequirementRepr> getRequirements(WhereClauseOwner);
+
+  /// Visit each of the requirements in the given owner,
+  ///
+  /// \returns true after short-circuiting if the callback returned \c true
+  /// for any of the requirements.
+  static bool visitRequirements(
+      WhereClauseOwner, TypeResolutionStage stage,
+      llvm::function_ref<bool(Requirement, RequirementRepr*)> callback);
+
+private:
+  friend class SimpleRequest;
+
+  /// Retrieve the requirement this request operates on.
+  RequirementRepr &getRequirement() const;
+
+  // Evaluation.
+  llvm::Expected<Requirement> evaluate(Evaluator &evaluator,
+                                       WhereClauseOwner,
+                                       unsigned index,
+                                       TypeResolutionStage stage) const;
+
+public:
+  // Cycle handling
+  void diagnoseCycle(DiagnosticEngine &diags) const;
+  void noteCycleStep(DiagnosticEngine &diags) const;
+
+  // Separate caching.
+  bool isCached() const;
+  Optional<Requirement> getCachedResult() const;
+  void cacheResult(Requirement value) const;
+};
+
 /// The zone number for the type checker.
 #define SWIFT_TYPE_CHECKER_REQUESTS_TYPEID_ZONE 10
 

trunk/include/swift/AST/TypeCheckerTypeIDZone.def

@@ -20,3 +20,4 @@ SWIFT_TYPEID(EnumRawTypeRequest)
 SWIFT_TYPEID(OverriddenDeclsRequest)
 SWIFT_TYPEID(IsObjCRequest)
 SWIFT_TYPEID(IsDynamicRequest)
+SWIFT_TYPEID(RequirementRequest)

trunk/lib/AST/AccessRequests.cpp

@@ -18,6 +18,7 @@
 #include "swift/AST/DiagnosticsCommon.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/Types.h"
 
 #include "llvm/Support/MathExtras.h"
@@ -212,12 +213,12 @@ DefaultAndMaxAccessLevelRequest::evaluate(Evaluator &evaluator,
                          AccessLevel::FilePrivate);
   }
 
-  if (const GenericParamList *genericParams = ED->getGenericParams()) {
-    auto getTypeAccess = [ED](const TypeLoc &TL) -> AccessLevel {
-      if (!TL.getType())
+  if (GenericParamList *genericParams = ED->getGenericParams()) {
+    auto getTypeAccess = [ED](Type type, TypeRepr *typeRepr) -> AccessLevel {
+      if (!type)
         return AccessLevel::Public;
       auto accessScope =
-          TypeReprAccessScopeChecker::getAccessScope(TL.getTypeRepr(),
+          TypeReprAccessScopeChecker::getAccessScope(typeRepr,
                                                      ED->getDeclContext());
       // This is an error case and will be diagnosed elsewhere.
       if (!accessScope.hasValue())
@@ -236,21 +237,30 @@ DefaultAndMaxAccessLevelRequest::evaluate(Evaluator &evaluator,
 
     // Only check the trailing 'where' requirements. Other requirements come
     // from the extended type and have already been checked.
-    for (const RequirementRepr &req : genericParams->getTrailingRequirements()){
-      switch (req.getKind()) {
-      case RequirementReprKind::TypeConstraint:
-        maxAccess = std::min(getTypeAccess(req.getSubjectLoc()), maxAccess);
-        maxAccess = std::min(getTypeAccess(req.getConstraintLoc()), maxAccess);
-        break;
-      case RequirementReprKind::LayoutConstraint:
-        maxAccess = std::min(getTypeAccess(req.getSubjectLoc()), maxAccess);
-        break;
-      case RequirementReprKind::SameType:
-        maxAccess = std::min(getTypeAccess(req.getFirstTypeLoc()), maxAccess);
-        maxAccess = std::min(getTypeAccess(req.getSecondTypeLoc()), maxAccess);
-        break;
-      }
-    }
+    RequirementRequest::visitRequirements(
+        WhereClauseOwner(ED, genericParams),
+        TypeResolutionStage::Interface,
+        [&](Requirement req, RequirementRepr *reqRepr) {
+          switch (req.getKind()) {
+          case RequirementKind::Conformance:
+          case RequirementKind::Superclass:
+          case RequirementKind::SameType:
+            maxAccess = std::min(getTypeAccess(
+                                   req.getSecondType(),
+                                   RequirementRepr::getSecondTypeRepr(reqRepr)),
+                                 maxAccess);
+            LLVM_FALLTHROUGH;
+
+          case RequirementKind::Layout:
+            maxAccess = std::min(getTypeAccess(
+                                   req.getFirstType(),
+                                   RequirementRepr::getFirstTypeRepr(reqRepr)),
+                                 maxAccess);
+            break;
+          }
+
+          return false;
+        });
   }
 
   AccessLevel defaultAccess;

trunk/lib/AST/Decl.cpp

@@ -6173,6 +6173,25 @@ NominalTypeDecl *TypeOrExtensionDecl::getBaseNominal() const {
 }
 bool TypeOrExtensionDecl::isNull() const { return Decl.isNull(); }
 
+void swift::simple_display(llvm::raw_ostream &out, const Decl *decl) {
+  if (!decl) {
+    out << "(null)";
+    return;
+  }
+
+  if (auto value = dyn_cast<ValueDecl>(decl)) {
+    simple_display(out, value);
+  } else if (auto ext = dyn_cast<ExtensionDecl>(decl)) {
+    out << "extension of ";
+    if (auto typeRepr = ext->getExtendedTypeLoc().getTypeRepr())
+      typeRepr->print(out);
+    else
+      ext->getSelfNominalTypeDecl()->dumpRef(out);
+  } else {
+    out << "(unknown decl)";
+  }
+}
+
 void swift::simple_display(llvm::raw_ostream &out, const ValueDecl *decl) {
   if (decl) decl->dumpRef(out);
   else out << "(null)";

trunk/lib/AST/GenericSignature.cpp

@@ -786,7 +786,8 @@ static bool hasNonCanonicalSelfProtocolRequirement(
 
 /// Retrieve the best requirement source from the list
 static const RequirementSource *
-getBestRequirementSource(ArrayRef<GSBConstraint<ProtocolDecl *>> constraints) {
+getBestRequirementSource(GenericSignatureBuilder &builder,
+                         ArrayRef<GSBConstraint<ProtocolDecl *>> constraints) {
   const RequirementSource *bestSource = nullptr;
   bool bestIsNonCanonical = false;
 
@@ -802,6 +803,16 @@ getBestRequirementSource(ArrayRef<GSBConstraint<ProtocolDecl *>> constraints) {
   for (const auto &constraint : constraints) {
     auto source = constraint.source;
 
+    // Skip self-recursive sources.
+    bool derivedViaConcrete = false;
+    if (source->getMinimalConformanceSource(
+                                        builder,
+                                        constraint.getSubjectDependentType({ }),
+                                        constraint.value,
+                                        derivedViaConcrete)
+          != source)
+      continue;
+
     // If there is a non-canonical protocol requirement next to the root,
     // skip this requirement source.
     bool isNonCanonical =
@@ -907,7 +918,8 @@ void GenericSignature::buildConformanceAccessPath(
     assert(conforms != equivClass->conformsTo.end());
 
     // Compute the root type, canonicalizing it w.r.t. the protocol context.
-    auto conformsSource = getBestRequirementSource(conforms->second);
+    auto conformsSource = getBestRequirementSource(inProtoSigBuilder,
+                                                   conforms->second);
     assert(conformsSource != source || !requirementSignatureProto);
     Type localRootType = conformsSource->getRootType();
     localRootType = inProtoSig->getCanonicalTypeInContext(localRootType);
@@ -977,7 +989,7 @@ GenericSignature::getConformanceAccessPath(Type type, ProtocolDecl *protocol) {
   assert(conforms != equivClass->conformsTo.end());
 
   // Canonicalize the root type.
-  auto source = getBestRequirementSource(conforms->second);
+  auto source = getBestRequirementSource(builder, conforms->second);
   Type rootType = source->getRootType()->getCanonicalType(this);
 
   // Build the path.