Parser For Sum And Product Types working.

include/Adt/AdtDialect.h

@@ -18,16 +18,36 @@ namespace mlir::adt{
 
 
 /// This class defines the adt source types.
+
+
 namespace mlir::adt{
+    class Tag;
         class TypeSource: public mlir::Type::TypeBase<TypeSource, mlir::Type,mlir::adt::TypeSourceStorage>{
         public:
             // Inherit some necessary constructors from 'TypeBase'.
             using Base::Base;
             // Creating an instance of a 'TypeSource' with the geven element types.
-            static TypeSource get(llvm::ArrayRef<mlir::Type> elementTypes);
+            static TypeSource getTag(llvm::ArrayRef<Tag> elementTypes);
+            static TypeSource getType(llvm::ArrayRef<Type> elementTypes);
+            static TypeSource getTypeSource(llvm::ArrayRef<TypeSource> elementTypes);
+
 
         };
-    }
+        class Tag{
+        private: TypeSource srcType;
+        private: std::string nameSrcType;
+        public: void setNameSrcType(std::string* name){
+                nameSrcType = *name;
+            }
+        public: void setTypeSource(TypeSource* newSrcType){
+                srcType = *newSrcType;
+            }
+        public: TypeSource getTypeSource() const{
+                return srcType;
+            }
+        };
+    };
+
 
 
 #endif // ADT_DIALECT_H_
\ No newline at end of file

include/Adt/AdtOps.td

@@ -25,8 +25,7 @@ def Adt_Dialect : Dialect{
 class Adt_Op<string mnemonic, list<Trait> traits = [] >:
         Op<Adt_Dialect,mnemonic, traits>;
 //===----------------------------------------------------------------------------------------===//
-// Adt type definition.[%i, %j] : memref<2x3xf32>
-         %v =
+//
 //==-----------------------------------------------------------------------------------------===//
 // Provide a definition for the Toy TypeSource for use in ODS. This allows for
 // using TypeSource in a similar way to the classical types in MLIR. We use `DialectType`

lib/Adt/AdtDialect.cpp

@@ -27,60 +27,132 @@ namespace mlir::adt {
         /// On doit implémenter ici une instance du type type source (donc cette instance est un type aussi)
     }
 ///
-TypeSource TypeSource::get(llvm::ArrayRef<mlir::Type> elementTypes) {
+TypeSource TypeSource::getTypeSource(llvm::ArrayRef<TypeSource> elementTypes) {
+    assert(!elementTypes.empty() && "expected at least 1 element type");
+    SmallVector<Type,1> newElementTypes;
+    for (int i = 0; i < (int)elementTypes.size();i++){
+        Type newElementType = (Type) elementTypes[i];
+        newElementTypes.push_back(newElementType);
+    }
+    mlir::MLIRContext *ctx = newElementTypes.front().getContext();
+    return Base::get(ctx,newElementTypes);
+}
+TypeSource TypeSource::getType(llvm::ArrayRef<mlir::Type> elementTypes) {
     assert(!elementTypes.empty() && "expected at least 1 element type");
     mlir::MLIRContext *ctx = elementTypes.front().getContext();
     return Base::get(ctx,elementTypes);
 }
 
-/// On parse ici une instance du type type source (donc cette instance est un type aussi)
-mlir::Type AdtDialect::parseType(::mlir::DialectAsmParser &parser) const{
-    if (parser.parseKeyword("type") || parser.parseLess())
+
+TypeSource TypeSource::getTag(llvm::ArrayRef<Tag> elementTypes){
+    assert(!elementTypes.empty() && "expected at least 1 element type");
+    SmallVector<Type,1> newElementTypes;
+    for (int i = 0; i < (int)elementTypes.size();i++){
+        Type newElementType = (Type) (elementTypes[i].getTypeSource());
+        newElementTypes.push_back(newElementType);
+    }
+    mlir::MLIRContext *ctx = newElementTypes.front().getContext();
+    return Base::get(ctx,newElementTypes);
+};
+
+
+class ProductSrcType : public TypeSource{
+public: static mlir::Type parseType(::mlir::DialectAsmParser &parser)  {
+    if (parser.parseLess())
         return Type();
-    SmallVector<mlir::Type, 1> elementTypes;
+    SmallVector<TypeSource,1> elementTypes;
     do {
-    SMLoc typeLoc = parser.getCurrentLocation();
-    mlir::Type elementType;
-    if (parser.parseType(elementType))
-        return nullptr;
-        /*if (!elementType.isa<mlir::IntegerType>()) {
-            parser.emitError(typeLoc, "element type must be an integer")
-                    << elementType;
-            return Type();
-        }*/
+        //SMLoc typeLoc = parser.getCurrentLocation();
+        TypeSource elementType;
+        if (parser.parseType(elementType))
+            return nullptr;
         elementTypes.push_back(elementType);
-    } while(succeeded(parser.parseOptionalComma()) || succeeded(parser.parseOptionalPlus()));
+    } while(succeeded(parser.parseOptionalPlus()));
     if (parser.parseGreater())
         return Type();
-    return TypeSource::get(elementTypes);
-}
+    return TypeSource::getTypeSource(elementTypes);
+    }
+};
 
-/// Cette fonction nous permet de print en format mlir une instance des types sources
-void AdtDialect::printType(::mlir::Type type, ::mlir::DialectAsmPrinter &os) const {
+class BasicLLVMType : public TypeSource{
+public: static mlir::Type parseType(::mlir::DialectAsmParser &parser){
+        if (parser.parseLess())
+            return Type();
+        SmallVector<mlir::Type, 1> elementTypes;
+        //SMLoc typeLoc = parser.getCurrentLocation();
+        mlir::Type elementType;
+        if (parser.parseType(elementType))
+                return nullptr;
+            elementTypes.push_back(elementType);
 
-}
+        if (parser.parseGreater())
+            return Type();
+        return TypeSource::getType(elementTypes);
+    }
+};
 
-class VarType : public TypeSource{
 
+class SumSrcType : public TypeSource{
+public: static mlir::Type parseType(::mlir::DialectAsmParser &parser)  {
+        if (parser.parseLess())
+            return Type();
+        SmallVector<Tag,1> elementTypes;
+        do {
+            //SMLoc typeLoc = parser.getCurrentLocation();
+            Tag elementType;
+            TypeSource srcType;
+            std::string operand;
+            if (failed(parser.parseString(&operand)))
+                return nullptr;
+            elementType.setNameSrcType(&operand);
+            if (parser.parseColon())
+                return nullptr;
+            if (parser.parseType(srcType))
+                return nullptr;
+            elementType.setTypeSource(&srcType);
+            elementTypes.push_back(elementType);
+        } while(succeeded(parser.parseOptionalComma()));
+        if (parser.parseGreater())
+            return Type();
+        return getTag(elementTypes);
+    }
 };
-// type intlgt = bits<lgt> represented as ilgt
-class IntType : public TypeSource{
+class BaseSrcType : public TypeSource{
+public: static mlir::Type parseType(::mlir::DialectAsmParser &parser){
 
+}
 };
 
-class RefType: public TypeSource{
+mlir::Type AdtDialect::parseType(::mlir::DialectAsmParser &parser) const{
+    StringRef keyword;
+    SMLoc typeLoc = parser.getCurrentLocation();
+    if (parser.parseKeyword(&keyword))
+        return Type();
+    //MLIRContext *context = getContext();
+    if (keyword == "product")
+        return ProductSrcType::parseType(parser);
+    if (keyword == "sum")
+        return SumSrcType::parseType(parser);
+    if (keyword == "base")
+        return BaseSrcType::parseType(parser);
+    if (keyword == "basic")
+        return BasicLLVMType::parseType(parser);
+    parser.emitError(typeLoc,"given keyword is unknown");
+    return Type();
+}
+
+/// On parse ici une instance du type type source (donc cette instance est un type aussi)
 
-};
 
-class ProType : public TypeSource{
+/// Cette fonction nous permet de print en format mlir une instance des types sources
+void AdtDialect::printType(::mlir::Type type, ::mlir::DialectAsmPrinter &printer) const {
+}
 
-};
 
-class SumType : public TypeSource{
 
-};
 #define GET_OP_CLASSES
 #include "Adt/AdtOps.cpp.inc"
+#include "Adt/AdtOpsDialect.cpp.inc"
 
 void AdtDialect::initialize() {
     addOperations<

test/Adt/Zarith.mlir

-!SumType = !adt.type<Small+Big>
+!integer = !adt.basic<i64>
+!SumType = !adt.sum<"Small":!integer,"Big":!integer>