Stop stripping the `std.` prefix when printing operations in a region with a defined default dialect

[mehdi_amini]

Summary

This fixes round-trip / ambiguity when an operation in the standard dialect would
have the same name as an operation in the default dialect.

[stellaraccident]

Thanks! I was searching for '"std"' figuring there had to be a callout for this, but needed to widen my search.

[rriddle]

mlir/test/IR/parser.mlir

1328–1330

Can you add a TODO here that we remove this after the standard dialect isn't privileged?

mlir/lib/IR/Operation.cpp

 void OpState::print(Operation *op, OpAsmPrinter &p) { p.printGenericOp(op); }
 // The fallback for the printer is to print in the generic assembly form.
 void OpState::printOpName(Operation *op, OpAsmPrinter &p,
                           StringRef defaultDialect) {
   StringRef name = op->getName().getStringRef();
   if (name.startswith((defaultDialect + ".").str()))
     name = name.drop_front(defaultDialect.size() + 1);
   // TODO: remove this special case.
-  else if (name.startswith("std."))
+  else if ((defaultDialect.empty() || defaultDialect == "builtin") &&
+           name.startswith("std."))
     name = name.drop_front(4);
   p.getStream() << name;
 }
 
 /// Emit an error about fatal conditions with this operation, reporting up to
 /// any diagnostic handlers that may be listening.
 InFlightDiagnostic OpState::emitError(const Twine &message) {
   return getOperation()->emitError(message);

mlir/test/IR/parser.mlir

func @pretty_names() {
   return
 }
 
 
 // This tests the behavior of "default dialect":
 // operations like `test.default_dialect` can define a default dialect
 // used in nested region.
 // CHECK-LABEL: func @default_dialect
-func @default_dialect() {
+func @default_dialect(%bool : i1) {
   test.default_dialect {
     // The test dialect is the default in this region, the following two
     // operations are parsed identically.
     // CHECK-NOT: test.parse_integer_literal
     parse_integer_literal : 5
     // CHECK: parse_integer_literal : 6
     test.parse_integer_literal : 6
     // Verify that only an op prefix is stripped, not an attribute value for
     // example.
     // CHECK:  "test.op_with_attr"() {test.attr = "test.value"} : () -> ()
     "test.op_with_attr"() {test.attr = "test.value"} : () -> ()
+
+    // Verify that operations in the standard dialect keep the `std.` prefix.
+    // CHECK: std.assert
+    assert %bool, "Assertion"
     "test.terminator"() : ()->()
   }
+  // The same operation outside of the region does not have an std. prefix.
+  // CHECK-NOT: std.assert
+  // CHECK: assert
+  assert %bool, "Assertion"
   return
 }
 
 // CHECK-LABEL: func @unreachable_dominance_violation_ok
 func @unreachable_dominance_violation_ok() -> i1 {
 // CHECK:   [[VAL:%.*]] = constant false
 // CHECK:   return [[VAL]] : i1
 // CHECK: ^bb1:   // no predecessors