[mlir][IR] Combine location hash if required in OperationEquivalence::computeHash

[uenoku]

Summary

This fixes a bug that OperationEquivalence::computeHash doesn't
combine hash of operation locations even when IgnoreLocations is false.
Added a unit test which fails at the current trunk.

mlir/lib/IR/OperationSupport.cpp

llvm::hash_code OperationEquivalence::computeHash(
   // Hash operations based upon their:
   //   - Operation Name
   //   - Attributes
   //   - Result Types
   llvm::hash_code hash =
       llvm::hash_combine(op->getName(), op->getDiscardableAttrDictionary(),
                          op->getResultTypes(), op->hashProperties());
 
+  //   - Location if required
+  if(!(flags & Flags::IgnoreLocations))
+    hash = llvm::hash_combine(hash, op->getLoc());
+
   //   - Operands
   ValueRange operands = op->getOperands();
   SmallVector<Value> operandStorage;
   if (op->hasTrait<mlir::OpTrait::IsCommutative>()) {
     operandStorage.append(operands.begin(), operands.end());
     llvm::sort(operandStorage, [](Value a, Value b) -> bool {
       return a.getAsOpaquePointer() < b.getAsOpaquePointer();
     });

mlir/unittests/IR/OperationSupportTest.cpp

TEST(OperandStorageTest, PopulateDefaultAttrs) {
   // Verify default attributes populated post op creation.
   Operation *op = b.create<test::OpAttrMatch1>(b.getUnknownLoc(), req1, nullptr,
                                                nullptr, req2);
   auto opt = op->getAttr("default_valued_attr");
   EXPECT_NE(opt, nullptr) << *op;
 
   op->destroy();
 }
+
+TEST(OperationEquivalenceTest, HashWorksWithFlags) {
+  MLIRContext context;
+  context.getOrLoadDialect<test::TestDialect>();
+
+  auto op1 = createOp(&context);
+  // `op1` has an unknown loc.
+  auto op2 = createOp(&context);
+  op2->setLoc(NameLoc::get(StringAttr::get(&context, "foo")));
+  auto getHash = [](Operation *op, OperationEquivalence::Flags flags) {
+    return OperationEquivalence::computeHash(
+        op, OperationEquivalence::ignoreHashValue,
+        OperationEquivalence::ignoreHashValue, flags);
+  };
+  EXPECT_EQ(getHash(op1, OperationEquivalence::IgnoreLocations),
+            getHash(op2, OperationEquivalence::IgnoreLocations));
+  EXPECT_NE(getHash(op1, OperationEquivalence::None),
+            getHash(op2, OperationEquivalence::None));
+  op1->destroy();
+  op2->destroy();
+}
+
 } // namespace