---

yaml
---
r: 349361
b: refs/heads/master-next
c: 226cd14
h: refs/heads/master
i:
  349359: 7e053a7

Author: swift-ci

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: 0337e5a130ef26bf4dfe49824e011b5e82e774a0
+refs/heads/master-next: 226cd140b9414cea26e4f43260502839f36bfae4
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/include/swift/Basic/CTypeIDZone.def

@@ -39,4 +39,4 @@ SWIFT_TYPEID_TEMPLATE1_NAMED(std::vector, Vector, typename T, T)
 
 // LLVM ADT types.
 SWIFT_TYPEID_TEMPLATE1_NAMED(llvm::TinyPtrVector, TinyPtrVector, typename T, T)
-SWIFT_TYPEID_TEMPLATE1_NAMED(llvm::ArrayRef, ArrayRef, typename T, T)
+SWIFT_TYPEID_TEMPLATE1_NAMED(llvm::ArrayRef, ArrayRef, typename T, T)

branches/master-next/lib/Sema/CSStep.cpp

@@ -96,27 +96,14 @@ void SplitterStep::computeFollowupSteps(
   CG.optimize();
 
   // Compute the connected components of the constraint graph.
-  // FIXME: We're seeding typeVars with TypeVariables so that the
-  // connected-components algorithm only considers those type variables within
-  // our component. There are clearly better ways to do this.
-  std::vector<TypeVariableType *> typeVars(CS.TypeVariables);
-  std::vector<unsigned> components;
-  unsigned numComponents = CG.computeConnectedComponents(typeVars, components);
+  auto components = CG.computeConnectedComponents(CS.TypeVariables);
+  unsigned numComponents = components.size();
   if (numComponents < 2) {
     componentSteps.push_back(llvm::make_unique<ComponentStep>(
-        CS, 0, /*single=*/true, &CS.InactiveConstraints, Solutions));
+        CS, 0, &CS.InactiveConstraints, Solutions));
     return;
   }
 
-  Components.resize(numComponents);
-  PartialSolutions = std::unique_ptr<SmallVector<Solution, 4>[]>(
-      new SmallVector<Solution, 4>[numComponents]);
-
-  for (unsigned i = 0, n = numComponents; i != n; ++i) {
-    componentSteps.push_back(llvm::make_unique<ComponentStep>(
-        CS, i, /*single=*/false, &Components[i], PartialSolutions[i]));
-  }
-
   if (isDebugMode()) {
     auto &log = getDebugLogger();
     // Verify that the constraint graph is valid.
@@ -129,66 +116,20 @@ void SplitterStep::computeFollowupSteps(
     CG.printConnectedComponents(CS.TypeVariables, log);
   }
 
-  // Map type variables and constraints into appropriate steps.
-  llvm::DenseMap<TypeVariableType *, unsigned> typeVarComponent;
-  llvm::DenseMap<Constraint *, unsigned> constraintComponent;
-  for (unsigned i = 0, n = typeVars.size(); i != n; ++i) {
-    auto *typeVar = typeVars[i];
-    // Record the component of this type variable.
-    typeVarComponent[typeVar] = components[i];
-
-    for (auto *constraint : CG[typeVar].getConstraints())
-      constraintComponent[constraint] = components[i];
-  }
-
-  // Add the orphaned components to the mapping from constraints to components.
-  unsigned firstOrphanedComponent =
-      numComponents - CG.getOrphanedConstraints().size();
-  {
-    unsigned component = firstOrphanedComponent;
-    for (auto *constraint : CG.getOrphanedConstraints()) {
-      // Register this orphan constraint both as associated with
-      // a given component as a regular constrant, as well as an
-      // "orphan" constraint, so it can be proccessed correctly.
-      constraintComponent[constraint] = component;
-      componentSteps[component]->recordOrphan(constraint);
-      ++component;
-    }
-  }
+  // Take the orphaned constraints, because they'll go into a component now.
+  OrphanedConstraints = CG.takeOrphanedConstraints();
 
-  for (auto *typeVar : CS.TypeVariables) {
-    auto known = typeVarComponent.find(typeVar);
-    // If current type variable is associated with
-    // a certain component step, record it as being so.
-    if (known != typeVarComponent.end()) {
-      componentSteps[known->second]->record(typeVar);
-      continue;
-    }
-  }
+  Components.resize(numComponents);
+  PartialSolutions = std::unique_ptr<SmallVector<Solution, 4>[]>(
+      new SmallVector<Solution, 4>[numComponents]);
 
-  // Transfer all of the constraints from the work list to
-  // the appropriate component.
-  auto &workList = CS.InactiveConstraints;
-  while (!workList.empty()) {
-    auto *constraint = &workList.front();
-    workList.pop_front();
-    assert(constraintComponent.count(constraint) > 0 && "Missed a constraint");
-    componentSteps[constraintComponent[constraint]]->record(constraint);
+  // Add components.
+  for (unsigned i : indices(components)) {
+    unsigned solutionIndex = components[i].solutionIndex;
+    componentSteps.push_back(llvm::make_unique<ComponentStep>(
+        CS, solutionIndex, &Components[i], std::move(components[i]),
+        PartialSolutions[solutionIndex]));
   }
-
-  // Remove all of the orphaned constraints; they'll be re-introduced
-  // by each component independently.
-  OrphanedConstraints = CG.takeOrphanedConstraints();
-
-  // Create component ordering based on the information associated
-  // with constraints in each step - e.g. number of disjunctions,
-  // since components are going to be executed in LIFO order, we'd
-  // want to have smaller/faster components at the back of the list.
-  std::sort(componentSteps.begin(), componentSteps.end(),
-            [](const std::unique_ptr<ComponentStep> &lhs,
-               const std::unique_ptr<ComponentStep> &rhs) {
-              return lhs->disjunctionCount() > rhs->disjunctionCount();
-            });
 }
 
 bool SplitterStep::mergePartialSolutions() const {

branches/master-next/lib/Sema/CSStep.h

@@ -19,6 +19,7 @@
 #define SWIFT_SEMA_CSSTEP_H
 
 #include "Constraint.h"
+#include "ConstraintGraph.h"
 #include "ConstraintSystem.h"
 #include "swift/AST/Types.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -336,50 +337,50 @@ class ComponentStep final : public SolverStep {
   std::unique_ptr<Scope> ComponentScope = nullptr;
 
   /// Type variables and constraints "in scope" of this step.
-  std::vector<TypeVariableType *> TypeVars;
+  TinyPtrVector<TypeVariableType *> TypeVars;
   /// Constraints "in scope" of this step.
   ConstraintList *Constraints;
 
-  /// Number of disjunction constraints associated with this step,
-  /// used to aid in ordering of the components.
-  unsigned NumDisjunctions = 0;
-
   /// Constraint which doesn't have any free type variables associated
   /// with it, which makes it disconnected in the graph.
   Constraint *OrphanedConstraint = nullptr;
 
 public:
-  ComponentStep(ConstraintSystem &cs, unsigned index, bool single,
+  /// Create a single component step.
+  ComponentStep(ConstraintSystem &cs, unsigned index,
                 ConstraintList *constraints,
                 SmallVectorImpl<Solution> &solutions)
-      : SolverStep(cs, solutions), Index(index), IsSingle(single),
+      : SolverStep(cs, solutions), Index(index), IsSingle(true),
         OriginalScore(getCurrentScore()), OriginalBestScore(getBestScore()),
         Constraints(constraints) {}
 
-  /// Record a type variable as associated with this step.
-  void record(TypeVariableType *typeVar) { TypeVars.push_back(typeVar); }
+  /// Create a component step from a constraint graph component.
+  ComponentStep(ConstraintSystem &cs, unsigned index,
+                ConstraintList *constraints,
+                ConstraintGraph::Component &&component,
+                SmallVectorImpl<Solution> &solutions)
+      : SolverStep(cs, solutions), Index(index), IsSingle(false),
+        OriginalScore(getCurrentScore()), OriginalBestScore(getBestScore()),
+        Constraints(constraints) {
+    if (component.isOrphaned()) {
+      assert(component.getConstraints().size() == 1);
+      OrphanedConstraint = component.getConstraints().front();
+    } else {
+      assert(component.typeVars.size() > 0);
+    }
 
-  /// Record a constraint as associated with this step.
-  void record(Constraint *constraint) {
-    Constraints->push_back(constraint);
-    if (constraint->getKind() == ConstraintKind::Disjunction)
-      ++NumDisjunctions;
-  }
+    TypeVars = std::move(component.typeVars);
 
-  /// Record a constraint as associated with this step but which doesn't
-  /// have any free type variables associated with it.
-  void recordOrphan(Constraint *constraint) {
-    assert(!OrphanedConstraint);
-    OrphanedConstraint = constraint;
+    for (auto constraint : component.getConstraints()) {
+      constraints->erase(constraint);
+      Constraints->push_back(constraint);
+    }
   }
 
   StepResult take(bool prevFailed) override;
 
   StepResult resume(bool prevFailed) override { return finalize(!prevFailed); }
 
-  // The number of disjunction constraints associated with this component.
-  unsigned disjunctionCount() const { return NumDisjunctions; }
-
   void print(llvm::raw_ostream &Out) override {
     Out << "ComponentStep with at #" << Index << '\n';
   }
@@ -395,7 +396,8 @@ class ComponentStep final : public SolverStep {
       getDebugLogger() << "(solving component #" << Index << '\n';
 
     ComponentScope = llvm::make_unique<Scope>(*this);
-    // If this component has oprhaned constraint attached,
+
+    // If this component has orphaned constraint attached,
     // let's return it to the graph.
     CS.CG.setOrphanedConstraint(OrphanedConstraint);
   }