Changes in src/AST/Convert.cpp [3e5dd913:361bf01]

File:

• src/AST/Convert.cpp (modified) (11 diffs)

src/AST/Convert.cpp

@@ -205 +205 @@
                 ftype->parameters = get<DeclarationWithType>().acceptL(node->params);
 
-                ftype->forall = get<TypeDecl>().acceptL( node->type_params );
-                if (!node->assertions.empty()) {
-                        assert(!ftype->forall.empty());
-                        // find somewhere to place assertions back, for convenience it is the last slot
-                        ftype->forall.back()->assertions = get<DeclarationWithType>().acceptL(node->assertions);
-                }
+                ftype->forall = get<TypeDecl>().acceptL( node->type->forall );
 
                 visitType(node->type, ftype);
@@ -607 +602 @@
 
                 for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
-                        rslt->add( src_i->first.typeString(),
+                        rslt->add( src_i->first,
                                    get<Type>().accept1(src_i->second) );
+                }
+
+                for (decltype(src->beginVar()) src_i = src->beginVar(); src_i != src->endVar(); src_i++) {
+                        rslt->addVar( src_i->first,
+                                      get<Expression>().accept1(src_i->second) );
                 }
 
@@ -1212 +1212 @@
                 // ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
                 // ty->parameters = get<DeclarationWithType>().acceptL( node->params );
-
-                auto types = get<TypeInstType>().acceptL( node->forall );
-                for (auto t : types) {
-                        auto newT = new TypeDecl(*t->baseType);
-                        newT->name = t->name; // converted by typeString()
-                        for (auto asst : newT->assertions) delete asst;
-                        newT->assertions.clear();
-                        ty->forall.push_back(newT);
-                }
-                auto assts = get<VariableExpr>().acceptL( node->assertions );
-                if (!assts.empty()) {
-                        assert(!types.empty());
-                        for (auto asst : assts) {
-                                auto newDecl = new ObjectDecl(*strict_dynamic_cast<ObjectDecl*>(asst->var));
-                                delete newDecl->type;
-                                newDecl->type = asst->result->clone();
-                                newDecl->storageClasses.is_extern = true; // hack
-                                ty->forall.back()->assertions.push_back(newDecl);
-                        }
-                }
-
+                ty->forall = get<TypeDecl>().acceptL( node->forall );
                 return visitType( node, ty );
         }
@@ -1319 +1299 @@
                         ty = new TypeInstType{
                                 cv( node ),
-                                node->typeString(),
+                                node->name,
                                 get<TypeDecl>().accept1( node->base ),
                                 get<Attribute>().acceptL( node->attributes )
@@ -1326 +1306 @@
                         ty = new TypeInstType{
                                 cv( node ),
-                                node->typeString(),
+                                node->name,
                                 node->kind == ast::TypeDecl::Ftype,
                                 get<Attribute>().acceptL( node->attributes )
@@ -1451 +1431 @@
         /// at conversion stage, all created nodes are guaranteed to be unique, therefore
         /// const_casting out of smart pointers is permitted.
-        std::unordered_map< const BaseSyntaxNode *, ast::readonly<ast::Node> > cache = {};
+        std::unordered_map< const BaseSyntaxNode *, ast::ptr<ast::Node> > cache = {};
 
         // Local Utilities:
@@ -1585 +1565 @@
                 // can function type have attributes? seems not to be the case.
                 // visitType(old->type, ftype);
-
-                // collect assertions and put directly in FunctionDecl
-                std::vector<ast::ptr<ast::DeclWithType>> assertions;
-                for (auto & param: forall) {
-                        for (auto & asst: param->assertions) {
-                                assertf(asst->unique(), "newly converted decl must be unique");
-                                assertions.emplace_back(asst);
-                        }
-                        auto mut = param.get_and_mutate();
-                        assertf(mut == param, "newly converted decl must be unique");
-                        mut->assertions.clear();
-                }
 
                 auto decl = new ast::FunctionDecl{
@@ -1616 +1584 @@
                 cache.emplace( old, decl );
 
-                decl->assertions = std::move(assertions);
                 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
@@ -2099 +2066 @@
         }
 
-        // TypeSubstitution shouldn't exist yet in old.
         ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {
-                
+
                 if (!old) return nullptr;
-                if (old->empty()) return nullptr;
-                assert(false);
-
-                /*
+
                 ast::TypeSubstitution *rslt = new ast::TypeSubstitution();
 
@@ -2114 +2077 @@
                 }
 
+                for (decltype(old->beginVar()) old_i = old->beginVar(); old_i != old->endVar(); old_i++) {
+                        rslt->addVar( old_i->first,
+                                      getAccept1<ast::Expr>(old_i->second) );
+                }
+
                 return rslt;
-                */
         }
 
@@ -2643 +2610 @@
                         ty->params.emplace_back(v->get_type());
                 }
-                // xxx - when will this be non-null?
-                // will have to create dangling (no-owner) decls to be pointed to
-                auto foralls = GET_ACCEPT_V( forall, TypeDecl );
-
-                for (auto & param : foralls) {
-                        ty->forall.emplace_back(new ast::TypeInstType(param->name, param));
-                        for (auto asst : param->assertions) {
-                                ty->assertions.emplace_back(new ast::VariableExpr({}, asst));
-                        }
-                }
+                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
                 visitType( old, ty );
         }