Changes in / [def751f:ffec1bf]

Files:

• src/CodeGen/CodeGenerator.cc (modified) (1 diff)
• src/Parser/ExpressionNode.cc (modified) (1 diff)
• src/Parser/ParseNode.h (modified) (1 diff)
• src/ResolvExpr/CandidateFinder.cpp (modified) (1 diff)
• src/ResolvExpr/ConversionCost.cc (modified) (1 diff)
• src/ResolvExpr/Unify.cc (modified) (2 diffs)
• src/SynTree/Expression.h (modified) (1 diff)
• src/SynTree/SynTree.h (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/Parser/ExpressionNode.cc

@@ -509 +509 @@
 } // build_varref
 
-QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name ) {
-        Type * targetType = maybeMoveBuildType( decl_node );
-        return new QualifiedNameExpr( targetType, name->name );
-        return nullptr;
-}
-
 DimensionExpr * build_dimensionref( const string * name ) {
         DimensionExpr * expr = new DimensionExpr( *name );

src/Parser/ParseNode.h

@@ -183 +183 @@
 
 NameExpr * build_varref( const std::string * name );
-QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name );
 DimensionExpr * build_dimensionref( const std::string * name );
 

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; // 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));
-                                                //      }
-                                                // }
+                                                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));
+                                                        }
+                                                } 
                                                 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/ResolvExpr/Unify.cc

@@ -165 +165 @@
                 ast::Type * newFirst  = shallowCopy( first  );
                 ast::Type * newSecond = shallowCopy( second );
-                if ( auto temp = dynamic_cast<const ast::EnumInstType *>(first) ) {
-                        if ( !dynamic_cast< const ast::EnumInstType * >( second ) ) {
-                                const ast::EnumDecl * baseEnum = dynamic_cast<const ast::EnumDecl *>(temp->base.get());
-                                if ( auto t = baseEnum->base.get() ) {
-                                        newFirst = ast::shallowCopy( t );
-                                }
-                        }
-                } else if ( auto temp = dynamic_cast<const ast::EnumInstType *>(second) ) {
-                        const ast::EnumDecl * baseEnum = dynamic_cast<const ast::EnumDecl *>(temp->base.get());
-                        if ( auto t = baseEnum->base.get() ) {
-                                newSecond = ast::shallowCopy( t );
-                        }
-                }
-
                 newFirst ->qualifiers = {};
                 newSecond->qualifiers = {};
@@ -1002 +988 @@
                                 if ( isTuple && isTuple2 ) {
                                         ++it; ++jt;  // skip ttype parameters before break
-                                } else if ( isTuple ) { 
+                                } else if ( isTuple ) {
                                         // bundle remaining params into tuple
                                         pty2 = tupleFromExprs( param2, jt, params2.end(), pty->qualifiers );

src/SynTree/Expression.h

@@ -163 +163 @@
 };
 
-// [Qualifier].name; Qualifier is the type_name from the parser
-class QualifiedNameExpr : public Expression {
-  public:
-        Type * type; // Convert to [parent] QualifiedNameExpr
-        std::string name; // Convert from NameExpr
-
-        QualifiedNameExpr( Type * type, std::string name): 
-                Expression(), type(type), name(name) {
-                std::cout << "Making QualifiedNameExpr" << std::endl;
-                print( std::cout );
-        }
-        QualifiedNameExpr( const QualifiedNameExpr & other): Expression(other), type(other.type), name(other.name) {
-
-        }
-        virtual ~QualifiedNameExpr() {
-                delete type;
-        }
-
-        virtual QualifiedNameExpr * clone() const override {
-                return new QualifiedNameExpr( * this );
-        }
-        virtual void accept( Visitor & v ) override { (void)v; }
-        virtual void accept( Visitor & v ) const override { (void)v; }
-        virtual Expression * acceptMutator( Mutator & m ) override { (void) m;return nullptr; }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const override {
-                type->print( os, indent );
-                std::cout << name << std::endl;
-        }
-};
-
 /// VariableExpr represents an expression that simply refers to the value of a named variable.
 /// Does not take ownership of var.

src/SynTree/SynTree.h

@@ -103 +103 @@
 class DefaultArgExpr;
 class GenericExpr;
-class QualifiedNameExpr;
 
 class Type;

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() {
-     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;
+    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;
 }