Sema: Move some more code around

Author: slavapestov

lib/Sema/AssociatedTypeInference.cpp

@@ -47,6 +47,8 @@ STATISTIC(NumDuplicateSolutionStates,
 
 using namespace swift;
 
+namespace {
+
 /// Describes the result of checking a type witness.
 ///
 /// This class evaluates true if an error occurred.
@@ -201,6 +203,8 @@ checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
   return CheckTypeWitnessResult::forSuccess();
 }
 
+}
+
 static void recordTypeWitness(NormalProtocolConformance *conformance,
                               AssociatedTypeDecl *assocType,
                               Type type,
@@ -542,6 +546,8 @@ ResolveWitnessResult ConformanceChecker::resolveTypeWitnessViaLookup(
   return ResolveWitnessResult::ExplicitFailed;
 }
 
+namespace {
+
 /// The set of associated types that have been inferred by matching
 /// the given value witness to its corresponding requirement.
 struct InferredAssociatedTypesByWitness {
@@ -561,6 +567,8 @@ struct InferredAssociatedTypesByWitness {
   SWIFT_DEBUG_DUMP;
 };
 
+}
+
 void InferredAssociatedTypesByWitness::dump() const {
   dump(llvm::errs(), 0);
 }
@@ -602,42 +610,42 @@ using InferredAssociatedTypes =
     SmallVector<std::pair<ValueDecl *, InferredAssociatedTypesByWitnesses>, 4>;
 
 namespace {
-  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::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) LLVM_ATTRIBUTE_USED;
 
-  void dumpInferredAssociatedTypesByWitnesses(
-                          const InferredAssociatedTypesByWitnesses &inferred) {
-    dumpInferredAssociatedTypesByWitnesses(inferred, llvm::errs(), 0);
-  }
+void dumpInferredAssociatedTypesByWitnesses(
+                        const InferredAssociatedTypesByWitnesses &inferred) {
+  dumpInferredAssociatedTypesByWitnesses(inferred, llvm::errs(), 0);
+}
 
-  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 << ")";
-    }
+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) LLVM_ATTRIBUTE_USED;
 
-  void dumpInferredAssociatedTypes(const InferredAssociatedTypes &inferred) {
-    dumpInferredAssociatedTypes(inferred, llvm::errs(), 0);
-  }
+void dumpInferredAssociatedTypes(const InferredAssociatedTypes &inferred) {
+  dumpInferredAssociatedTypes(inferred, llvm::errs(), 0);
 }
 
 /// A conflict between two inferred type witnesses for the same
@@ -739,8 +747,137 @@ void InferredTypeWitnessesSolution::dump() const {
   }
 }
 
+/// A system for recording and probing the integrity of a type witness solution
+/// for a set of unresolved associated type declarations.
+///
+/// Right now can reason only about abstract type witnesses, i.e., same-type
+/// constraints, default type definitions, and bindings to generic parameters.
+class TypeWitnessSystem final {
+  /// Equivalence classes are used on demand to express equivalences between
+  /// witness candidates and reflect changes to resolved types across their
+  /// members.
+  class EquivalenceClass final {
+    /// The pointer:
+    /// - The resolved type for witness candidates belonging to this equivalence
+    ///   class. The resolved type may be a type parameter, but cannot directly
+    ///   pertain to a name variable in the owning system; instead, witness
+    ///   candidates that should resolve to the same type share an equivalence
+    ///   class.
+    /// The int:
+    /// - A flag indicating whether the resolved type is ambiguous. When set,
+    ///   the resolved type is null.
+    llvm::PointerIntPair<Type, 1, bool> ResolvedTyAndIsAmbiguous;
+
+  public:
+    EquivalenceClass(Type ty) : ResolvedTyAndIsAmbiguous(ty, false) {}
+
+    EquivalenceClass(const EquivalenceClass &) = delete;
+    EquivalenceClass(EquivalenceClass &&) = delete;
+    EquivalenceClass &operator=(const EquivalenceClass &) = delete;
+    EquivalenceClass &operator=(EquivalenceClass &&) = delete;
+
+    Type getResolvedType() const {
+      return ResolvedTyAndIsAmbiguous.getPointer();
+    }
+    void setResolvedType(Type ty);
+
+    bool isAmbiguous() const {
+      return ResolvedTyAndIsAmbiguous.getInt();
+    }
+    void setAmbiguous() {
+      ResolvedTyAndIsAmbiguous = {nullptr, true};
+    }
+  };
+
+  /// A type witness candidate for a name variable.
+  struct TypeWitnessCandidate final {
+    /// The defaulted associated type declaration correlating with this
+    /// candidate, if present.
+    AssociatedTypeDecl *DefaultedAssocType;
+
+    /// The equivalence class of this candidate.
+    EquivalenceClass *EquivClass;
+  };
+
+  /// The set of equivalence classes in the system.
+  llvm::SmallPtrSet<EquivalenceClass *, 4> EquivalenceClasses;
+
+  /// The mapping from name variables (the names of unresolved associated
+  /// type declarations) to their corresponding type witness candidates.
+  llvm::SmallDenseMap<Identifier, TypeWitnessCandidate, 4> TypeWitnesses;
+
+public:
+  TypeWitnessSystem(ArrayRef<AssociatedTypeDecl *> assocTypes);
+  ~TypeWitnessSystem();
+
+  TypeWitnessSystem(const TypeWitnessSystem &) = delete;
+  TypeWitnessSystem(TypeWitnessSystem &&) = delete;
+  TypeWitnessSystem &operator=(const TypeWitnessSystem &) = delete;
+  TypeWitnessSystem &operator=(TypeWitnessSystem &&) = delete;
+
+  /// Get the resolved type witness for the associated type with the given name.
+  Type getResolvedTypeWitness(Identifier name) const;
+  bool hasResolvedTypeWitness(Identifier name) const;
+
+  /// Get the defaulted associated type relating to the resolved type witness
+  /// for the associated type with the given name, if present.
+  AssociatedTypeDecl *getDefaultedAssocType(Identifier name) const;
+
+  /// Record a type witness for the given associated type name.
+  ///
+  /// \note This need not lead to the resolution of a type witness, e.g.
+  /// an associated type may be defaulted to another.
+  void addTypeWitness(Identifier name, Type type);
+
+  /// Record a default type witness.
+  ///
+  /// \param defaultedAssocType The specific associated type declaration that
+  /// defines the given default type.
+  ///
+  /// \note This need not lead to the resolution of a type witness.
+  void addDefaultTypeWitness(Type type, AssociatedTypeDecl *defaultedAssocType);
+
+  /// Record the given same-type requirement, if regarded of interest to
+  /// the system.
+  ///
+  /// \note This need not lead to the resolution of a type witness.
+  void addSameTypeRequirement(const Requirement &req);
+
+  void dump(llvm::raw_ostream &out,
+            const NormalProtocolConformance *conformance) const;
+
+private:
+  /// Form an equivalence between the given name variables.
+  void addEquivalence(Identifier name1, Identifier name2);
+
+  /// Merge \p equivClass2 into \p equivClass1.
+  ///
+  /// \note This will delete \p equivClass2 after migrating its members to
+  /// \p equivClass1.
+  void mergeEquivalenceClasses(EquivalenceClass *equivClass1,
+                               const EquivalenceClass *equivClass2);
+
+  /// The result of comparing two resolved types targeting a single equivalence
+  /// class, in terms of their relative impact on solving the system.
+  enum class ResolvedTypeComparisonResult {
+    /// The first resolved type is a better choice than the second one.
+    Better,
+
+    /// The first resolved type is an equivalent or worse choice than the
+    /// second one.
+    EquivalentOrWorse,
+
+    /// Both resolved types are concrete and mutually exclusive.
+    Ambiguity
+  };
+
+  /// Compare the given resolved types as targeting a single equivalence class,
+  /// in terms of the their relative impact on solving the system.
+  static ResolvedTypeComparisonResult compareResolvedTypes(Type ty1, Type ty2);
+};
+
 /// Captures the state needed to infer associated types.
-class swift::AssociatedTypeInference {
+class AssociatedTypeInference {
   /// The type checker we'll need to validate declarations etc.
   ASTContext &ctx;
 
@@ -929,6 +1066,8 @@ class swift::AssociatedTypeInference {
   llvm::Optional<InferredTypeWitnesses> solve(ConformanceChecker &checker);
 };
 
+}
+
 AssociatedTypeInference::AssociatedTypeInference(
     ASTContext &ctx, NormalProtocolConformance *conformance)
     : ctx(ctx), conformance(conformance), proto(conformance->getProtocol()),
@@ -1622,8 +1761,8 @@ Type swift::adjustInferredAssociatedType(TypeAdjustment adjustment, Type type,
   return type;
 }
 
-AssociatedTypeDecl *
-swift::getReferencedAssocTypeOfProtocol(Type type, ProtocolDecl *proto) {
+static AssociatedTypeDecl *
+getReferencedAssocTypeOfProtocol(Type type, ProtocolDecl *proto) {
   if (auto dependentMember = type->getAs<DependentMemberType>()) {
     if (auto assocType = dependentMember->getAssocType()) {
       if (dependentMember->getBase()->isEqual(proto->getSelfInterfaceType())) {
@@ -1865,10 +2004,10 @@ AssociatedTypeInference::computeDefaultTypeWitness(
   return AbstractTypeWitness(assocType, defaultType, defaultedAssocType);
 }
 
-std::pair<Type, TypeDecl *>
-TypeChecker::deriveTypeWitness(DeclContext *DC,
-                               NominalTypeDecl *TypeDecl,
-                               AssociatedTypeDecl *AssocType) {
+static std::pair<Type, TypeDecl *>
+deriveTypeWitness(DeclContext *DC,
+                  NominalTypeDecl *TypeDecl,
+                  AssociatedTypeDecl *AssocType) {
   auto *protocol = cast<ProtocolDecl>(AssocType->getDeclContext());
 
   auto knownKind = protocol->getKnownProtocolKind();
@@ -1913,7 +2052,7 @@ AssociatedTypeInference::computeDerivedTypeWitness(
     return std::make_pair(Type(), nullptr);
 
   // Try to derive the type witness.
-  auto result = TypeChecker::deriveTypeWitness(dc, derivingTypeDecl, assocType);
+  auto result = deriveTypeWitness(dc, derivingTypeDecl, assocType);
   if (!result.first)
     return std::make_pair(Type(), nullptr);