Changes in / [69867ad9:caaf424]

Files:

• libcfa/src/enum.cfa (deleted)
• src/ResolvExpr/CandidateFinder.cpp (modified) (3 diffs)
• src/ResolvExpr/CastCost.cc (modified) (2 diffs)
• src/ResolvExpr/ConversionCost.cc (modified) (3 diffs)
• src/Validate/HoistStruct.cpp (modified) (5 diffs)
• src/Validate/ImplementEnumFunc.cpp (modified) (8 diffs)
• src/main.cc (modified) (2 diffs)
• tests/enum_tests/.expect/funcEnum.txt (deleted)
• tests/enum_tests/.expect/position.txt (deleted)
• tests/enum_tests/.expect/stringEnum.txt (modified) (1 diff)
• tests/enum_tests/anonymous.cfa (modified) (1 diff)
• tests/enum_tests/enumInlineValue.cfa (modified) (1 diff)
• tests/enum_tests/position.cfa (modified) (2 diffs)
• tests/enum_tests/stringEnum.cfa (modified) (2 diffs)
• tests/enum_tests/typedIntEnum.cfa (modified) (2 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -906 +906 @@
                                 }
                                 CandidateRef & choice = winners.front();
-                                choice->cost.incSafe();
+                                choice->cost.incVar();
                                 candidates.emplace_back( std::move(choice) );
                         }
@@ -1376 +1376 @@
                         ast::Expr * newExpr = data.combine( nameExpr->location, cost );
 
-                        // bool bentConversion = false;
-                        // if ( auto inst = newExpr->result.as<ast::EnumInstType>() ) {
-                        //      if ( inst->base && inst->base->base ) {
-                        //              bentConversion = true;
-                        //      }
-                        // }
-
-                        // CandidateRef newCand = std::make_shared<Candidate>(
-                        //      newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, bentConversion? Cost::safe: Cost::zero,
-                        //      cost );
+                        bool bentConversion = false;
+                        if ( auto inst = newExpr->result.as<ast::EnumInstType>() ) {
+                                if ( inst->base && inst->base->base ) {
+                                        bentConversion = true;
+                                }
+                        }
+
                         CandidateRef newCand = std::make_shared<Candidate>(
-                                newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero,
+                                newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, bentConversion? Cost::safe: Cost::zero,
                                 cost );
+
                         if (newCand->expr->env) {
                                 newCand->env.add(*newCand->expr->env);
@@ -1831 +1829 @@
                                         Cost cost = Cost::zero;
                                         ast::Expr * newExpr = data.combine( expr->location, cost );
-                                        // CandidateRef newCand =
-                                        //      std::make_shared<Candidate>(
-                                        //              newExpr, copy( tenv ), ast::OpenVarSet{},
-                                        //              ast::AssertionSet{}, Cost::safe, cost
-                                        //      );
                                         CandidateRef newCand =
                                                 std::make_shared<Candidate>(
                                                         newExpr, copy( tenv ), ast::OpenVarSet{},
-                                                        ast::AssertionSet{}, Cost::zero, cost
+                                                        ast::AssertionSet{}, Cost::safe, cost
                                                 );
+
                                         if (newCand->expr->env) {
                                                 newCand->env.add(*newCand->expr->env);

src/ResolvExpr/CastCost.cc

@@ -53 +53 @@
                         } else {
                                 cost = conversionCost( basicType, dst, srcIsLvalue, symtab, env );
-                                if ( Cost::unsafe < cost ) {
-                                        if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
-                                                assert(enumInst->base->base);
-                                                cost = Cost::unsafe;
-                                        }
-                                }
                         }
-                }
-
-                void postvisit( const ast::ZeroType * zero ) {
-                        // auto ptr = dynamic_cast< const ast::PointerType * >( dst );
-                        // if ( ptr && basicType->isInteger() ) {
-                        //      // needed for, e.g. unsigned long => void *
-                        //      cost = Cost::unsafe;
-                        // } else {
-                        cost = conversionCost( zero, dst, srcIsLvalue, symtab, env );
-                        if ( Cost::unsafe < cost ) {
-                                if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
-                                        assert(enumInst->base->base);
-                                        cost = Cost::unsafe;
-                                }
-                        }
-                        // }
-                }
-
-                void postvisit( const ast::OneType * one ) {
-                        // auto ptr = dynamic_cast< const ast::PointerType * >( dst );
-                        // if ( ptr && basicType->isInteger() ) {
-                        //      // needed for, e.g. unsigned long => void *
-                        //      cost = Cost::unsafe;
-                        // } else {
-                        cost = conversionCost( one, dst, srcIsLvalue, symtab, env );
-                        if ( Cost::unsafe < cost ) {
-                                if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
-                                        assert(enumInst->base->base);
-                                        cost = Cost::unsafe;
-                                }
-                        }
-                        // }
                 }
 
@@ -118 +80 @@
                                         cost = Cost::unsafe;
                                 }
-                        }
-                }
-
-                void postvist( const ast::EnumInstType * ) {
-                        if ( auto basic = dynamic_cast< const ast::BasicType * >(dst) ) {
-                                if ( basic->isInteger() ) cost = Cost::unsafe;
                         }
                 }

src/ResolvExpr/ConversionCost.cc

@@ -284 +284 @@
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
-                        cost = Cost::unsafe;
+                        cost = Cost::zero;
+                        cost.incUnsafe();
                 }
         }
@@ -481 +482 @@
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
-                        cost = Cost::unsafe;
+                        cost = Cost::zero;
+                        cost.incUnsafe();
                 }
         }
@@ -502 +504 @@
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
-                        cost = Cost::unsafe;
+                        cost = Cost::zero;
+                        cost.incUnsafe();
                 }
         }

src/Validate/HoistStruct.cpp

@@ -27 +27 @@
 namespace {
 
-/// Is this a declaration can appear in a struct/union and should be hoisted?
 bool shouldHoist( ast::Decl const * decl ) {
         return dynamic_cast< ast::StructDecl const * >( decl )
@@ -35 +34 @@
 }
 
-/// Helper that updates an InstType if the base name could be updated.
-template<typename InstType>
-InstType const * preInstType( InstType const * type ) {
-        assert( type->base );
-        if ( nullptr == type->base->parent ) return type;
-        auto mut = ast::mutate( type );
-        mut->name = mut->base->name;
-        return mut;
-}
-
-/// Update StructInstType and UnionInstType names.
-struct NameUpdater {
-        ast::StructInstType const * previsit( ast::StructInstType const * type ) {
-                return preInstType( type );
-        }
-
-        ast::UnionInstType const * previsit( ast::UnionInstType const * type ) {
-                return preInstType( type );
-        }
-};
-
-ast::Decl const * updateNames( ast::Decl const * decl ) {
-        ast::Pass<NameUpdater> visitor;
-        return decl->accept( visitor );
-}
-
-/* This pass hoists from structs/unions. Hoisted declarations should always
+/* This pass also does some renaming and internal field alteration, but the
+ * complex part is the actual hoisting. Hoisted declarations should always
  * appear before the declaration they are hoisted out of and if two types are
  * nested in the same declaration their order should not change.
- * It also sets up parent relationships, does name mangling of hoisted types
- * and updates instance types of the hoisted types.
  */
 struct HoistStructCore final :
@@ -124 +96 @@
                 auto mut = ast::mutate( decl );
                 mut->parent = parent;
+                mut->name = qualifiedName( mut );
                 extendParams( mut->params, parent->params );
                 decl = mut;
@@ -143 +116 @@
                 }
         }
-        // Is this a nested type? Then update the name, after the parent's name
-        // has been updated (hence the post visit).
-        if ( mut->parent ) {
-                mut->name = qualifiedName( mut );
-        // Top level type that has hoisted? Then do a second pass subpass to make
-        // sure we update instance type names after the declaration is renamed.
-        } else if ( !declsToAddBefore.empty() ) {
-                for ( ast::ptr<ast::Decl> & member : mut->members ) {
-                        member = updateNames( member.get() );
-                }
-                for ( ast::ptr<ast::Decl> & declToAdd : declsToAddBefore ) {
-                        declToAdd = updateNames( declToAdd );
-                }
-        }
         return mut;
 }
@@ -208 +167 @@
 }
 
+template<typename InstType>
+InstType const * preInstType( InstType const * type ) {
+        assert( type->base );
+        auto mut = ast::mutate( type );
+        mut->name = mut->base->name;
+        return mut;
+}
+
 ast::StructInstType const * HoistStructCore::previsit( ast::StructInstType const * type ) {
         return preInstType( preCollectionInstType( type ) );

src/Validate/ImplementEnumFunc.cpp

@@ -30 +30 @@
         void genAttrFunctions();
         void genSuccPredPosn();
-        // void genSuccPredDecl();
+        void genSuccPredDecl();
 
         void appendReturnThis(ast::FunctionDecl* decl) {
@@ -73 +73 @@
         const ast::Decl* getDecl() const { return decl; }
 
-        // Implement Bounded trait for enum
-    void genBoundedFunctions();
-        // Implement Serial trait for enum
-        void genSerialTraitFuncs();
-
-        // Bounded trait
-        ast::FunctionDecl* genLowerBoundProto() const;
-        ast::FunctionDecl* genUpperBoundProto() const;
-        void genLowerBoundBody(ast::FunctionDecl* func) const;
-        void genUpperBoundBody(ast::FunctionDecl* func) const;
-
         ast::FunctionDecl* genPosnProto() const;
         ast::FunctionDecl* genLabelProto() const;
         ast::FunctionDecl* genValueProto() const;
-
-        // Serial trait
-        ast::FunctionDecl* genFromIntProto() const;
-        ast::FunctionDecl* genFromInstanceProto() const;
         ast::FunctionDecl* genSuccProto() const;
         ast::FunctionDecl* genPredProto() const;
-
-        void genFromIntBody(ast::FunctionDecl *) const; 
-        void genFromInstanceBody(ast::FunctionDecl *) const;
-        ////////////////
 
         ast::FunctionDecl* genSuccPosProto() const;
@@ -308 +289 @@
 
 ast::FunctionDecl* EnumAttrFuncGenerator::genPosnProto() const {
-    return genProto(
-        "posE",
-        {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
-        {new ast::ObjectDecl(getLocation(), "_ret",
-            new ast::BasicType(ast::BasicKind::UnsignedInt))});
+        return genProto(
+                "posE",
+                {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
+                {new ast::ObjectDecl(getLocation(), "_ret",
+                        new ast::BasicType(ast::BasicKind::UnsignedInt))});
 }
 
@@ -332 +313 @@
 }
 
-ast::FunctionDecl* EnumAttrFuncGenerator::genFromIntProto() const {
-        return genProto(
-                "fromInt",
-                {new ast::ObjectDecl(getLocation(), "_i", new ast::BasicType(ast::BasicKind::UnsignedInt))},
-                {new ast::ObjectDecl(getLocation(), "_ret", new ast::EnumInstType(decl))}
-        );
-}
-
-ast::FunctionDecl* EnumAttrFuncGenerator::genFromInstanceProto() const {
-        return genProto(
-                "fromInstance",
-                {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))},
-                {new ast::ObjectDecl(getLocation(), "_ret", new ast::BasicType(ast::BasicKind::UnsignedInt))}
-        );
-}
-
-void EnumAttrFuncGenerator::genFromIntBody(ast::FunctionDecl* func) const {
-        auto params = func->params;
-        assert( params.size() == 1 );
-        auto param = params.front();
-        auto castExpr = new ast::CastExpr(
-                func->location,
-                new ast::VariableExpr(func->location, param),
-                new ast::EnumInstType(decl),
-                ast::GeneratedFlag::ExplicitCast
-        );
-        func->stmts = new ast::CompoundStmt(
-                func->location, {new ast::ReturnStmt(func->location, castExpr)}
-        );
-}
-
-void EnumAttrFuncGenerator::genFromInstanceBody(ast::FunctionDecl* func) const {
-        auto params = func->params;
-        assert( params.size() == 1 );
-        auto param = params.front();
-        ast::UntypedExpr* untyped = ast::UntypedExpr::createCall(
-                func->location, "posE", { new ast::VariableExpr(func->location, param) });
-        func->stmts = new ast::CompoundStmt(
-                func->location, {new ast::ReturnStmt(func->location, untyped)}
-        );
-}
-
-void EnumAttrFuncGenerator::genSerialTraitFuncs() {
-        auto fromIntProto = genFromIntProto();
-        produceForwardDecl(fromIntProto);
-        genFromIntBody(fromIntProto);
-        produceDecl(fromIntProto);
-
-        auto fromInstanceProto = genFromInstanceProto();
-        produceForwardDecl(fromInstanceProto);
-        genFromInstanceBody(fromInstanceProto);
-        produceDecl(fromInstanceProto);
-
-        auto succProto = genSuccProto();
-        auto predProto = genPredProto();
-        produceForwardDecl(succProto);
-        produceForwardDecl(predProto);
-}
-
 ast::FunctionDecl* EnumAttrFuncGenerator::genSuccProto() const {
         return genProto(
@@ -405 +327 @@
                 {new ast::ObjectDecl(getLocation(), "_ret",
                                      new ast::EnumInstType(decl))});
-}
-
-ast::FunctionDecl* EnumAttrFuncGenerator::genLowerBoundProto() const {
-    return genProto("lowerBound", {}, {
-        new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))
-    });
-}
-
-ast::FunctionDecl* EnumAttrFuncGenerator::genUpperBoundProto() const {
-    return genProto("upperBound", {}, {
-        new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))
-    });
-}
-
-void EnumAttrFuncGenerator::genLowerBoundBody(ast::FunctionDecl* func) const {
-        const CodeLocation & loc = func->location;
-        auto mem = decl->members.front();
-        // auto expr = new ast::QualifiedNameExpr( loc, decl, mem->name );
-        // expr->result = new ast::EnumInstType( decl );
-        auto expr = new ast::NameExpr( loc, mem->name );
-        func->stmts = new ast::CompoundStmt( loc, {new ast::ReturnStmt(loc, expr)});
-}
-
-void EnumAttrFuncGenerator::genUpperBoundBody(ast::FunctionDecl* func) const {
-        const CodeLocation & loc = func->location;
-        auto mem = decl->members.back();
-        auto expr = new ast::NameExpr( loc, mem->name );
-        // expr->result = new ast::EnumInstType( decl );
-        func->stmts = new ast::CompoundStmt( loc, {new ast::ReturnStmt(loc, expr)});    
-}
-
-void EnumAttrFuncGenerator::genBoundedFunctions() {
-        ast::FunctionDecl * upperDecl = genUpperBoundProto();
-        produceForwardDecl(upperDecl);
-        genUpperBoundBody(upperDecl);
-        produceDecl(upperDecl);
-
-        ast::FunctionDecl * lowerDecl = genLowerBoundProto();
-        produceForwardDecl(lowerDecl);
-        genLowerBoundBody(lowerDecl);
-        produceDecl(lowerDecl);
 }
 
@@ -492 +373 @@
                 func->location, "?[?]",
                 {new ast::NameExpr(func->location, arrDecl->name),
-                new ast::CastExpr(
-                        func->location,
-                        new ast::VariableExpr( func->location, func->params.front() ),
-                        new ast::EnumAttrType( new ast::EnumInstType(decl),
-                                ast::EnumAttribute::Posn))});
+                        new ast::CastExpr(
+                                func->location,
+                                new ast::VariableExpr( func->location, func->params.front() ),
+                                new ast::EnumAttrType( new ast::EnumInstType(decl),
+                                        ast::EnumAttribute::Posn))});
         func->stmts = new ast::CompoundStmt(
                 func->location, {new ast::ReturnStmt(func->location, untyped)});
@@ -569 +450 @@
 
 void EnumAttrFuncGenerator::genAttrFunctions() {
-        genAttributesDecls(ast::EnumAttribute::Value);
-        genAttributesDecls(ast::EnumAttribute::Label);
-        genAttributesDecls(ast::EnumAttribute::Posn);   
-}
-
-// void EnumAttrFuncGenerator::genSuccPredDecl() {
-//      auto succProto = genSuccProto();
-//      auto predProto = genPredProto();
-
-//      produceForwardDecl(succProto);
-//      produceForwardDecl(predProto);
-// }
+        if (decl->base) {
+                genAttributesDecls(ast::EnumAttribute::Value);
+                genAttributesDecls(ast::EnumAttribute::Label);
+                genAttributesDecls(ast::EnumAttribute::Posn);
+        }
+}
+
+void EnumAttrFuncGenerator::genSuccPredDecl() {
+        if (decl->base) {
+                auto succProto = genSuccProto();
+                auto predProto = genPredProto();
+
+                produceForwardDecl(succProto);
+                produceForwardDecl(predProto);
+        }
+}
 
 void EnumAttrFuncGenerator::genSuccPredPosn() {
-        ast::FunctionDecl* succ = genSuccPredFunc(true);
-        ast::FunctionDecl* pred = genSuccPredFunc(false);
-
-        produceDecl(succ);
-        produceDecl(pred);
+        if (decl->base) {
+                ast::FunctionDecl* succ = genSuccPredFunc(true);
+                ast::FunctionDecl* pred = genSuccPredFunc(false);
+
+                produceDecl(succ);
+                produceDecl(pred);
+        }
 }
 
@@ -595 +482 @@
         genAttrStandardFuncs();
         genAttrFunctions();
-        genSerialTraitFuncs();
-        genSuccPredPosn();
-        // problematic
-        genBoundedFunctions();
+        genSuccPredDecl();
+        genSuccPredPosn(); // Posn
         // Now export the lists contents.
         decls.splice(decls.end(), forwards);

src/main.cc

@@ -325 +325 @@
                 PASS( "Validate Generic Parameters", Validate::fillGenericParameters, transUnit );
                 PASS( "Translate Dimensions", Validate::translateDimensionParameters, transUnit );
-                // Need to happen before fixing returns because implementEnumFunc has ReturnStmt
-                
-                PASS( "Generate Enum Attributes Functions", Validate::implementEnumFunc, transUnit );
                 PASS( "Check Function Returns", Validate::checkReturnStatements, transUnit );
                 PASS( "Fix Return Statements", InitTweak::fixReturnStatements, transUnit );
@@ -336 +333 @@
 
                 PASS( "Generate Autogen Routines", Validate::autogenerateRoutines, transUnit );
-                
+                PASS( "Generate Enum Attributes Functions", Validate::implementEnumFunc, transUnit );
+
                 PASS( "Implement Actors", Concurrency::implementActors, transUnit );
                 PASS( "Implement Virtual Destructors", Virtual::implementVirtDtors, transUnit );

tests/enum_tests/.expect/stringEnum.txt

@@ -1 +1 @@
 zero: zero, one: one
-zero: 0, one: 1

tests/enum_tests/anonymous.cfa

@@ -1 @@
-#include <fstream.hfa>
+#include <stdio.h>
 enum(unsigned long int ) { nthreads = 17 };
 
 int main() {
-    sout | nthreads;
+    printf("%lu", nthreads);
 }
 

tests/enum_tests/enumInlineValue.cfa

@@ -12 +12 @@
     enum enumB val = A;
     sout | "enumB.A is" | val;
-    enum enumB val2 = enumB.B;
+    enum enumB val2= enumB.B;
     sout | "enumB.B is" | val2;
     sout | "enumB.D is" | enumB.D;

tests/enum_tests/position.cfa

@@ -12 +12 @@
 
 int main () {
-    Colour fishy;
-    fishy = Colour.Green; 
-    fishy;
+    Colour fishy; // posE()
+    fishy = Colour.Green; // value(fishy) = Colour.Green;
+    fishy; // valueE( fishy );
+
+    printf( "Compile Time: blue value: %s, position: %d, label: %s, default return value: %s \n", valueE(Colour.Blue), posE(Colour.Blue), labelE(Colour.Blue), Colour.Blue );
+    printf( "Runtime: fishy value: %s, position: %d, label: %s, default return value: %s\n", valueE(fishy), posE(fishy), labelE(fishy), fishy );
     Colour c2 = fishy;
-
-    sout | "Compile Time: blue value: " | valueE(Colour.Blue) | ", position: " | posE(Colour.Blue) | ", label: " | labelE(Colour.Blue) | ", default return value: " | Colour.Blue;
-    sout | "Runtime: fishy value: " | valueE(fishy) | ", position: " | posE(fishy) | ", label: " | labelE(fishy) | ", default return value: " | fishy;
-    sout | "Runtime: C2 value: " | valueE(c2) | ", position: " | posE(c2) | ", label: " | labelE(c2) | ", default return value: " | c2;
+    printf( "Runtime: C2 value: %s, position: %d, label: %s, default return value: %s\n", valueE(c2), posE(c2), labelE(c2), c2 );
     Colour.Red;
     char * ao = Colour.Red;
@@ -29 +29 @@
     Plain a = B;
     printf( "%d \n", a );
-    
 }

tests/enum_tests/stringEnum.cfa

@@ -1 @@
-#include <fstream.hfa>
 #include <stdio.h>
 
@@ -8 +7 @@
 
 int main() {
-    sout | "zero: "| zero | ", one: " | one;
-    printf("zero: %d, one: %d\n", zero, one);
+    printf("zero: %s, one: %s\n", zero, one);
     return 0;
 }

tests/enum_tests/typedIntEnum.cfa

@@ -1 @@
-#include <fstream.hfa>
+#include <stdio.h>
 
 enum(int) IntEnum {
@@ -12 +12 @@
 
 int main() {
-    sout | "0=" | zero;
-    sout | "1=" | one;
-    sout | "1000=" | thousand;
-    sout | "1001=" | thousand_one;
-    sout | "2000=" | two_thousand;
-    sout | "2001=" | two_thousand_one;
-    sout | "2002=" | two_thousand_two;
+    printf("0=%d\n", zero);
+    printf("1=%d\n", one);
+    printf("1000=%d\n", thousand);
+    printf("1001=%d\n", thousand_one);
+    printf("2000=%d\n", two_thousand);
+    printf("2001=%d\n", two_thousand_one);
+    printf("2002=%d\n", two_thousand_two);
     return 0;
 }