[NFC] Thread a common type through all the AST substitution code.

There are a lot of problems caused by our highly-abstract substitution
subsystem.  Most of them would be solved by a more semantic / holistic
understanding of the active transformation, but that's difficult to do
because we just pass around function_refs.  The first step in fixing
that is to pass around a better currency type.  For now, it can just
hold the function_refs (and the SubstOptions).

I've set it up so that the places that just apply SubstitutionMaps
are constructing the IFS in a standard way; that should make it easy
to change those places in the future.

Author: rjmccall

include/swift/AST/InFlightSubstitution.h

@@ -0,0 +1,88 @@
+//===--- InFlightSubstitution.h - In-flight substitution data ---*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the InFlightSubstitution structure, which captures
+// all the information about a type substitution that's currently in
+// progress.  For now, this is meant to be an internal implementation
+// detail of the substitution system, and other systems should not use
+// it (unless they are part of the extended substitution system, such as
+// the SIL type substituter)
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_INFLIGHTSUBSTITUTION_H
+#define SWIFT_AST_INFLIGHTSUBSTITUTION_H
+
+#include "swift/AST/SubstitutionMap.h"
+
+namespace swift {
+class SubstitutionMap;
+
+class InFlightSubstitution {
+  SubstOptions Options;
+  TypeSubstitutionFn BaselineSubstType;
+  LookupConformanceFn BaselineLookupConformance;
+
+public:
+  InFlightSubstitution(TypeSubstitutionFn substType,
+                       LookupConformanceFn lookupConformance,
+                       SubstOptions options)
+    : Options(options),
+      BaselineSubstType(substType),
+      BaselineLookupConformance(lookupConformance) {}
+
+  InFlightSubstitution(const InFlightSubstitution &) = delete;
+  InFlightSubstitution &operator=(const InFlightSubstitution &) = delete;
+
+  Type substType(SubstitutableType *ty) {
+    return BaselineSubstType(ty);
+  }
+
+  ProtocolConformanceRef lookupConformance(CanType dependentType,
+                                           Type conformingReplacementType,
+                                           ProtocolDecl *conformedProtocol) {
+    return BaselineLookupConformance(dependentType,
+                                     conformingReplacementType,
+                                     conformedProtocol);
+  }
+
+  SubstOptions getOptions() const {
+    return Options;
+  }
+
+  /// Is the given type invariant to substitution?
+  bool isInvariant(Type type) const;
+};
+
+/// A helper classes that provides stable storage for the query
+/// functions against a SubstitutionMap.
+struct InFlightSubstitutionViaSubMapHelper {
+  QuerySubstitutionMap QueryType;
+  LookUpConformanceInSubstitutionMap QueryConformance;
+
+  InFlightSubstitutionViaSubMapHelper(SubstitutionMap subMap)
+    : QueryType{subMap}, QueryConformance(subMap) {}
+};
+class InFlightSubstitutionViaSubMap :
+  private InFlightSubstitutionViaSubMapHelper,
+  public InFlightSubstitution {
+
+public:
+  InFlightSubstitutionViaSubMap(SubstitutionMap subMap,
+                                SubstOptions options)
+    : InFlightSubstitutionViaSubMapHelper(subMap),
+      InFlightSubstitution(QueryType, QueryConformance, options) {}
+};
+
+} // end namespace swift
+
+#endif

include/swift/AST/PackConformance.h

@@ -88,6 +88,13 @@ class alignas(1 << DeclAlignInBits) PackConformance final
                                LookupConformanceFn conformances,
                                SubstOptions options=None) const;
 
+  /// Apply an in-flight substitution to the conformances in this
+  /// protocol conformance ref.
+  ///
+  /// This function should generally not be used outside of the
+  /// substitution subsystem.
+  ProtocolConformanceRef subst(InFlightSubstitution &IFS) const;
+
   SWIFT_DEBUG_DUMP;
   void dump(llvm::raw_ostream &out, unsigned indent = 0) const;
 };

include/swift/AST/ProtocolConformance.h

@@ -309,6 +309,13 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance
                              LookupConformanceFn conformances,
                              SubstOptions options=None) const;
 
+  /// Substitute the conforming type and produce a ProtocolConformance that
+  /// applies to the substituted type.
+  ///
+  /// This function should generally not be used outside of the substitution
+  /// subsystem.
+  ProtocolConformance *subst(InFlightSubstitution &IFS) const;
+
   SWIFT_DEBUG_DUMP;
   void dump(llvm::raw_ostream &out, unsigned indent = 0) const;
 };

include/swift/AST/ProtocolConformanceRef.h

@@ -164,6 +164,13 @@ class ProtocolConformanceRef {
                                LookupConformanceFn conformances,
                                SubstOptions options=None) const;
 
+  /// Apply a substitution to the conforming type.
+  ///
+  /// This function should generally not be used outside of the substitution
+  /// subsystem.
+  ProtocolConformanceRef subst(Type origType,
+                               InFlightSubstitution &IFS) const;
+
   /// Map contextual types to interface types in the conformance.
   ProtocolConformanceRef mapConformanceOutOfContext() const;
 

include/swift/AST/SubstitutionMap.h

@@ -121,6 +121,14 @@ class SubstitutionMap {
                              TypeSubstitutionFn subs,
                              LookupConformanceFn lookupConformance);
 
+  /// Build a substitution map from the substitutions represented by
+  /// the given in-flight substitution.
+  ///
+  /// This function should generally only be used by the substitution
+  /// subsystem.
+  static SubstitutionMap get(GenericSignature genericSig,
+                             InFlightSubstitution &IFS);
+
   /// Retrieve the generic signature describing the environment in which
   /// substitutions occur.
   GenericSignature getGenericSignature() const;
@@ -182,6 +190,13 @@ class SubstitutionMap {
                         LookupConformanceFn conformances,
                         SubstOptions options=None) const;
 
+  /// Apply an in-flight substitution to all replacement types in the map.
+  /// Does not change keys.
+  ///
+  /// This should generally not be used outside of the substitution
+  /// subsystem.
+  SubstitutionMap subst(InFlightSubstitution &subs) const;
+
   /// Apply type expansion lowering to all types in the substitution map. Opaque
   /// archetypes will be lowered to their underlying types if the type expansion
   /// context allows.

include/swift/AST/Type.h

@@ -43,6 +43,7 @@ class ClassDecl;
 class CanType;
 class EnumDecl;
 class GenericSignatureImpl;
+class InFlightSubstitution;
 class ModuleDecl;
 class NominalTypeDecl;
 class GenericTypeDecl;
@@ -343,6 +344,12 @@ class Type {
              LookupConformanceFn conformances,
              SubstOptions options=None) const;
 
+  /// Apply an in-flight substitution to this type.
+  ///
+  /// This should generally not be used outside of the substitution
+  /// subsystem.
+  Type subst(InFlightSubstitution &subs) const;
+
   bool isPrivateStdlibType(bool treatNonBuiltinProtocolsAsPublic = true) const;
 
   SWIFT_DEBUG_DUMP;

lib/AST/PackConformance.cpp

@@ -18,6 +18,7 @@
 #include "swift/AST/PackConformance.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
+#include "swift/AST/InFlightSubstitution.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/Types.h"
 
@@ -162,9 +163,8 @@ PackConformance *PackConformance::getAssociatedConformance(
 
 ProtocolConformanceRef PackConformance::subst(SubstitutionMap subMap,
                                               SubstOptions options) const {
-  return subst(QuerySubstitutionMap{subMap},
-               LookUpConformanceInSubstitutionMap(subMap),
-               options);
+  InFlightSubstitutionViaSubMap IFS(subMap, options);
+  return subst(IFS);
 }
 
 // TODO: Move this elsewhere since it's generally useful
@@ -206,14 +206,9 @@ namespace {
 template<typename ImplClass>
 class PackExpander {
 protected:
-  TypeSubstitutionFn subs;
-  LookupConformanceFn conformances;
-  SubstOptions options;
+  InFlightSubstitution &IFS;
 
-  PackExpander(TypeSubstitutionFn subs,
-               LookupConformanceFn conformances,
-               SubstOptions options)
-    : subs(subs), conformances(conformances), options(options) {}
+  PackExpander(InFlightSubstitution &IFS) : IFS(IFS) {}
 
   ImplClass *asImpl() {
     return static_cast<ImplClass *>(this);
@@ -233,7 +228,7 @@ class PackExpander {
     // the expanded count pack type.
     llvm::SmallDenseMap<Type, PackType *, 2> expandedPacks;
     for (auto origParamType : rootParameterPacks) {
-      auto substParamType = origParamType.subst(subs, conformances, options);
+      auto substParamType = origParamType.subst(IFS);
 
       if (auto expandedParamType = substParamType->template getAs<PackType>()) {
         assert(arePackShapesEqual(expandedParamType, expandedCountType) &&
@@ -262,7 +257,7 @@ class PackExpander {
         }
 
         // Compute the substituted type using our parent substitutions.
-        auto substType = Type(type).subst(subs, conformances, options);
+        auto substType = Type(type).subst(IFS);
 
         // If the substituted type is a pack, project the jth element.
         if (isRootParameterPack(type)) {
@@ -277,12 +272,13 @@ class PackExpander {
           return packType->getElementType(j);
         }
 
-        return subs(type);
+        return IFS.substType(type);
       };
 
       auto projectedConformances = [&](CanType origType, Type substType,
                                        ProtocolDecl *proto) -> ProtocolConformanceRef {
-        auto substConformance = conformances(origType, substType, proto);
+        auto substConformance =
+          IFS.lookupConformance(origType, substType, proto);
 
         // If the substituted conformance is a pack, project the jth element.
         if (isRootedInParameterPack(origType)) {
@@ -294,7 +290,7 @@ class PackExpander {
 
       auto origCountElement = expandedCountType->getElementType(j);
       auto substCountElement = origCountElement.subst(
-          projectedSubs, projectedConformances, options);
+          projectedSubs, projectedConformances, IFS.getOptions());
 
       asImpl()->add(origCountElement, substCountElement, i);
     }
@@ -304,7 +300,7 @@ class PackExpander {
   /// form a new pack expansion.
   void addUnexpandedExpansion(Type origPatternType, Type substCountType,
                               unsigned i) {
-    auto substPatternType = origPatternType.subst(subs, conformances, options);
+    auto substPatternType = origPatternType.subst(IFS);
     auto substExpansion = PackExpansionType::get(substPatternType, substCountType);
 
     asImpl()->add(origPatternType, substExpansion, i);
@@ -313,7 +309,7 @@ class PackExpander {
   /// Scalar elements of the original pack are substituted and added to the
   /// flattened pack.
   void addScalar(Type origElement, unsigned i) {
-    auto substElement = origElement.subst(subs, conformances, options);
+    auto substElement = origElement.subst(IFS);
 
     asImpl()->add(origElement, substElement, i);
   }
@@ -323,7 +319,7 @@ class PackExpander {
     auto origPatternType = origExpansion->getPatternType();
     auto origCountType = origExpansion->getCountType();
 
-    auto substCountType = origCountType.subst(subs, conformances, options);
+    auto substCountType = origCountType.subst(IFS);
 
     // If the substituted count type is a pack, we're expanding the
     // original element.
@@ -358,19 +354,16 @@ class PackConformanceExpander : public PackExpander<PackConformanceExpander> {
 
   ArrayRef<ProtocolConformanceRef> origConformances;
 
-  PackConformanceExpander(TypeSubstitutionFn subs,
-                          LookupConformanceFn conformances,
-                          SubstOptions options,
+  PackConformanceExpander(InFlightSubstitution &IFS,
                           ArrayRef<ProtocolConformanceRef> origConformances)
-    : PackExpander(subs, conformances, options),
-      origConformances(origConformances) {}
+    : PackExpander(IFS), origConformances(origConformances) {}
 
   void add(Type origType, Type substType, unsigned i) {
     substElements.push_back(substType);
 
     // FIXME: Pass down projection callbacks
     substConformances.push_back(origConformances[i].subst(
-        origType, subs, conformances, options));
+        origType, IFS));
   }
 };
 
@@ -379,8 +372,13 @@ class PackConformanceExpander : public PackExpander<PackConformanceExpander> {
 ProtocolConformanceRef PackConformance::subst(TypeSubstitutionFn subs,
                                               LookupConformanceFn conformances,
                                               SubstOptions options) const {
-  PackConformanceExpander expander(subs, conformances, options,
-                                   getPatternConformances());
+  InFlightSubstitution IFS(subs, conformances, options);
+  return subst(IFS);
+}
+
+ProtocolConformanceRef
+PackConformance::subst(InFlightSubstitution &IFS) const {
+  PackConformanceExpander expander(IFS, getPatternConformances());
   expander.expand(ConformingType);
 
   auto &ctx = Protocol->getASTContext();