[mlir][emitc] Mark emitc.literal with CExpression

This PR marks `emitc.literal` as a valid operation within
`emitc.expression`, removing an artificial restriction since
literals are inherently inlined into expressions during emission.

Example:
```mlir
%0 = emitc.expression : i32 {
  %literal = emitc.literal "42" : i32
  emitc.yield %literal : i32
}
```

Author: Vladislave0-0

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

@@ -873,7 +873,7 @@ def EmitC_IncludeOp
   let hasCustomAssemblyFormat = 1;
 }
 
-def EmitC_LiteralOp : EmitC_Op<"literal", [Pure]> {
+def EmitC_LiteralOp : EmitC_Op<"literal", [Pure, CExpressionInterface]> {
   let summary = "Literal operation";
   let description = [{
     The `emitc.literal` operation produces an SSA value equal to some constant

mlir/lib/Target/Cpp/TranslateToCpp.cpp

@@ -100,6 +100,7 @@ static FailureOr<int> getOperatorPrecedence(Operation *operation) {
       .Case<emitc::ConstantOp>([&](auto op) { return 17; })
       .Case<emitc::DivOp>([&](auto op) { return 13; })
       .Case<emitc::LoadOp>([&](auto op) { return 16; })
+      .Case<emitc::LiteralOp>([&](auto op) { return 16; })
       .Case<emitc::LogicalAndOp>([&](auto op) { return 4; })
       .Case<emitc::LogicalNotOp>([&](auto op) { return 15; })
       .Case<emitc::LogicalOrOp>([&](auto op) { return 3; })
@@ -452,6 +453,16 @@ static LogicalResult printOperation(CppEmitter &emitter, emitc::LoadOp loadOp) {
   return emitter.emitOperand(loadOp.getOperand());
 }
 
+static LogicalResult printOperation(CppEmitter &emitter,
+                                    emitc::LiteralOp literalOp) {
+  // If literalOp is used inside an expression, we treat it as an embedded one.
+  if (emitter.isPartOfCurrentExpression(literalOp.getResult()))
+    return emitter.ostream() << literalOp.getValue(), success();
+
+  emitter.cacheDeferredOpResult(literalOp.getResult(), literalOp.getValue());
+  return success();
+}
+
 static LogicalResult printBinaryOperation(CppEmitter &emitter,
                                           Operation *operation,
                                           StringRef binaryOperator) {
@@ -1714,10 +1725,10 @@ LogicalResult CppEmitter::emitOperation(Operation &op, bool trailingSemicolon) {
                 emitc::DeclareFuncOp, emitc::DivOp, emitc::ExpressionOp,
                 emitc::FieldOp, emitc::FileOp, emitc::ForOp, emitc::FuncOp,
                 emitc::GlobalOp, emitc::IfOp, emitc::IncludeOp, emitc::LoadOp,
-                emitc::LogicalAndOp, emitc::LogicalNotOp, emitc::LogicalOrOp,
-                emitc::MulOp, emitc::RemOp, emitc::ReturnOp, emitc::SubOp,
-                emitc::SwitchOp, emitc::UnaryMinusOp, emitc::UnaryPlusOp,
-                emitc::VariableOp, emitc::VerbatimOp>(
+                emitc::LiteralOp, emitc::LogicalAndOp, emitc::LogicalNotOp,
+                emitc::LogicalOrOp, emitc::MulOp, emitc::RemOp, emitc::ReturnOp,
+                emitc::SubOp, emitc::SwitchOp, emitc::UnaryMinusOp,
+                emitc::UnaryPlusOp, emitc::VariableOp, emitc::VerbatimOp>(
 
               [&](auto op) { return printOperation(*this, op); })
           // Func ops.
@@ -1731,10 +1742,6 @@ LogicalResult CppEmitter::emitOperation(Operation &op, bool trailingSemicolon) {
             cacheDeferredOpResult(op.getResult(), op.getFieldName());
             return success();
           })
-          .Case<emitc::LiteralOp>([&](auto op) {
-            cacheDeferredOpResult(op.getResult(), op.getValue());
-            return success();
-          })
           .Case<emitc::MemberOp>([&](auto op) {
             cacheDeferredOpResult(op.getResult(), createMemberAccess(op));
             return success();

mlir/test/Dialect/EmitC/form-expressions.mlir

@@ -208,3 +208,29 @@ func.func @expression_with_constant(%arg0: i32) -> i32 {
   %a = emitc.mul %arg0, %c42 : (i32, i32) -> i32
   return %a : i32
 }
+
+// CHECK-LABEL:   func.func @expression_with_literal(
+// CHECK-SAME:      %[[ARG0:.*]]: i32) -> i1 {
+// CHECK:           %[[VAL_0:.*]] = emitc.expression : i32 {
+// CHECK:             %[[VAL_1:.*]] = literal "1" : i32
+// CHECK:             yield %[[VAL_1]] : i32
+// CHECK:           }
+// CHECK:           %[[VAL_2:.*]] = emitc.expression : i32 {
+// CHECK:             %[[VAL_3:.*]] = literal "2" : i32
+// CHECK:             yield %[[VAL_3]] : i32
+// CHECK:           }
+// CHECK:           %[[VAL_4:.*]] = emitc.expression : i1 {
+// CHECK:             %[[VAL_5:.*]] = add %[[VAL_0]], %[[VAL_2]] : (i32, i32) -> i32
+// CHECK:             %[[VAL_6:.*]] = cmp lt, %[[VAL_5]], %[[ARG0]] : (i32, i32) -> i1
+// CHECK:             yield %[[VAL_6]] : i1
+// CHECK:           }
+// CHECK:           return %[[VAL_4]] : i1
+// CHECK:         }
+
+func.func @expression_with_literal(%arg0: i32) -> i1 {
+  %literal1 = emitc.literal "1" : i32
+  %literal2 = emitc.literal "2" : i32
+  %b = emitc.add %literal1, %literal2 : (i32, i32) -> i32
+  %c = emitc.cmp lt, %b, %arg0 :(i32, i32) -> i1
+  return %c : i1
+}

mlir/test/Target/Cpp/expressions.mlir

@@ -458,3 +458,29 @@ emitc.func @expression_with_call_opaque_with_args_array(%0 : i32, %1 : i32) {
   }
   return
 }
+
+
+// CPP-DEFAULT:      bool expression_with_literal(int32_t [[VAL_1:v[0-9]+]]) {
+// CPP-DEFAULT-NEXT:   bool [[VAL_2:v[0-9]+]] = (1 + [[VAL_1]]) / 2 < 3;
+// CPP-DEFAULT-NEXT:   return [[VAL_2]];
+// CPP-DEFAULT-NEXT: }
+
+// CPP-DECLTOP:      bool expression_with_literal(int32_t [[VAL_1:v[0-9]+]]) {
+// CPP-DECLTOP-NEXT:   bool [[VAL_2:v[0-9]+]];
+// CPP-DECLTOP-NEXT:   [[VAL_2]] = (1 + [[VAL_1]]) / 2 < 3;
+// CPP-DECLTOP-NEXT:   return [[VAL_2]];
+// CPP-DECLTOP-NEXT: }
+
+func.func @expression_with_literal(%arg0 : i32) -> i1 {
+  %ret = emitc.expression noinline : i1 {
+    %literal1 = emitc.literal "1" : i32
+    %literal2 = emitc.literal "2" : i32
+    %add = add %literal1, %arg0 : (i32, i32) -> i32
+    %div = div %add, %literal2 : (i32, i32) -> i32
+    %literal3 = emitc.literal "3" : i32
+    %f = emitc.cmp lt, %div, %literal3 :(i32, i32) -> i1
+    emitc.yield %f : i1
+  }
+
+  return %ret : i1
+}