[NFC] Inlining: Avoid wasteful non-nullable local fixups (#8147)

Mark the scanning and planning passes as not modifying the IR at all.

Mark the doInlining and Inlining passes as not needing non-nullable
fixups, as we apply those fixups when we inline (update the comment
there to clarify that).

This makes `--inlining` 8% faster on a Dart testcase I am looking at.
That is the result of avoiding 87% of the scans for non-nullable
fixups. The `--inlining-optimizing` pass, however, has a more modest
speedup (since it optimizes after each inlining anyhow, which is even
larger work): 10% fewer scans, and wall time is within noise. (Still,
this does avoid some wasted work even there, and marking sub-passes
that do not modify the IR as not doing so seems like a win for
readability.)

Author: kripken

src/passes/Inlining.cpp

@@ -198,6 +198,8 @@ struct FunctionInfoScanner
   : public WalkerPass<PostWalker<FunctionInfoScanner>> {
   bool isFunctionParallel() override { return true; }
 
+  bool modifiesBinaryenIR() override { return false; }
+
   FunctionInfoScanner(NameInfoMap& infos) : infos(infos) {}
 
   std::unique_ptr<Pass> create() override {
@@ -323,6 +325,8 @@ struct InliningState {
 struct Planner : public WalkerPass<TryDepthWalker<Planner>> {
   bool isFunctionParallel() override { return true; }
 
+  bool modifiesBinaryenIR() override { return false; }
+
   Planner(InliningState* state) : state(state) {}
 
   std::unique_ptr<Pass> create() override {
@@ -688,8 +692,9 @@ static void updateAfterInlining(Module* module, Function* into) {
   // Inlining unreachable contents can make things in the function we inlined
   // into unreachable.
   ReFinalize().walkFunctionInModule(into, module);
-  // New locals we added may require fixups for nondefaultability.
-  // FIXME Is this not done automatically?
+  // New locals we added may require fixups for nondefaultability. We do this
+  // here and not in the main pass (or its subpasses) so that we only do it
+  // where needed.
   TypeUpdating::handleNonDefaultableLocals(into, *module);
 }
 
@@ -710,6 +715,9 @@ using ChosenActions = std::unordered_map<Name, std::vector<InliningAction>>;
 struct DoInlining : public Pass {
   bool isFunctionParallel() override { return true; }
 
+  // We do this only where we inline, inside updateAfterInlining().
+  bool requiresNonNullableLocalFixups() override { return false; }
+
   std::unique_ptr<Pass> create() override {
     return std::make_unique<DoInlining>(chosenActions);
   }
@@ -1254,6 +1262,9 @@ struct Inlining : public Pass {
   // FIXME DWARF updating does not handle local changes yet.
   bool invalidatesDWARF() override { return true; }
 
+  // We do this only where we inline, inside updateAfterInlining().
+  bool requiresNonNullableLocalFixups() override { return false; }
+
   // whether to optimize where we inline
   bool optimize = false;