[MLIR] Add mapping based on ValueRange to BlockAndValueMapper.

[herhut]

Summary

It is often needed to map entire ranges rather than single values. To avoid
writing the same for loop every time, I have added an overload to the map
method.

[herhut]

Maybe this should even be a template to cover more cases like BlockArguments.

[merge_guards_bot]

Unit tests: pass. 62416 tests passed, 0 failed and 839 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[rriddle]

mlir/include/mlir/IR/BlockAndValueMapping.h

35

I would prefer that we use templates instead of specific classes. That would also remove the need for any additional includes, among other benefits.

[herhut]

Made it a template with help from @pifon2a.

[herhut]

Remove unneeded import.

[merge_guards_bot]

Unit tests: fail. 62437 tests passed, 1 failed and 845 were skipped.

failed: libc++.std/thread/thread_mutex/thread_mutex_requirements/thread_timedmutex_requirements/thread_timedmutex_class/lock.pass.cpp

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[merge_guards_bot]

Unit tests: pass. 62438 tests passed, 0 failed and 845 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[rriddle]

mlir/include/mlir/IR/BlockAndValueMapping.h

33

nit: I would just keep these the same for now. Is there a reason to templatize these yet?

50

nit: S&& and T&&

[herhut]

Less templates.

[herhut]

@rriddle Is this what you had in mind?

mlir/include/mlir/IR/BlockAndValueMapping.h

33

No, this was more me figuring out specifying the right template constraints. I have reverted that part.

[merge_guards_bot]

Unit tests: pass. 62438 tests passed, 0 failed and 845 were skipped.

clang-tidy: pass.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[rriddle]

LGTM after fixing the format issue.

mlir/include/mlir/IR/BlockAndValueMapping.h

42

nit: Can you just use is_assignable for both?

[herhut]

Formatting.

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[herhut]

use is_assignable

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

mlir/include/mlir/IR/BlockAndValueMapping.h

 // value types.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_BLOCKANDVALUEMAPPING_H
 #define MLIR_IR_BLOCKANDVALUEMAPPING_H
 
 #include "mlir/IR/Block.h"
+#include "mlir/IR/OperationSupport.h"
 
 namespace mlir {
 // This is a utility class for mapping one set of values to another. New
 // mappings can be inserted via 'map'. Existing mappings can be
 // found via the 'lookup*' functions. There are two variants that differ only in
 // return value when an existing is not found for the provided key.
 // 'lookupOrNull' returns nullptr where as 'lookupOrDefault' will return the
 // lookup key.
 class BlockAndValueMapping {
 public:
   /// Inserts a new mapping for 'from' to 'to'. If there is an existing mapping,
   /// it is overwritten.
   void map(Block *from, Block *to) { valueMap[from] = to; }
   void map(Value from, Value to) {
     valueMap[from.getAsOpaquePointer()] = to.getAsOpaquePointer();
   }
+  void map(ValueRange from, ValueRange to) {
+    for (auto pair : llvm::zip(from, to))
+      map(std::get<0>(pair), std::get<1>(pair));
+  }
 
   /// Erases a mapping for 'from'.
   void erase(Block *from) { valueMap.erase(from); }
   void erase(Value from) { valueMap.erase(from.getAsOpaquePointer()); }
 
   /// Checks to see if a mapping for 'from' exists.
   bool contains(Block *from) const { return valueMap.count(from); }
   bool contains(Value from) const {
     return valueMap.count(from.getAsOpaquePointer());
   }
 
   /// Lookup a mapped value within the map. If a mapping for the provided value
   /// does not exist then return nullptr.
   Block *lookupOrNull(Block *from) const {
     return lookupOrValue(from, (Block *)nullptr);
   }
   Value lookupOrNull(Value from) const { return lookupOrValue(from, Value()); }
 
   /// Lookup a mapped value within the map. If a mapping for the provided value
   /// does not exist then return the provided value.