Align to changes that were requested for int/float

mlir/include/mlir/Dialect/EmitC/IR/EmitC.h

@@ -31,7 +31,7 @@ namespace mlir {
 namespace emitc {
 void buildTerminatedBody(OpBuilder &builder, Location loc);
 /// Determines whether \p type is valid in EmitC.
-bool isValidEmitCType(mlir::Type type);
+bool isSupportedEmitCType(mlir::Type type);
 /// Determines whether \p type is a valid integer type in EmitC.
 bool isSupportedIntegerType(mlir::Type type);
 /// Determines whether \p type is a valid floating-point type in EmitC.

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

@@ -34,16 +34,16 @@ class EmitC_Op<string mnemonic, list<Trait> traits = []>
 // Base class for unary operations.
 class EmitC_UnaryOp<string mnemonic, list<Trait> traits = []> :
     EmitC_Op<mnemonic, traits> {
-  let arguments = (ins Valid_EmitC_Type);
-  let results = (outs Valid_EmitC_Type);
+  let arguments = (ins EmitCType);
+  let results = (outs EmitCType);
   let assemblyFormat = "operands attr-dict `:` functional-type(operands, results)";
 }
 
 // Base class for binary operations.
 class EmitC_BinaryOp<string mnemonic, list<Trait> traits = []> :
     EmitC_Op<mnemonic, traits> {
-  let arguments = (ins Valid_EmitC_Type:$lhs, Valid_EmitC_Type:$rhs);
-  let results = (outs Valid_EmitC_Type);
+  let arguments = (ins EmitCType:$lhs, EmitCType:$rhs);
+  let results = (outs EmitCType);
   let assemblyFormat = "operands attr-dict `:` functional-type(operands, results)";
 }
 
@@ -97,9 +97,9 @@ def EmitC_ApplyOp : EmitC_Op<"apply", [CExpression]> {
   }];
   let arguments = (ins
     Arg<StrAttr, "the operator to apply">:$applicableOperator,
-    Valid_EmitC_Type:$operand
+    EmitCType:$operand
   );
-  let results = (outs Valid_EmitC_Type:$result);
+  let results = (outs EmitCType:$result);
   let assemblyFormat = [{
     $applicableOperator `(` $operand `)` attr-dict `:` functional-type($operand, results)
   }];
@@ -240,9 +240,9 @@ def EmitC_CallOpaqueOp : EmitC_Op<"call_opaque", [CExpression]> {
     Arg<StrAttr, "the C++ function to call">:$callee,
     Arg<OptionalAttr<ArrayAttr>, "the order of operands and further attributes">:$args,
     Arg<OptionalAttr<ArrayAttr>, "template arguments">:$template_args,
-    Variadic<Valid_EmitC_Type>:$operands
+    Variadic<EmitCType>:$operands
   );
-  let results = (outs Variadic<Valid_EmitC_Type>);
+  let results = (outs Variadic<EmitCType>);
   let builders = [
     OpBuilder<(ins
       "::mlir::TypeRange":$resultTypes,
@@ -284,8 +284,8 @@ def EmitC_CastOp : EmitC_Op<"cast",
     ```
   }];
 
-  let arguments = (ins Valid_EmitC_Type:$source);
-  let results = (outs Valid_EmitC_Type:$dest);
+  let arguments = (ins EmitCType:$source);
+  let results = (outs EmitCType:$dest);
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($dest)";
 }
 
@@ -323,9 +323,9 @@ def EmitC_CmpOp : EmitC_BinaryOp<"cmp", [CExpression]> {
   }];
 
   let arguments = (ins EmitC_CmpPredicateAttr:$predicate,
-                       Valid_EmitC_Type:$lhs,
-                       Valid_EmitC_Type:$rhs);
-  let results = (outs Valid_EmitC_Type);
+                       EmitCType:$lhs,
+                       EmitCType:$rhs);
+  let results = (outs EmitCType);
 
   let assemblyFormat = "$predicate `,` operands attr-dict `:` functional-type(operands, results)";
 }
@@ -354,7 +354,7 @@ def EmitC_ConstantOp : EmitC_Op<"constant", [ConstantLike]> {
   }];
 
   let arguments = (ins EmitC_OpaqueOrTypedAttr:$value);
-  let results = (outs Valid_EmitC_Type);
+  let results = (outs EmitCType);
 
   let hasFolder = 1;
   let hasVerifier = 1;
@@ -424,7 +424,7 @@ def EmitC_ExpressionOp : EmitC_Op<"expression",
   }];
 
   let arguments = (ins UnitAttr:$do_not_inline);
-  let results = (outs Valid_EmitC_Type:$result);
+  let results = (outs EmitCType:$result);
   let regions = (region SizedRegion<1>:$region);
 
   let hasVerifier = 1;
@@ -532,8 +532,8 @@ def EmitC_CallOp : EmitC_Op<"call",
     %2 = emitc.call @my_add(%0, %1) : (f32, f32) -> f32
     ```
   }];
-  let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<Valid_EmitC_Type>:$operands);
-  let results = (outs Variadic<Valid_EmitC_Type>);
+  let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<EmitCType>:$operands);
+  let results = (outs Variadic<EmitCType>);
 
   let builders = [
     OpBuilder<(ins "FuncOp":$callee, CArg<"ValueRange", "{}">:$operands), [{
@@ -723,7 +723,7 @@ def EmitC_ReturnOp : EmitC_Op<"return", [Pure, HasParent<"FuncOp">,
     }
     ```
   }];
-  let arguments = (ins Optional<Valid_EmitC_Type>:$operand);
+  let arguments = (ins Optional<EmitCType>:$operand);
 
   let assemblyFormat = "attr-dict ($operand^ `:` type($operand))?";
   let hasVerifier = 1;
@@ -767,7 +767,7 @@ def EmitC_LiteralOp : EmitC_Op<"literal", [Pure]> {
   }];
 
   let arguments = (ins StrAttr:$value);
-  let results = (outs Valid_EmitC_Type:$result);
+  let results = (outs EmitCType:$result);
 
   let hasVerifier = 1;
   let assemblyFormat = "$value attr-dict `:` type($result)";
@@ -933,8 +933,8 @@ def EmitC_ConditionalOp : EmitC_Op<"conditional",
     int32_t v6 = v3 ? v4 : v5;
     ```
   }];
-  let arguments = (ins I1:$condition, Valid_EmitC_Type:$true_value, Valid_EmitC_Type:$false_value);
-  let results = (outs Valid_EmitC_Type:$result);
+  let arguments = (ins I1:$condition, EmitCType:$true_value, EmitCType:$false_value);
+  let results = (outs EmitCType:$result);
   let assemblyFormat = "operands attr-dict `:` type($result)";
 }
 
@@ -1011,7 +1011,7 @@ def EmitC_VariableOp : EmitC_Op<"variable", []> {
   }];
 
   let arguments = (ins EmitC_OpaqueOrTypedAttr:$value);
-  let results = (outs Valid_EmitC_Type);
+  let results = (outs EmitCType);
 
   let hasVerifier = 1;
 }
@@ -1081,7 +1081,7 @@ def EmitC_GetGlobalOp : EmitC_Op<"get_global",
   }];
 
   let arguments = (ins FlatSymbolRefAttr:$name);
-  let results = (outs AnyType:$result);
+  let results = (outs EmitCType:$result);
   let assemblyFormat = "$name `:` type($result) attr-dict";
 }
 
@@ -1139,7 +1139,7 @@ def EmitC_AssignOp : EmitC_Op<"assign", []> {
     ```
   }];
 
-  let arguments = (ins Valid_EmitC_Type:$var, Valid_EmitC_Type:$value);
+  let arguments = (ins EmitCType:$var, EmitCType:$value);
   let results = (outs);
 
   let hasVerifier = 1;
@@ -1160,7 +1160,7 @@ def EmitC_YieldOp : EmitC_Op<"yield",
     value is yielded.
   }];
 
-  let arguments = (ins Optional<Valid_EmitC_Type>:$result);
+  let arguments = (ins Optional<EmitCType>:$result);
   let builders = [OpBuilder<(ins), [{ /* nothing to do */ }]>];
 
   let hasVerifier = 1;
@@ -1243,7 +1243,7 @@ def EmitC_SubscriptOp : EmitC_Op<"subscript",
   }];
   let arguments = (ins Arg<EmitC_ArrayType, "the reference to load from">:$array,
                        Variadic<IntegerIndexOrOpaqueType>:$indices);
-  let results = (outs Valid_EmitC_Type:$result);
+  let results = (outs EmitCType:$result);
 
   let builders = [
     OpBuilder<(ins "Value":$array, "ValueRange":$indices), [{

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

@@ -22,8 +22,8 @@ include "mlir/IR/BuiltinTypeInterfaces.td"
 // EmitC type definitions
 //===----------------------------------------------------------------------===//
 
-def Valid_EmitC_Type : Type<CPred<"emitc::isValidEmitCType($_self)">,
-    "EmitC dialect type">;
+def EmitCType : Type<CPred<"emitc::isSupportedEmitCType($_self)">,
+    "type supported by EmitC">;
 
 def EmitCIntegerType : Type<CPred<"emitc::isSupportedIntegerType($_self)">,
     "integer type supported by EmitC">;

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

@@ -58,16 +58,16 @@ void mlir::emitc::buildTerminatedBody(OpBuilder &builder, Location loc) {
   builder.create<emitc::YieldOp>(loc);
 }
 
-bool mlir::emitc::isValidEmitCType(Type type) {
+bool mlir::emitc::isSupportedEmitCType(Type type) {
   if (isa<emitc::OpaqueType>(type)) {
     return true;
   }
   if (auto ptrType = dyn_cast<emitc::PointerType>(type)) {
-    return isValidEmitCType(ptrType.getPointee());
+    return isSupportedEmitCType(ptrType.getPointee());
   }
   if (auto arrayType = llvm::dyn_cast<emitc::ArrayType>(type)) {
     auto elemType = arrayType.getElementType();
-    return !isa<emitc::ArrayType>(elemType) && isValidEmitCType(elemType);
+    return !isa<emitc::ArrayType>(elemType) && isSupportedEmitCType(elemType);
   }
   if (type.isIndex()) {
     return true;
@@ -86,11 +86,11 @@ bool mlir::emitc::isValidEmitCType(Type type) {
     if (isa<emitc::ArrayType>(elemType)) {
       return false;
     }
-    return isValidEmitCType(elemType);
+    return isSupportedEmitCType(elemType);
   }
   if (auto tupleType = llvm::dyn_cast<TupleType>(type)) {
     return llvm::all_of(tupleType.getTypes(), [](Type type) {
-      return !isa<emitc::ArrayType>(type) && isValidEmitCType(type);
+      return !isa<emitc::ArrayType>(type) && isSupportedEmitCType(type);
     });
   }
   return false;