Don't rerun mandatory lowering passes on deserialized SIL.

Author: atrick

lib/SILOptimizer/Analysis/ClosureScope.cpp

@@ -91,6 +91,15 @@ class ClosureScopeData {
     auto scopeFunc = PAI->getFunction();
     int scopeIdx = lookupScopeIndex(scopeFunc);
 
+    // Passes may assume that a deserialized function can only refer to
+    // deserialized closures. For example, AccessEnforcementSelection skips
+    // deserialized functions but assumes all a closure's parent scope have been
+    // processed.
+    assert(scopeFunc->wasDeserializedCanonical()
+           == closureFunc->wasDeserializedCanonical() &&
+           "A closure cannot be serialized in a different module than its "
+           "parent context");
+
     auto &indices = closureToScopesMap[closureFunc];
     if (std::find(indices.begin(), indices.end(), scopeIdx) != indices.end())
       return;

lib/SILOptimizer/Mandatory/AccessEnforcementSelection.cpp

@@ -13,19 +13,19 @@
 /// This pass eliminates 'unknown' access enforcement by selecting either
 /// static or dynamic enforcement.
 ///
-/// TODO: This is currently a module transform so that closures can be
-/// transformed after their parent scope is analyzed. This isn't a big problem
-/// now because AccessMarkerElimination is also a module pass that follows this
-/// pass. However, we would like to mostly eliminate module transforms. This
-/// could be done by changing the PassManager to follow CloseScopeAnalysis. A
-/// new ClosureTransform type would be pipelined just like FunctionTransform,
-/// but would have an entry point that handled a parent closure scope and all
-/// its children in one invocation. For function pipelining to be upheld, we
-/// would need to verify that BasicCalleeAnalysis never conflicts with
-/// ClosureScopeAnalysis. i.e. we could never create a caller->callee edge when
-/// the callee is passed as a function argument. Normal FunctionTransforms would
-/// then be called on each closure function and its parent scope before calling
-/// the ClosureTransform.
+/// TODO: This is currently a module transform so that it can process closures
+/// after analyzing their parent scope. This isn't a big problem now because
+/// AccessMarkerElimination is also a module pass that follows this pass, so all
+/// markers will still be present when this pass runs. However, we would like to
+/// mostly eliminate module transforms. This could be done by changing the
+/// PassManager to follow ClosureScopeAnalysis. A new ClosureTransform type
+/// would be pipelined just like FunctionTransform, but would have an entry
+/// point that handled a parent closure scope and all its children in one
+/// invocation. For function pipelining to be upheld, we would need to verify
+/// that BasicCalleeAnalysis never conflicts with ClosureScopeAnalysis. i.e. we
+/// could never create a caller->callee edge when the callee is passed as a
+/// function argument. Normal FunctionTransforms would then be called on each
+/// closure function and its parent scope before calling the ClosureTransform.
 ///
 /// FIXME: handle boxes used by copy_value when neither copy is captured.
 ///
@@ -521,6 +521,12 @@ struct SourceAccess {
 };
 
 /// The pass.
+///
+/// This can't be a SILFunctionTransform because DynamicCaptures need to be
+/// recorded while analyzing a closure's parent scopes before processing the
+/// closures.
+///
+/// TODO: Make this a "ClosureTransform". See the file-level comments above.
 class AccessEnforcementSelection : public SILModuleTransform {
   // Reference back to the known dynamically enforced non-escaping closure
   // arguments in this module. Parent scopes are processed before the closures
@@ -554,6 +560,12 @@ void AccessEnforcementSelection::run() {
 }
 
 void AccessEnforcementSelection::processFunction(SILFunction *F) {
+  if (F->wasDeserializedCanonical()) {
+    DEBUG(llvm::dbgs() << "Skipping Access Enforcement Selection of "
+                          "deserialized "
+                       << F->getName() << "\n");
+    return;
+  }
   DEBUG(llvm::dbgs() << "Access Enforcement Selection in " << F->getName()
                      << "\n");
 #ifndef NDEBUG

lib/SILOptimizer/Transforms/OwnershipModelEliminator.cpp

@@ -297,6 +297,10 @@ namespace {
 struct OwnershipModelEliminator : SILModuleTransform {
   void run() override {
     for (auto &F : *getModule()) {
+      // Don't rerun early lowering on deserialized functions.
+      if (F.wasDeserializedCanonical())
+        continue;
+
       // Set F to have unqualified ownership.
       F.setUnqualifiedOwnership();