[mlir][tblgen] Fix undefined behaviour found by MSVC debug iterators

[zero9178]

Summary

Incrementing past the end iterator of any container in C++ is immediate undefined behaviour.
This is guaranteed to occur in the loop condition due to the expression cur = earlyIncIt++, which when earlyIncIt is the end iterator (aka we just did the last iteration of the loop), will do an increment on the end iterator.

To fix this, the patch refactors the loop to a more conventional loop using iterators, with the only difference being that the increment happens through the erase operation, which conveniently returns an iterator to the element after the erased element. Thanks to that guarantee there is also no need to use std::list over std::vector.
I also opted to reduce the inner loop find_if, because I felt splitting the "search" and the effects of if it was successful made the code (subjectively) nicer, and also avoided having to add an extra "bool erased" to the outer loop body.

[jpienaar]

Thanks

mlir/lib/TableGen/Operator.cpp

if (fullyInferredIndex) {
           inference[resultIndex].sources.emplace_back(otherResultIndex,
                                                       "$_self");
         }
       }
     }
   }
 
   // Propagate inferredness until a fixed point.
-  std::list<ResultTypeInference *> worklist;
+  std::vector<ResultTypeInference *> worklist;
   for (ResultTypeInference &infer : inference)
     if (!infer.inferred)
       worklist.push_back(&infer);
   bool changed;
   do {
     changed = false;
-    // This is `llvm::make_early_inc_range` but keeps the iterator for erasing.
-    for (auto earlyIncIt = worklist.begin(), cur = earlyIncIt;
-         cur = earlyIncIt++, cur != worklist.end();) {
+    for (auto cur = worklist.begin(); cur != worklist.end();) {
       ResultTypeInference &infer = **cur;
-      for (auto &[idx, source] : llvm::enumerate(infer.sources)) {
+
+      InferredResultType *iter =
+          llvm::find_if(infer.sources, [&](const InferredResultType &source) {
             assert(InferredResultType::isResultIndex(source.getIndex()));
-        if (inference[InferredResultType::unmapResultIndex(source.getIndex())]
-                .inferred) {
-          changed = true;
-          infer.inferred = true;
-          // Make this the only source for the result. This breaks any cycles.
-          infer.sources.assign(1, source);
-          worklist.erase(cur);
-          break;
-        }
-      }
+            return inference[InferredResultType::unmapResultIndex(
+                                 source.getIndex())]
+                .inferred;
+          });
+      if (iter == infer.sources.end()) {
+        ++cur;
+        continue;
+      }
+
+      infer.sources.assign(1, *iter);
+      cur = worklist.erase(cur);
     }
   } while (changed);
 
   allResultsHaveKnownTypes = worklist.empty();
 
   // If the types could be computed, then add type inference trait.
   if (allResultsHaveKnownTypes) {
     traits.push_back(Trait::create(inferTrait->getDefInit()));