rewritten

Author: Jaddyen

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

@@ -1593,46 +1593,45 @@ def EmitC_SwitchOp : EmitC_Op<"switch", [RecursiveMemoryEffects,
   let hasVerifier = 1;
 }
 
-def EmitC_ClassOp : EmitC_Op<"class", [AutomaticAllocationScope,
-                                       IsolatedFromAbove, OpAsmOpInterface]> {
+def EmitC_ClassOp
+    : EmitC_Op<"class", [AutomaticAllocationScope, IsolatedFromAbove,
+                         OpAsmOpInterface, SymbolTable,
+                         Symbol]#GraphRegionNoTerminator.traits> {
   let summary =
       "Represents a C++ class definition, encapsulating fields and methods.";
 
+  // FIX WORDING
   let description = [{
     The `emitc.class` operation defines a C++ class, acting as a container
     for its data fields (`emitc.variable`) and methods (`emitc.func`).
     It creates a distinct scope, isolating its contents from the surrounding
     MLIR region, similar to how C++ classes encapsulate their internals.
+    All the class memebrs need to be default initalizable. 
 
     Example:
     ```mlir
-    emitc.class @MyModelClass {
-        emitc.field @another_feature : !emitc.lvalue<!emitc.ptr<f32>>
-        emitc.field @some_feature : !emitc.lvalue<!emitc.ptr<f32>>
-        emitc.field @output_0 : !emitc.lvalue<!emitc.ptr<f32>>
-
-        emitc.func @main() attributes {tf.entry_function = {inputs = "serving_default_another_feature:0,serving_default_some_feature:0", outputs = "PartitionedCall:0"}, tf_saved_model.exported_names = ["serving_default"]} {
-          %c0 = "emitc.constant"() <{value = 0 : index}> : () -> !emitc.size_t
-
-          %some_ptr = emitc.get_field %self : @MyModelClass, @some_feature -> !emitc.ptr<f32>
-          %another_ptr = emitc.get_field %self : @MyModelClass, @another_feature -> !emitc.ptr<f32>
-          %output_ptr = emitc.get_field %self : @MyModelClass, @output_0 -> !emitc.ptr<f32>
-
-          %v1 = subscript %some_ptr[%c0] : (!emitc.ptr<f32>, !emitc.size_t) -> !emitc.lvalue<f32>
-          %v1_val = load %v1 : !emitc.lvalue<f32> -> f32
-
-          %v2 = subscript %another_ptr[%c0] : (!emitc.ptr<f32>, !emitc.size_t) -> !emitc.lvalue<f32>
-          %v2_val = load %v2 : !emitc.lvalue<f32> -> f32
-
-          %v3_val = add %v1_val, %v2_val : (f32, f32) -> f32
-
-          %output_lvalue = subscript %output_ptr[%c0] : (!emitc.ptr<f32>, !emitc.size_t) -> !emitc.lvalue<f32>
-          assign %v3_val, %output_lvalue : (f32, !emitc.lvalue<f32>) -> ()
-
-          return
-        }
+    emitc.class @MymainClass {
+      emitc.field @another_feature : !emitc.array<1xf32> = {tf_saved_model.index_path = ["another_feature"]}
+      emitc.field @some_feature : !emitc.array<1xf32> = {tf_saved_model.index_path = ["some_feature"]}
+      emitc.field @output_0 : !emitc.array<1xf32> = {tf_saved_model.index_path = ["output_0"]}
+
+      emitc.func @execute() {
+        %0 = "emitc.constant"() <{value = 0 : index}> : () -> !emitc.size_t
+
+        %1 = get_field @another_feature : !emitc.array<1xf32>
+        %2 = get_field @some_feature : !emitc.array<1xf32>
+        %3 = get_field @output_0 : !emitc.array<1xf32>
+
+        %4 = subscript %2[%0] : (!emitc.array<1xf32>, !emitc.size_t) -> !emitc.lvalue<f32>
+        %5 = load %4 : <f32>
+        %6 = subscript %1[%0] : (!emitc.array<1xf32>, !emitc.size_t) -> !emitc.lvalue<f32>
+        %7 = load %6 : <f32>
+        %8 = add %5, %7 : (f32, f32) -> f32
+        %9 = subscript %3[%0] : (!emitc.array<1xf32>, !emitc.size_t) -> !emitc.lvalue<f32>
+        assign %8 : f32 to %9 : <f32>
+        return
       }
-    }
+  }
 
     ```
   }];
@@ -1650,7 +1649,7 @@ def EmitC_ClassOp : EmitC_Op<"class", [AutomaticAllocationScope,
 
   let hasCustomAssemblyFormat = 1;
 
-  let assemblyFormat = "`class` $sym_name attr-dict-with-keyword $body";
+  let assemblyFormat = [{ $sym_name attr-dict-with-keyword $body }];
 }
 
 def EmitC_FieldOp : EmitC_Op<"field", [Symbol]> {
@@ -1663,23 +1662,18 @@ def EmitC_FieldOp : EmitC_Op<"field", [Symbol]> {
 
     ```mlir
     emitc.class @MyModelClass {
-      emitc.field @another_feature : !emitc.lvalue<!emitc.ptr<f32>> = #emitc.value<0.0> : !emitc.f32
-      emitc.field @some_feature : !emitc.lvalue<!emitc.ptr<f32>> = #emitc.value<1.0> : !emitc.f32
-      emitc.field @output_0 : !emitc.lvalue<!emitc.ptr<f32>>
-    }
-    ```
-    Example without initial value:
-    ```mlir
-    emitc.class @MyModelClass {
-      emitc.field @another_feature : !emitc.lvalue<!emitc.ptr<f32>>
+      emitc.field @another_feature : !emitc.array<1xf32> = {tf_saved_model.index_path = ["another_feature"]}
+      emitc.field @some_feature : !emitc.array<1xf32> = {tf_saved_model.index_path = ["some_feature"]}
+      emitc.field @output_0 : !emitc.array<1xf32> = {tf_saved_model.index_path = ["output_0"]}
     }
     ```
   }];
 
   let arguments = (ins SymbolNameAttr:$sym_name, TypeAttr:$type,
       OptionalAttr<AnyAttr>:$initial_value);
 
-  let assemblyFormat = "$sym_name `:` $type (`=` $initial_value^)? attr-dict";
+  let assemblyFormat =
+      [{ $sym_name `:` $type (`=` $initial_value^)? attr-dict}];
 
   let hasVerifier = 1;
 }
@@ -1695,18 +1689,15 @@ def EmitC_GetFieldOp
      Example:
 
      ```mlir
-     %some_ptr = emitc.get_field %self : @MyModelClass, @some_feature -> !emitc.ptr<f32>
-     %another_ptr = emitc.get_field %self : @MyModelClass, @another_feature -> !emitc.ptr<f32>
-     %output_ptr = emitc.get_field %self : @MyModelClass, @output_0 -> !emitc.ptr<f32>
+    %some_ptr = emitc.get_field @some_feature : !emitc.array<1xf32> 
+    %another_ptr = emitc.get_field @another_feature : !emitc.array<1xf32> 
+    %output_ptr = emitc.get_field @output_0 : !emitc.array<1xf32> 
      ```
   }];
 
-  let arguments = (ins AnyTypeOf<[EmitC_LValueType, EmitC_PointerType]>:$base,
-      FlatSymbolRefAttr:$class_name, FlatSymbolRefAttr:$field_name);
-
-  let results = (outs AnyTypeOf<[EmitC_LValueType, EmitC_PointerType]>:$result);
-  let assemblyFormat = "$base `:` type($base) $class_name `,` $field_name `->` "
-                       "type($result) attr-dict";
+  let arguments = (ins FlatSymbolRefAttr:$field_name);
+  let results = (outs AnyTypeOf<[EmitC_ArrayType, EmitC_LValueType]>:$result);
+  let assemblyFormat = "$field_name `:` type($result) attr-dict";
 }
 
 #endif // MLIR_DIALECT_EMITC_IR_EMITC

mlir/include/mlir/Dialect/EmitC/Transforms/Passes.h

@@ -15,7 +15,7 @@ namespace mlir {
 namespace emitc {
 
 #define GEN_PASS_DECL_FORMEXPRESSIONSPASS
-#define GEN_PASS_DECL_CONVERTFUNCTOCLASSPASS
+#define GEN_PASS_DECL_WRAPFUNCINCLASSPASS
 #include "mlir/Dialect/EmitC/Transforms/Passes.h.inc"
 
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/EmitC/Transforms/Passes.td

@@ -20,9 +20,8 @@ def FormExpressionsPass : Pass<"form-expressions"> {
   let dependentDialects = ["emitc::EmitCDialect"];
 }
 
-def ConvertFuncToClassPass
-    : Pass<"convert-emitc-func-to-class", "mlir::emitc::FuncOp"> {
-  let summary = "Convert functions to classes, using arguments as fields.";
+def WrapFuncInClassPass : Pass<"wrap-emitc-func-in-class"> {
+  let summary = "Wrap functions in classes, using arguments as fields.";
   let description = [{
     This pass transforms `emitc.func` operations into `emitc.class` operations.
     Function arguments become fields of the class, and the function body is moved

mlir/include/mlir/Dialect/EmitC/Transforms/Transforms.h

@@ -28,11 +28,8 @@ ExpressionOp createExpression(Operation *op, OpBuilder &builder);
 /// Populates `patterns` with expression-related patterns.
 void populateExpressionPatterns(RewritePatternSet &patterns);
 
-//===----------------------------------------------------------------------===//
-// Convert Func to Class Transform
-//===----------------------------------------------------------------------===//
-
-ClassOp createClass(FuncOp funcOp, OpBuilder &builder);
+/// Populates 'patterns' with func-related patterns.
+void populateFuncPatterns(RewritePatternSet &patterns);
 
 } // namespace emitc
 } // namespace mlir

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

@@ -1408,32 +1408,32 @@ LogicalResult FieldOp::verify() {
     return emitOpError("expected valid emitc type");
   }
 
-  if (!getInitialValue().has_value()) {
+  if (!getInitialValue()) {
     return success();
   }
 
-  Attribute initValue = getInitialValue().value();
+  Attribute initValue = *getInitialValue();
   // Check that the type of the initial value is compatible with the type of
   // the global variable.
-  if (auto elementsAttr = llvm::dyn_cast<ElementsAttr>(initValue)) {
-    auto initialValueType = elementsAttr.getType();
+  if (ElementsAttr elementsAttr = llvm::dyn_cast<ElementsAttr>(initValue)) {
+    Type initialValueType = elementsAttr.getType();
     if (!initialValueType) {
       return emitOpError("initial value attribute must have a type");
     }
-    auto fieldType = getType();
+    Type fieldType = getType();
     if (initialValueType != fieldType) {
-      if (auto lvalueType = dyn_cast<LValueType>(fieldType)) {
-        auto innerFieldType = lvalueType.getValueType();
+      if (LValueType lvalueType = dyn_cast<LValueType>(fieldType)) {
+        Type innerFieldType = lvalueType.getValueType();
         if (innerFieldType != initialValueType) {
           return emitOpError("initial value type ")
-                 << initialValueType << " is not compatible with field type "
-                 << fieldType << " its inner type " << innerFieldType;
+                 << initialValueType << " is not compatible with field type '"
+                 << fieldType << "' its inner type '" << innerFieldType << "'";
         }
 
       } else {
-        return emitOpError("initial value type ")
-               << initialValueType << " is not compatible with field type "
-               << fieldType;
+        return emitOpError("initial value type '")
+               << initialValueType << "' is not compatible with field type '"
+               << fieldType << "'";
       }
     }
   }
@@ -1445,20 +1445,18 @@ LogicalResult FieldOp::verify() {
 // GetFieldOp
 //===----------------------------------------------------------------------===//
 LogicalResult GetFieldOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
-  auto classNameAttr = getClassNameAttr();
-  auto fieldNameAttr = getFieldNameAttr();
-  if (!classNameAttr || !fieldNameAttr) {
-    return emitError("class and field name attributes are mandatory");
+  mlir::FlatSymbolRefAttr fieldNameAttr = getFieldNameAttr();
+  if (!fieldNameAttr) {
+    return emitError("field name attribute is mandatory");
   }
-  StringRef className = classNameAttr.getValue();
+
   StringRef fieldName = fieldNameAttr.getValue();
 
-  auto fieldOp =
+  FieldOp fieldOp =
       symbolTable.lookupNearestSymbolFrom<FieldOp>(*this, getFieldNameAttr());
 
   if (!fieldOp) {
-    return emitOpError("field '")
-           << fieldName << "' not found in class '" << className << "'";
+    return emitOpError("field '") << fieldName << "' not found in the class '";
   }
 
   Type getFieldResultType = getResult().getType();

mlir/lib/Dialect/EmitC/Transforms/CMakeLists.txt

@@ -2,7 +2,7 @@ add_mlir_dialect_library(MLIREmitCTransforms
   Transforms.cpp
   FormExpressions.cpp
   TypeConversions.cpp
-  ConvertFuncToClass.cpp
+  WrapFuncInClass.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/EmitC/Transforms

mlir/lib/Dialect/EmitC/Transforms/ConvertFuncToClass.cpp

@@ -10,7 +10,6 @@
 #include "mlir/Dialect/EmitC/IR/EmitC.h"
 #include "mlir/IR/IRMapping.h"
 #include "mlir/IR/PatternMatch.h"
-#include "llvm/Support/Debug.h"
 
 namespace mlir {
 namespace emitc {
@@ -42,80 +41,6 @@ ExpressionOp createExpression(Operation *op, OpBuilder &builder) {
   return expressionOp;
 }
 
-ClassOp createClass(FuncOp funcOp, OpBuilder &builder) {
-  builder.setInsertionPoint(funcOp);
-
-  auto classOp = builder.create<emitc::ClassOp>(
-      funcOp.getLoc(), builder.getStringAttr("MyModelClass"));
-
-  builder.createBlock(&classOp.getBody());
-  builder.setInsertionPointToStart(&classOp.getBody().front());
-
-  SmallVector<std::pair<StringRef, Type>> fields;
-  llvm::SmallDenseMap<Value, Value> argToFieldMap;
-
-  auto argAttrs = funcOp.getArgAttrs();
-  if (argAttrs) {
-    for (const auto [arg, val] : zip(*argAttrs, funcOp.getArguments())) {
-      if (auto da = dyn_cast<mlir::DictionaryAttr>(arg)) {
-        auto nv = da.getNamed("tf_saved_model.index_path")->getValue();
-        auto fieldName = cast<mlir::StringAttr>(cast<mlir::ArrayAttr>(nv)[0]);
-        auto fieldType = emitc::LValueType::get(emitc::PointerType::get(
-            dyn_cast_or_null<emitc::ArrayType>(val.getType())
-                .getElementType()));
-        fields.push_back({fieldName.str(), fieldType});
-
-        auto typeAttr = TypeAttr::get(val.getType());
-        mlir::Attribute emptyAttr = builder.getAttr<mlir::UnitAttr>();
-        auto dictAttr = DictionaryAttr::get(
-            builder.getContext(),
-            {builder.getNamedAttr(fieldName.str(), emptyAttr)});
-        builder.create<emitc::FieldOp>(funcOp.getLoc(), fieldName, typeAttr,
-                                       /* attributes*/ dictAttr);
-
-        // TODO: From my current understanding, we need to instantiate a class
-        // so we can get the pointers from .field but we can't do that in here
-        // so I'm unsure how I can rewrite the following line to ensure
-        // GetFieldOp works correctly. auto pointer =
-        // emitc::PointerType::get(dyn_cast_or_null<emitc::ArrayType>(val.getType()).getElementType());
-        // auto ptr = builder.create<emitc::GetFieldOp>(funcOp.getLoc(),
-        // pointer, val, "MyModelClass", fieldName);
-        argToFieldMap[val] = nullptr;
-      }
-    }
-  }
-
-  auto funcContext = funcOp.getContext();
-  auto inputTypes = funcOp.getFunctionType().getInputs();
-  auto results = funcOp.getFunctionType().getResults();
-  auto funcType = FunctionType::get(funcContext, inputTypes, results);
-  auto loc = funcOp.getLoc();
-  auto newFuncOp = builder.create<emitc::FuncOp>(
-      loc, builder.getStringAttr("execute"), funcType);
-
-  builder.createBlock(&newFuncOp.getBody());
-  builder.setInsertionPointToStart(&newFuncOp.getBody().front());
-
-  IRMapping mapper;
-
-  auto body = llvm::make_early_inc_range(funcOp.getBody().front());
-  for (Operation &opToClone : body) {
-    if (isa<emitc::ConstantOp>(opToClone) ||
-        isa<emitc::SubscriptOp>(opToClone) || isa<emitc::LoadOp>(opToClone) ||
-        isa<emitc::AddOp>(opToClone) || isa<emitc::AssignOp>(opToClone) ||
-        isa<emitc::ReturnOp>(opToClone)) {
-      builder.clone(opToClone, mapper);
-    } else {
-      opToClone.emitOpError("Unsupported operation found");
-    }
-  }
-
-  // TODO: Need to erase the funcOp after all this. Using funcOp->erase raises
-  // errors:
-
-  return classOp;
-}
-
 } // namespace emitc
 } // namespace mlir