[CS] NFC: Rename PackEnvironments -> PackElementExpansions

IMO "environment" is confusable for GenericEnvironment,
make it clearer it's referring to the parent
PackExpansionExpr.

Author: hamishknight

include/swift/Sema/CSTrail.def

@@ -95,7 +95,7 @@ CHANGE(AddedConversionRestriction)
 CHANGE(AddedFix)
 CHANGE(AddedFixedRequirement)
 CHANGE(RecordedOpenedPackExpansionType)
-CHANGE(RecordedPackEnvironment)
+CHANGE(RecordedPackElementExpansion)
 CHANGE(RecordedNodeType)
 CHANGE(RecordedKeyPathComponentType)
 CHANGE(RecordedResultBuilderTransform)
@@ -118,4 +118,4 @@ LAST_CHANGE(RetractedBinding)
 #undef BINDING_RELATION_CHANGE
 #undef SCORE_CHANGE
 #undef LAST_CHANGE
-#undef CHANGE
+#undef CHANGE

include/swift/Sema/CSTrail.h

@@ -213,7 +213,7 @@ class SolverTrail {
 
     /// Create a change that recorded a mapping from a pack element expression
     /// to its parent expansion expression.
-    static Change RecordedPackEnvironment(PackElementExpr *packElement);
+    static Change RecordedPackElementExpansion(PackElementExpr *packElement);
 
     /// Create a change that recorded an assignment of a type to an AST node.
     static Change RecordedNodeType(ASTNode node, Type oldType);
@@ -307,4 +307,4 @@ class SolverTrail {
 } // namespace constraints
 } // namespace swift
 
-#endif // SWIFT_SEMA_CSTRAIL_H
+#endif // SWIFT_SEMA_CSTRAIL_H

include/swift/Sema/ConstraintSystem.h

@@ -1565,9 +1565,8 @@ class Solution {
   llvm::DenseMap<ConstraintLocator *, std::pair<UUID, Type>>
       PackExpansionEnvironments;
 
-  /// The pack expansion environment that can open a given pack element.
-  llvm::DenseMap<PackElementExpr *, PackExpansionExpr *>
-      PackEnvironments;
+  /// The pack expansion expression for a given pack element.
+  llvm::DenseMap<PackElementExpr *, PackExpansionExpr *> PackElementExpansions;
 
   /// The locators of \c Defaultable constraints whose defaults were used.
   llvm::DenseSet<ConstraintLocator *> DefaultedConstraints;
@@ -2412,7 +2411,7 @@ class ConstraintSystem {
       PackExpansionEnvironments;
 
   llvm::SmallDenseMap<PackElementExpr *, PackExpansionExpr *, 2>
-      PackEnvironments;
+      PackElementExpansions;
 
   llvm::SmallVector<GenericEnvironment *, 4> PackElementGenericEnvironments;
 
@@ -3379,17 +3378,18 @@ class ConstraintSystem {
   void recordPackExpansionEnvironment(ConstraintLocator *locator,
                                       std::pair<UUID, Type> uuidAndShape);
 
-  /// Get the opened element generic environment for the given pack element.
-  PackExpansionExpr *getPackEnvironment(PackElementExpr *packElement) const;
+  /// Get the pack expansion expr for the given pack element.
+  PackExpansionExpr *
+  getPackElementExpansion(PackElementExpr *packElement) const;
 
-  /// Associate an opened element generic environment to a pack element,
-  /// and record a change in the trail.
-  void addPackEnvironment(PackElementExpr *packElement,
-                          PackExpansionExpr *packExpansion);
+  /// Associate a pack element with a given pack expansion, and record the
+  /// change in the trail.
+  void recordPackElementExpansion(PackElementExpr *packElement,
+                                  PackExpansionExpr *packExpansion);
 
   /// Undo the above change.
-  void removePackEnvironment(PackElementExpr *packElement) {
-    bool erased = PackEnvironments.erase(packElement);
+  void removePackElementExpansion(PackElementExpr *packElement) {
+    bool erased = PackElementExpansions.erase(packElement);
     ASSERT(erased);
   }
 

lib/Sema/CSGen.cpp

@@ -902,10 +902,10 @@ TypeVarRefCollector::walkToExprPre(Expr *expr) {
   }
 
   if (auto *packElement = getAsExpr<PackElementExpr>(expr)) {
-    // If environment hasn't been established yet, it means that pack expansion
+    // If expansion hasn't been established yet, it means that pack expansion
     // appears inside of this closure.
-    if (auto *outerEnvironment = CS.getPackEnvironment(packElement))
-      inferTypeVars(outerEnvironment);
+    if (auto *outerExpansion = CS.getPackElementExpansion(packElement))
+      inferTypeVars(outerExpansion);
   }
 
   return Action::Continue(expr);
@@ -1214,9 +1214,8 @@ namespace {
       SmallVector<ASTNode, 2> expandedPacks;
       collectExpandedPacks(expr, expandedPacks);
       for (auto pack : expandedPacks) {
-        if (auto *elementExpr = getAsExpr<PackElementExpr>(pack)) {
-          CS.addPackEnvironment(elementExpr, expr);
-        }
+        if (auto *elementExpr = getAsExpr<PackElementExpr>(pack))
+          CS.recordPackElementExpansion(elementExpr, expr);
       }
 
       auto *patternLoc = CS.getConstraintLocator(
@@ -3239,15 +3238,15 @@ namespace {
 
     Type visitPackElementExpr(PackElementExpr *expr) {
       auto packType = CS.getType(expr->getPackRefExpr());
-      auto *packEnvironment = CS.getPackEnvironment(expr);
+      auto *packExpansion = CS.getPackElementExpansion(expr);
       auto elementType = openPackElement(
-          packType, CS.getConstraintLocator(expr), packEnvironment);
-      if (packEnvironment) {
+          packType, CS.getConstraintLocator(expr), packExpansion);
+      if (packExpansion) {
         auto expansionType =
-            CS.getType(packEnvironment)->castTo<PackExpansionType>();
+            CS.getType(packExpansion)->castTo<PackExpansionType>();
         CS.addConstraint(ConstraintKind::ShapeOf, expansionType->getCountType(),
                          packType,
-                         CS.getConstraintLocator(packEnvironment,
+                         CS.getConstraintLocator(packExpansion,
                                                  ConstraintLocator::PackShape));
       } else {
         CS.recordFix(AllowInvalidPackReference::create(

lib/Sema/CSSolver.cpp

@@ -256,8 +256,8 @@ Solution ConstraintSystem::finalize() {
     solution.PackExpansionEnvironments.insert(env);
   }
 
-  for (const auto &packEnv : PackEnvironments)
-    solution.PackEnvironments.insert(packEnv);
+  for (const auto &packEnv : PackElementExpansions)
+    solution.PackElementExpansions.insert(packEnv);
 
   for (const auto &synthesized : SynthesizedConformances) {
     solution.SynthesizedConformances.insert(synthesized);
@@ -355,10 +355,10 @@ void ConstraintSystem::replaySolution(const Solution &solution,
       recordPackExpansionEnvironment(expansion.first, expansion.second);
   }
 
-  // Register the solutions's pack environments.
-  for (auto &packEnvironment : solution.PackEnvironments) {
-    if (PackEnvironments.count(packEnvironment.first) == 0)
-      addPackEnvironment(packEnvironment.first, packEnvironment.second);
+  // Register the solutions's pack expansions.
+  for (auto &packEnvironment : solution.PackElementExpansions) {
+    if (PackElementExpansions.count(packEnvironment.first) == 0)
+      recordPackElementExpansion(packEnvironment.first, packEnvironment.second);
   }
 
   // Register the defaulted type variables.

lib/Sema/CSSyntacticElement.cpp

@@ -188,8 +188,8 @@ class TypeVariableRefFinder : public ASTWalker {
     // that reference pack elements have to bring expansion's shape
     // type in scope to make sure that the shapes match.
     if (auto *packElement = getAsExpr<PackElementExpr>(expr)) {
-      if (auto *outerEnvironment = CS.getPackEnvironment(packElement)) {
-        auto *expansionTy = CS.simplifyType(CS.getType(outerEnvironment))
+      if (auto *outerExpansion = CS.getPackElementExpansion(packElement)) {
+        auto *expansionTy = CS.simplifyType(CS.getType(outerExpansion))
                                 ->castTo<PackExpansionType>();
         expansionTy->getCountType()->getTypeVariables(ReferencedVars);
       }

lib/Sema/CSTrail.cpp

@@ -191,10 +191,10 @@ SolverTrail::Change::RecordedOpenedPackExpansionType(PackExpansionType *expansio
   return result;
 }
 
-SolverTrail::Change
-SolverTrail::Change::RecordedPackEnvironment(PackElementExpr *packElement) {
+SolverTrail::Change SolverTrail::Change::RecordedPackElementExpansion(
+    PackElementExpr *packElement) {
   Change result;
-  result.Kind = ChangeKind::RecordedPackEnvironment;
+  result.Kind = ChangeKind::RecordedPackElementExpansion;
   result.TheElement = packElement;
   return result;
 }
@@ -426,8 +426,8 @@ void SolverTrail::Change::undo(ConstraintSystem &cs) const {
     cs.removeOpenedPackExpansionType(TheExpansion);
     break;
 
-  case ChangeKind::RecordedPackEnvironment:
-    cs.removePackEnvironment(TheElement);
+  case ChangeKind::RecordedPackElementExpansion:
+    cs.removePackElementExpansion(TheElement);
     break;
 
   case ChangeKind::RecordedNodeType:
@@ -694,9 +694,9 @@ void SolverTrail::Change::dump(llvm::raw_ostream &out,
     out << ")\n";
     break;
 
-  case ChangeKind::RecordedPackEnvironment:
+  case ChangeKind::RecordedPackElementExpansion:
     // FIXME: Print short form of PackExpansionExpr
-    out << "(RecordedPackEnvironment ";
+    out << "(RecordedPackElementExpansion ";
     simple_display(out, TheElement);
     out << "\n";
     break;
@@ -971,4 +971,4 @@ void SolverTrail::dump(raw_ostream &OS, unsigned fromIndex,
                        unsigned indent) const {
   for (unsigned i = fromIndex; i < Changes.size(); ++i)
     Changes[i].dump(OS, CS, indent);
-}
+}

lib/Sema/ConstraintSystem.cpp

@@ -918,18 +918,21 @@ void ConstraintSystem::recordPackExpansionEnvironment(
 }
 
 PackExpansionExpr *
-ConstraintSystem::getPackEnvironment(PackElementExpr *packElement) const {
-  const auto match = PackEnvironments.find(packElement);
-  return (match == PackEnvironments.end()) ? nullptr : match->second;
+ConstraintSystem::getPackElementExpansion(PackElementExpr *packElement) const {
+  const auto match = PackElementExpansions.find(packElement);
+  return (match == PackElementExpansions.end()) ? nullptr : match->second;
 }
 
-void ConstraintSystem::addPackEnvironment(PackElementExpr *packElement,
-                                          PackExpansionExpr *packExpansion) {
-  bool inserted = PackEnvironments.insert({packElement, packExpansion}).second;
+void ConstraintSystem::recordPackElementExpansion(
+    PackElementExpr *packElement, PackExpansionExpr *packExpansion) {
+  bool inserted =
+      PackElementExpansions.insert({packElement, packExpansion}).second;
   ASSERT(inserted);
 
-  if (solverState)
-    recordChange(SolverTrail::Change::RecordedPackEnvironment(packElement));
+  if (solverState) {
+    recordChange(
+        SolverTrail::Change::RecordedPackElementExpansion(packElement));
+  }
 }
 
 /// Extend the given depth map by adding depths for all of the subexpressions
@@ -1916,6 +1919,7 @@ size_t Solution::getTotalMemory() const {
   if (TotalMemory)
     return *TotalMemory;
 
+  // clang-format off
   const_cast<Solution *>(this)->TotalMemory
        = sizeof(*this) + size_in_bytes(typeBindings) +
          overloadChoices.getMemorySize() +
@@ -1925,7 +1929,7 @@ size_t Solution::getTotalMemory() const {
          OpenedTypes.getMemorySize() + OpenedExistentialTypes.getMemorySize() +
          OpenedPackExpansionTypes.getMemorySize() +
          PackExpansionEnvironments.getMemorySize() +
-         size_in_bytes(PackEnvironments) +
+         size_in_bytes(PackElementExpansions) +
          (DefaultedConstraints.size() * sizeof(void *)) +
          nodeTypes.getMemorySize() +
          keyPathComponentTypes.getMemorySize() +
@@ -1941,6 +1945,7 @@ size_t Solution::getTotalMemory() const {
          size_in_bytes(argumentLists) +
          size_in_bytes(ImplicitCallAsFunctionRoots) +
          size_in_bytes(SynthesizedConformances);
+  // clang-format on
 
   return *TotalMemory;
 }