Add closure use-var tracking to distributed HHBBC

Summary:
Add support for tracking closure use-var types for HHBBC in
distributed mode. This is similar to local mode, except that it never
really handled dependencies properly. Distributed mode does this
correctly.

Reviewed By: mdko

Differential Revision: D89898538

fbshipit-source-id: 9c263b01dc7c27d376ce32342501c518ff372409

Author: ricklavoie

hphp/hhbbc/analyze.cpp

@@ -53,6 +53,8 @@ const StaticString s_Closure("Closure");
 const StaticString s_AsyncGenerator("HH\\AsyncGenerator");
 const StaticString s_Generator("Generator");
 
+const StaticString s_invoke("__invoke");
+
 //////////////////////////////////////////////////////////////////////
 
 /*
@@ -143,9 +145,10 @@ Optional<State> entry_state(const IIndex& index, CollectedInfo& collect,
   }
 
   // Closures have use vars, we need to look up their types from the index.
-  auto const useVars = ctx.func->isClosureBody
-    ? index.lookup_closure_use_vars(*ctx.func)
-    : CompactVector<Type>{};
+  auto const useVars = [&] {
+    if (!ctx.func->isClosureBody) return CompactVector<Type>{};
+    return collect.closureUseVars.initial(*ctx.func);
+  }();
 
   /*
    * Reified functions have a hidden local that's always the first
@@ -499,7 +502,7 @@ FuncAnalysis do_analyze_collect(const IIndex& index,
     }
   } while (!incompleteQ.empty());
 
-  ai.closureUseTypes = std::move(collect.closureUseTypes);
+  ai.closureUseTypes = collect.closureUseVars.merged();
   ai.effectFree = collect.effectFree;
   ai.reanalyzeOnUpdate = collect.reanalyzeOnUpdate;
   ai.hasInvariantIterBase = collect.hasInvariantIterBase;
@@ -801,6 +804,12 @@ void ClassAnalysisWorklist::scheduleForReturnType(const php::Func& callee) {
   for (auto const f : it->second) schedule(*f);
 }
 
+void ClassAnalysisWorklist::scheduleForUseVars(const php::Func& invoke) {
+  auto const it = useVarDeps.find(&invoke);
+  if (it == useVarDeps.end()) return;
+  for (auto const f : it->second) schedule(*f);
+}
+
 //////////////////////////////////////////////////////////////////////
 
 ClsConstantWork::ClsConstantWork(const IIndex& index,
@@ -1214,6 +1223,7 @@ ClassAnalysis analyze_class(const IIndex& index, const Context& ctx) {
     assertx(inserted);
     auto [type, refinements] = index.lookup_return_type_raw(f);
     work.returnTypes.emplace(f, std::move(type));
+    work.useVars.emplace(f, index.lookup_closure_use_vars_raw(*f));
     funcMeta.emplace(
       f, FuncMeta{ctx.unit, c, &clsAnalysis.closures, refinements}
     );
@@ -1227,8 +1237,29 @@ ClassAnalysis analyze_class(const IIndex& index, const Context& ctx) {
     );
   }
 
-  // Keep analyzing until we have more functions scheduled (the fixed
-  // point).
+  // Suppose we first analyze a function which has a CreateCl and
+  // record use-var types, then later analysis (within analyze_class)
+  // determines the CreateCl was dead. In that case, we'll overwrite
+  // the original FuncAnalysisResult (containing the use-var types)
+  // with the new one (containing no use-var types because we didn't
+  // see a CreateCl). The lack of info in the FuncAnalysisResult will
+  // prevent the index from being updated, even though our analysis
+  // might depend on some of those initial use-var types. This can
+  // cause monotonicity violations. To prevent this, when overwriting
+  // a FuncAnalysisResult entry, always make sure to copy over any
+  // use-var type into the new one. This ensures that if ever see a
+  // CreateCl, the FuncAnalysisResult will always have a record of
+  // that.
+  auto const persistUseTypes = [&] (const FuncAnalysisResult& from,
+                                    FuncAnalysisResult& to) {
+    for (auto const& [clo, types] : from.closureUseTypes) {
+      // Will only add closure entries which don't already exist.
+      to.closureUseTypes.emplace(clo, types);
+    }
+  };
+
+  // Keep analyzing until we have more no functions scheduled (the
+  // fixed point).
   while (!work.worklist.empty()) {
     hphp_fast_set<const php::Func*> changed;
 
@@ -1247,7 +1278,9 @@ ClassAnalysis analyze_class(const IIndex& index, const Context& ctx) {
           meta.outputIdx = meta.output->size();
           meta.output->emplace_back(std::move(results));
         } else {
-          (*meta.output)[meta.outputIdx] = std::move(results);
+          auto& output = (*meta.output)[meta.outputIdx];
+          persistUseTypes(output, results);
+          output = std::move(results);
         }
       }
 
@@ -1330,6 +1363,40 @@ ClassAnalysis analyze_class(const IIndex& index, const Context& ctx) {
         );
       }
 
+      for (auto const& [clo, useVars] : results.closureUseTypes) {
+        assertx(is_closure(*clo));
+        auto invoke = find_method(clo, s_invoke.get());
+        always_assert(invoke);
+
+        auto const old = folly::get_ptr(work.useVars, invoke);
+        if (!old) continue;
+
+        auto anyChanged = false;
+        for (size_t i = 0, size = useVars.size(); i < size; ++i) {
+          auto u = useVars.get_default(i, TCell);
+          auto const o = old->get_default(i, TCell);
+
+          if (u.strictlyMoreRefined(o)) {
+            old->ensure(i, TCell) = std::move(u);
+            anyChanged = true;
+          } else {
+            always_assert_flog(
+              u.moreRefined(o),
+              "Index closure use-var invariant violated for {}.\n"
+              "   {} is not at least as refined as {}\n",
+              clo->name,
+              show(u),
+              show(o)
+            );
+          }
+        }
+
+        if (anyChanged) {
+          work.worklist.scheduleForUseVars(*invoke);
+          changed.emplace(invoke);
+        }
+      }
+
       results.localReturnRefinements = meta.localReturnRefinements;
       if (results.localReturnRefinements > 0) --results.localReturnRefinements;
     }
@@ -1396,11 +1463,47 @@ ClassAnalysis analyze_class(const IIndex& index, const Context& ctx) {
         );
       }
 
+      for (auto const& [clo, useVars] : results.closureUseTypes) {
+        assertx(is_closure(*clo));
+        auto invoke = find_method(clo, s_invoke.get());
+        always_assert(invoke);
+
+        auto const old = folly::get_ptr(work.useVars, invoke);
+        if (!old) continue;
+
+        auto anyChanged = false;
+        for (size_t i = 0, size = useVars.size(); i < size; ++i) {
+          auto u = useVars.get_default(i, TCell);
+          auto const o = old->get_default(i, TCell);
+
+          if (u.strictlyMoreRefined(o)) {
+            old->ensure(i, TCell) = std::move(u);
+            anyChanged = true;
+          } else {
+            always_assert_flog(
+              u.moreRefined(o),
+              "Index closure use-var invariant violated for {}.\n"
+              "   {} is not at least as refined as {}\n",
+              clo->name,
+              show(u),
+              show(o)
+            );
+          }
+        }
+
+        if (anyChanged) {
+          work.worklist.scheduleForUseVars(*invoke);
+          changed.emplace(invoke);
+        }
+      }
+
       results.localReturnRefinements = meta.localReturnRefinements;
       if (results.localReturnRefinements > 0) --results.localReturnRefinements;
 
       assertx(meta.outputIdx >= 0);
-      (*meta.output)[meta.outputIdx] = std::move(results);
+      auto& output = (*meta.output)[meta.outputIdx];
+      persistUseTypes(output, results);
+      output = std::move(results);
     }
 
     // Return types have reached a fixed point. However, this means
@@ -1430,14 +1533,21 @@ ClassAnalysis analyze_class(const IIndex& index, const Context& ctx) {
       };
 
       hphp_fast_set<SString> retryProps;
-      for (auto const f : changed) {
-        auto const deps = work.worklist.depsForReturnType(*f);
-        if (!deps) continue;
-        for (auto const dep : *deps) {
+      auto const addProps = [&] (const hphp_fast_set<const php::Func*>& deps) {
+        for (auto const dep : deps) {
           auto const propsIt = work.propMutators.find(dep);
           if (propsIt == work.propMutators.end()) continue;
           for (auto const prop : propsIt->second) retryProps.emplace(prop);
         }
+      };
+
+      for (auto const f : changed) {
+        if (auto const deps = work.worklist.depsForReturnType(*f)) {
+          addProps(*deps);
+        }
+        if (auto const deps = work.worklist.depsForUseVars(*f)) {
+          addProps(*deps);
+        }
       }
 
       // Schedule the funcs which mutate the props before the ones

hphp/hhbbc/analyze.h

@@ -170,6 +170,7 @@ struct ClassAnalysisWorklist {
   void scheduleForProp(SString name);
   void scheduleForPropMutate(SString name);
   void scheduleForReturnType(const php::Func& callee);
+  void scheduleForUseVars(const php::Func& invoke);
 
   void addPropDep(SString name, const php::Func& f) {
     propDeps[name].emplace(&f);
@@ -180,6 +181,9 @@ struct ClassAnalysisWorklist {
   void addReturnTypeDep(const php::Func& callee, const php::Func& f) {
     returnTypeDeps[&callee].emplace(&f);
   }
+  void addUseVarsDep(const php::Func& invoke, const php::Func& caller) {
+    useVarDeps[&invoke].emplace(&caller);
+  }
 
   bool empty() const { return worklist.empty(); }
 
@@ -194,6 +198,13 @@ struct ClassAnalysisWorklist {
     return &it->second;
   }
 
+  const hphp_fast_set<const php::Func*>*
+  depsForUseVars(const php::Func& f) const {
+    auto const it = useVarDeps.find(&f);
+    if (it == useVarDeps.end()) return nullptr;
+    return &it->second;
+  }
+
 private:
   hphp_fast_set<const php::Func*> inWorklist;
   std::deque<const php::Func*> worklist;
@@ -203,12 +214,14 @@ struct ClassAnalysisWorklist {
   Deps<SString> propDeps;
   Deps<SString> propMutateDeps;
   Deps<const php::Func*> returnTypeDeps;
+  Deps<const php::Func*> useVarDeps;
 };
 
 struct ClassAnalysisWork {
   ClassAnalysisWorklist worklist;
   hphp_fast_map<const php::Func*, Index::ReturnType> returnTypes;
   hphp_fast_map<const php::Func*, hphp_fast_set<SString>> propMutators;
+  hphp_fast_map<const php::Func*, CompactVector<Type>> useVars;
   // List of properties whose initial values have been determined to
   // satisfy their type-constraint and which haven't been reflected in
   // the index yet.

hphp/hhbbc/emit.cpp

@@ -1137,7 +1137,7 @@ void emit_class(EmitUnitState& state, UnitEmitter& ue, PreClassEmitter* pce,
   if (is_closure(cls)) {
     auto f = find_method(&cls, s_invoke.get());
     always_assert(f);
-    useVars = state.index.lookup_closure_use_vars(*f, true);
+    useVars = state.index.lookup_closure_use_vars_raw(*f);
   }
   auto uvIt = useVars.begin();