Merge pull request #5687 from DougGregor/drop-witness-markers

Drop witness markers for 'uninteresting' dependent types

Author: DougGregor

lib/AST/ArchetypeBuilder.cpp

@@ -2046,6 +2046,15 @@ Type ArchetypeBuilder::substDependentType(Type type) {
 static void collectRequirements(ArchetypeBuilder &builder,
                                 ArrayRef<GenericTypeParamType *> params,
                                 SmallVectorImpl<Requirement> &requirements) {
+  // Don't emit WitnessMarker requirements for secondary types with
+  // no requirements.
+  auto dropRedundantWitnessMarker = [&]() {
+    if (!requirements.empty() &&
+        requirements.back().getKind() == RequirementKind::WitnessMarker &&
+        !requirements.back().getFirstType()->is<GenericTypeParamType>())
+      requirements.pop_back();
+  };
+
   builder.enumerateRequirements([&](RequirementKind kind,
           ArchetypeBuilder::PotentialArchetype *archetype,
           llvm::PointerUnion<Type, ArchetypeBuilder::PotentialArchetype *> type,
@@ -2070,6 +2079,7 @@ static void collectRequirements(ArchetypeBuilder &builder,
       return;
 
     if (kind == RequirementKind::WitnessMarker) {
+      dropRedundantWitnessMarker();
       requirements.push_back(Requirement(kind, depTy, Type()));
       return;
     }
@@ -2089,6 +2099,8 @@ static void collectRequirements(ArchetypeBuilder &builder,
 
     requirements.push_back(Requirement(kind, depTy, repTy));
   });
+
+  dropRedundantWitnessMarker();
 }
 
 GenericSignature *ArchetypeBuilder::getGenericSignature() {

lib/AST/ProtocolConformance.cpp

@@ -393,6 +393,8 @@ SpecializedProtocolConformance::getTypeWitnessSubstAndDecl(
   // Apply the substitution we computed above
   auto specializedType
     = genericWitness.getReplacement().subst(substitutionMap, None);
+  if (!specializedType)
+    specializedType = ErrorType::get(genericWitness.getReplacement());
 
   // If the type witness was unchanged, just copy it directly.
   if (specializedType.getPointer() == genericWitness.getReplacement().getPointer()) {

lib/AST/Type.cpp

@@ -2810,12 +2810,12 @@ static Type getMemberForBaseType(ConformanceSource conformances,
     }
 
     if (!conformance) return failed();
+    if (!conformance->isConcrete()) return failed();
 
     // If we have an unsatisfied type witness while we're checking the
     // conformances we're supposed to skip this conformance's unsatisfied type
     // witnesses, and we have an unsatisfied type witness, return
     // "missing".
-    assert(conformance->isConcrete());
     if (conformance->getConcrete()->getRootNormalConformance()->getState()
           == ProtocolConformanceState::CheckingTypeWitnesses &&
         !conformance->getConcrete()->hasTypeWitness(assocType, nullptr))

lib/SILOptimizer/Utils/Local.cpp

@@ -1332,28 +1332,6 @@ void ValueLifetimeAnalysis::dump() const {
 //                    Casts Optimization and Simplification
 //===----------------------------------------------------------------------===//
 
-/// \brief Get a substitution corresponding to the type witness.
-/// Inspired by ProtocolConformance::getTypeWitnessByName.
-static const Substitution *
-getTypeWitnessByName(ProtocolConformance *conformance, Identifier name) {
-  // Find the named requirement.
-  AssociatedTypeDecl *assocType = nullptr;
-  assert(conformance && "Missing conformance information");
-  auto members = conformance->getProtocol()->lookupDirect(name);
-  for (auto member : members) {
-    assocType = dyn_cast<AssociatedTypeDecl>(member);
-    if (assocType)
-      break;
-  }
-
-  if (!assocType)
-    return nullptr;
-
-  if (!conformance->hasTypeWitness(assocType, nullptr)) {
-    return nullptr;
-  }
-  return &conformance->getTypeWitness(assocType, nullptr);
-}
 
 /// Check if is a bridging cast, i.e. one of the sides is
 /// a bridged type.
@@ -1513,14 +1491,12 @@ optimizeBridgedObjCToSwiftCast(SILInstruction *Inst,
   SmallVector<SILValue, 1> Args;
 
   // Add substitutions
-  SmallVector<Substitution, 2> Subs;
   auto Conformances =
     M.getASTContext().AllocateUninitialized<ProtocolConformanceRef>(1);
   Conformances[0] = ProtocolConformanceRef(Conformance);
-  Subs.push_back(Substitution(Target, Conformances));
-  const Substitution *DepTypeSubst = getTypeWitnessByName(
-      Conformance, M.getASTContext().getIdentifier("_ObjectiveCType"));
-  Subs.push_back(*DepTypeSubst);
+  Substitution Subs[1] = {
+    Substitution(Target, Conformances)
+  };
   auto SILFnTy = FuncRef->getType();
   SILType SubstFnTy = SILFnTy.substGenericArgs(M, Subs);
   SILType ResultTy = SubstFnTy.castTo<SILFunctionType>()->getSILResult();

lib/Sema/CSApply.cpp

@@ -1573,26 +1573,9 @@ namespace {
       auto fnGenericParams
         = fn->getGenericSignatureOfContext()->getGenericParams();
 
-      SmallVector<Substitution, 2> Subs;
-      Substitution sub(valueType, Conformances);
-      Subs.push_back(sub);
-
-      // Add substitution for the dependent type T._ObjectiveCType.
-      if (conformsToBridgedToObjectiveC) {
-        auto objcTypeId = tc.Context.Id_ObjectiveCType;
-        auto objcAssocType = cast<AssociatedTypeDecl>(
-                               conformance->getProtocol()->lookupDirect(
-                                 objcTypeId).front());
-        const Substitution &objcSubst = conformance->getTypeWitness(
-                                          objcAssocType, &tc);
-
-        // Create a substitution for the dependent type.
-        Substitution newDepTypeSubst(
-                       objcSubst.getReplacement(),
-                       objcSubst.getConformances());
-
-        Subs.push_back(newDepTypeSubst);
-      }
+      Substitution Subs[1] = {
+        Substitution(valueType, Conformances)
+      };
 
       ConcreteDeclRef fnSpecRef(tc.Context, fn, Subs);
       auto fnRef = new (tc.Context) DeclRefExpr(fnSpecRef,

lib/Sema/CSDiag.cpp

@@ -5436,7 +5436,9 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) {
     if (calleeInfo.closeness == CC_ExactMatch)
       return true;
 
-    if (!CS->getContextualType() || calleeInfo.closeness != CC_ArgumentMismatch)
+    if (!CS->getContextualType() ||
+        (calleeInfo.closeness != CC_ArgumentMismatch &&
+         calleeInfo.closeness != CC_OneGenericArgumentMismatch))
       return false;
 
     CalleeCandidateInfo candidates(fnExpr, hasTrailingClosure, CS);

lib/Sema/CodeSynthesis.cpp

@@ -1438,11 +1438,11 @@ void TypeChecker::completePropertyBehaviorParameter(VarDecl *VD,
 
 void TypeChecker::completePropertyBehaviorAccessors(VarDecl *VD,
                                        VarDecl *ValueImpl,
+                                       Type valueTy,
                                        ArrayRef<Substitution> SelfInterfaceSubs,
                                        ArrayRef<Substitution> SelfContextSubs) {
   auto selfTy = SelfContextSubs[0].getReplacement();
-  auto valueTy = SelfContextSubs[1].getReplacement();
-  
+
   SmallVector<ASTNode, 3> bodyStmts;
 
   auto makeSelfExpr = [&](FuncDecl *fromAccessor,

lib/Sema/ConstraintSystem.h

@@ -2382,7 +2382,7 @@ class ExprCleaner {
       }
 
       std::pair<bool, Pattern*> walkToPatternPre(Pattern *P) override {
-        TS->Patterns.insert({ P, P->getType() });
+        TS->Patterns.insert({ P, P->hasType() ? P->getType() : Type() });
         return { true, P };
       }
 

lib/Sema/TypeCheckDecl.cpp

@@ -2958,16 +2958,23 @@ static void checkVarBehavior(VarDecl *decl, TypeChecker &TC) {
     TC.Context.AllocateUninitialized<ProtocolConformanceRef>(1);
   auto selfConformance = new ((void*)conformanceMem.data())
     ProtocolConformanceRef(conformance);
-  // FIXME: Additional associated types introduced by other requirements?
-  Substitution interfaceSubs[] = {
+  Substitution allInterfaceSubs[] = {
     Substitution(behaviorInterfaceSelf, *selfConformance),
     Substitution(decl->getInterfaceType(), valueSub.getConformances()),
   };
-  Substitution contextSubs[] = {
+  Substitution allContextSubs[] = {
     Substitution(behaviorSelf, *selfConformance),
     Substitution(decl->getType(), valueSub.getConformances()),
   };
-  
+
+  ArrayRef<Substitution> interfaceSubs = allInterfaceSubs;
+  if (interfaceSubs.back().getConformances().empty())
+    interfaceSubs = interfaceSubs.drop_back();
+
+  ArrayRef<Substitution> contextSubs = allContextSubs;
+  if (contextSubs.back().getConformances().empty())
+    contextSubs = contextSubs.drop_back();
+
   // Now that type witnesses are done, satisfy property and method requirements.
   conformance->setState(ProtocolConformanceState::Checking);
 
@@ -3185,6 +3192,7 @@ static void checkVarBehavior(VarDecl *decl, TypeChecker &TC) {
   // Synthesize the bodies of the property's accessors now, forwarding to the
   // 'value' implementation.
   TC.completePropertyBehaviorAccessors(decl, behavior->ValueDecl,
+                                       decl->getType(),
                                        interfaceSubs, contextSubs);
 
   return;

lib/Sema/TypeCheckProtocol.cpp

@@ -1591,18 +1591,88 @@ namespace {
     /// requirements.
     SmallVector<std::tuple<AssociatedTypeDecl *, Type, CheckTypeWitnessResult>,
                 2> NonViable;
+
+    void dump(llvm::raw_ostream &out, unsigned indent) const {
+      out << "\n";
+      out.indent(indent) << "(";
+      if (Witness) {
+        Witness->dumpRef(out);
+      }
+
+      for (const auto &inferred : Inferred) {
+        out << "\n";
+        out.indent(indent + 2);
+        out << inferred.first->getName() << " := "
+            << inferred.second.getString();
+      }
+
+      for (const auto &inferred : NonViable) {
+        out << "\n";
+        out.indent(indent + 2);
+        out << std::get<0>(inferred)->getName() << " := "
+            << std::get<1>(inferred).getString();
+        if (auto nominal = std::get<2>(inferred).getProtocolOrClass())
+          out << " [failed constraint " << nominal->getName() << "]";
+      }
+
+      out << ")";
+    }
+
+    LLVM_ATTRIBUTE_DEPRECATED(void dump() const,
+                              "only for use in the debugger");
   };
 
+  void InferredAssociatedTypesByWitness::dump() const {
+    dump(llvm::errs(), 0);
+  }
+
   /// The set of witnesses that were considered when attempting to
   /// infer associated types.
   typedef SmallVector<InferredAssociatedTypesByWitness, 2>
     InferredAssociatedTypesByWitnesses;
 
+  void dumpInferredAssociatedTypesByWitnesses(
+        const InferredAssociatedTypesByWitnesses &inferred,
+        llvm::raw_ostream &out,
+        unsigned indent) {
+    for (const auto &value : inferred) {
+      value.dump(out, indent);
+    }
+  }
+
+  void dumpInferredAssociatedTypesByWitnesses(
+        const InferredAssociatedTypesByWitnesses &inferred) LLVM_ATTRIBUTE_USED;
+
+  void dumpInferredAssociatedTypesByWitnesses(
+                          const InferredAssociatedTypesByWitnesses &inferred) {
+    dumpInferredAssociatedTypesByWitnesses(inferred, llvm::errs(), 0);
+  }
+
   /// A mapping from requirements to the set of matches with witnesses.
   typedef SmallVector<std::pair<ValueDecl *,
                                 InferredAssociatedTypesByWitnesses>, 4>
     InferredAssociatedTypes;
 
+  void dumpInferredAssociatedTypes(const InferredAssociatedTypes &inferred,
+                                   llvm::raw_ostream &out,
+                                   unsigned indent) {
+    for (const auto &value : inferred) {
+      out << "\n";
+      out.indent(indent) << "(";
+      value.first->dumpRef(out);
+      dumpInferredAssociatedTypesByWitnesses(value.second, out, indent + 2);
+      out << ")";
+    }
+    out << "\n";
+  }
+
+  void dumpInferredAssociatedTypes(
+         const InferredAssociatedTypes &inferred) LLVM_ATTRIBUTE_USED;
+
+  void dumpInferredAssociatedTypes(const InferredAssociatedTypes &inferred) {
+    dumpInferredAssociatedTypes(inferred, llvm::errs(), 0);
+  }
+
   /// The protocol conformance checker.
   ///
   /// This helper class handles most of the details of checking whether a

lib/Sema/TypeChecker.h

@@ -1164,6 +1164,7 @@ class TypeChecker final : public LazyResolver {
   /// property.
   void completePropertyBehaviorAccessors(VarDecl *VD,
                                      VarDecl *ValueImpl,
+                                     Type valueTy,
                                      ArrayRef<Substitution> SelfInterfaceSubs,
                                      ArrayRef<Substitution> SelfContextSubs);
 

stdlib/public/core/BidirectionalCollection.swift

@@ -134,6 +134,29 @@ public protocol BidirectionalCollection
   ///     
   /// - Complexity: O(1)
   var last: Iterator.Element? { get }
+
+  /// Accesses a contiguous subrange of the collection's elements.
+  ///
+  /// The accessed slice uses the same indices for the same elements as the
+  /// original collection uses. Always use the slice's `startIndex` property
+  /// instead of assuming that its indices start at a particular value.
+  ///
+  /// This example demonstrates getting a slice of an array of strings, finding
+  /// the index of one of the strings in the slice, and then using that index
+  /// in the original array.
+  ///
+  ///     let streets = ["Adams", "Bryant", "Channing", "Douglas", "Evarts"]
+  ///     let streetsSlice = streets[2 ..< streets.endIndex]
+  ///     print(streetsSlice)
+  ///     // Prints "["Channing", "Douglas", "Evarts"]"
+  ///
+  ///     let index = streetsSlice.index(of: "Evarts")    // 4
+  ///     print(streets[index!])
+  ///     // Prints "Evarts"
+  ///
+  /// - Parameter bounds: A range of the collection's indices. The bounds of
+  ///   the range must be valid indices of the collection.
+  subscript(bounds: Range<Index>) -> SubSequence { get }
 }
 
 /// Default implementation for bidirectional collections.

stdlib/public/core/Indices.swift.gyb

@@ -107,7 +107,11 @@ public struct ${Self}<
   internal var _endIndex: Elements.Index
 }
 
-extension ${collectionForTraversal(Traversal)} where Indices == ${Self}<Self> {
+extension ${collectionForTraversal(Traversal)}
+%     if Traversal != 'RandomAccess':
+  where Indices == ${Self}<Self>
+%     end
+{
   /// The indices that are valid for subscripting the collection, in ascending
   /// order.
   ///

stdlib/public/core/RandomAccessCollection.swift

@@ -81,6 +81,29 @@ public protocol RandomAccessCollection :
   ///     }
   ///     // c == MyFancyCollection([2, 4, 6, 8, 10])
   var indices: Indices { get }
+
+  /// Accesses a contiguous subrange of the collection's elements.
+  ///
+  /// The accessed slice uses the same indices for the same elements as the
+  /// original collection uses. Always use the slice's `startIndex` property
+  /// instead of assuming that its indices start at a particular value.
+  ///
+  /// This example demonstrates getting a slice of an array of strings, finding
+  /// the index of one of the strings in the slice, and then using that index
+  /// in the original array.
+  ///
+  ///     let streets = ["Adams", "Bryant", "Channing", "Douglas", "Evarts"]
+  ///     let streetsSlice = streets[2 ..< streets.endIndex]
+  ///     print(streetsSlice)
+  ///     // Prints "["Channing", "Douglas", "Evarts"]"
+  ///
+  ///     let index = streetsSlice.index(of: "Evarts")    // 4
+  ///     print(streets[index!])
+  ///     // Prints "Evarts"
+  ///
+  /// - Parameter bounds: A range of the collection's indices. The bounds of
+  ///   the range must be valid indices of the collection.
+  subscript(bounds: Range<Index>) -> SubSequence { get }
 }
 
 /// Supply the default "slicing" `subscript` for `RandomAccessCollection`

test/Generics/associated_types.swift

@@ -160,17 +160,23 @@ protocol A {
 }
 
 protocol B : A {
-  associatedtype e : A = C<Self> // expected-note {{default type 'C<C<a>>' for associated type 'e' (from protocol 'B') does not conform to 'A'}}
+  associatedtype e : A = C<Self>
 }
 
 extension B {
   func c() {
   }
 }
 
-struct C<a : B> : B { // expected-error {{type 'C<a>' does not conform to protocol 'B'}}
+struct C<a : B> : B {
 }
 
+struct CC : B {
+  typealias e = CC
+}
+
+C<CC>().c()
+
 // SR-511
 protocol sr511 {
   typealias Foo // expected-error {{typealias is missing an assigned type; use 'associatedtype' to define an associated type requirement}}