Changeset d958834b

Timestamp:

Jul 25, 2022, 12:29:40 PM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

b729c01

Parents:

d4b37ab

Message:

Save a minimal compilable version. The enum pointer assignment/comparsion is fixed

Files:

• src/CodeGen/CodeGenerator.cc (modified) (1 diff)
• src/ResolvExpr/CandidateFinder.cpp (modified) (1 diff)
• src/ResolvExpr/ConversionCost.cc (modified) (1 diff)
• src/Validate/Autogen.cpp (modified) (1 diff)
• tests/enum_tests/structEnum.cfa (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -289 +289 @@
                                         if ( obj->get_init() ) {
                                                 obj->get_init()->accept( *visitor );
-                                                last_val = ((ConstantExpr *)(((SingleInit *)(obj->init))->value))->constant.get_ival();
+                                                // last_val = ((ConstantExpr *)(((SingleInit *)(obj->init))->value))->constant.get_ival();
                                         } else {
                                                 output << ++last_val;

src/ResolvExpr/CandidateFinder.cpp

@@ -897 +897 @@
                                                 }
 
-                                                if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);
-                                                else if (const ast::EnumInstType * enumInst = argType.as<ast::EnumInstType>()) {
-                                                        const ast::EnumDecl * enumDecl = enumInst->base;
-                                                        if ( const ast::Type* enumType = enumDecl->base ) {
-                                                                // instance of enum (T) is a instance of type (T) 
-                                                                funcFinder.otypeKeys.insert(Mangle::mangle(enumType, Mangle::NoGenericParams | Mangle::Type));
-                                                        } else {
-                                                                // instance of an untyped enum is techically int
-                                                                funcFinder.otypeKeys.insert(Mangle::mangle(enumDecl, Mangle::NoGenericParams | Mangle::Type));
-                                                        }
-                                                } 
+                                                if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);                                             
+                                                // else if (const ast::EnumInstType * enumInst = argType.as<ast::EnumInstType>()) {
+                                                //      const ast::EnumDecl * enumDecl = enumInst->base; // Here
+                                                //      if ( const ast::Type* enumType = enumDecl->base ) {
+                                                //              // instance of enum (T) is a instance of type (T) 
+                                                //              funcFinder.otypeKeys.insert(Mangle::mangle(enumType, Mangle::NoGenericParams | Mangle::Type));
+                                                //      } else {
+                                                //              // instance of an untyped enum is techically int
+                                                //              funcFinder.otypeKeys.insert(Mangle::mangle(enumDecl, Mangle::NoGenericParams | Mangle::Type));
+                                                //      }
+                                                // }
                                                 else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type));
                                         }

src/ResolvExpr/ConversionCost.cc

@@ -695 +695 @@
         if ( const ast::Type * baseType = baseEnum->base ) {
                 cost = costCalc( baseType, dst, srcIsLvalue, symtab, env );
+                // cost = Cost::safe;
         } else {
                 (void)enumInstType;

src/Validate/Autogen.cpp

@@ -235 +235 @@
         // Must visit children (enum constants) to add them to the symbol table.
         if ( !enumDecl->body ) return;
+
+        // if ( auto enumBaseType = enumDecl->base ) {
+        //      if ( auto enumBaseTypeAsStructInst = dynamic_cast<const ast::StructInstType *>(enumBaseType.get()) ) {
+        //              const ast::StructDecl * structDecl = enumBaseTypeAsStructInst->base.get();
+        //              this->previsit( structDecl );
+        //      }
+        // }
 
         ast::EnumInstType enumInst( enumDecl->name );

tests/enum_tests/structEnum.cfa

@@ -2 +2 @@
 
 struct Point {
-    int x;
-    char y;
+     int x;
+     char y;
 };
 
 enum(Point) PointEnum {
-    first={
-        100,
-        'c'
-    },
-    second={
-        200,
-        'a'
-    }
+     first={
+         100,
+         'c'
+     },
+     second={
+         200,
+         'a'
+     }
 };
+
+PointEnum foo(PointEnum in) {
+     return in;
+}
 
 // The only valid usage
 struct Point apple = first;
 // Failed due to Qualified name is currently unimplemented.
-// struct Point banana = PointEnum.first;
+struct Point banana = PointEnum.first;
 
 int main() {
-    printf("%d %c\n", apple.x, apple.y);
-    // Failed; enumInstType is now not a real type and not instantiated.
-    // Not sure if we want that
-    // printf("%d %c\n", second.x, second.y);
-    return 0;
+     PointEnum vals = second;
+     PointEnum val2;
+     // P1
+     val2 = vals;
+
+     printf("%d %c\n", apple.x, apple.y);
+     // Failed; enumInstType is now not a real type and not instantiated.
+     // Not sure if we want that
+     // printf("%d %c\n", second.x, second.y);
+     return 0;
 }