Changes in src/AST/Convert.cpp [3e5dd913:23954b6]

File:

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

src/AST/Convert.cpp

@@ -55 +55 @@
 
 // these need to be accessed in new FixInit now
-ast::ptr<ast::Type> sizeType = nullptr;
-const ast::FunctionDecl * dereferenceOperator = nullptr;
-const ast::StructDecl   * dtorStruct = nullptr;
-const ast::FunctionDecl * dtorStructDestroy = nullptr;
+ast::Type * sizeType = nullptr;
+ast::FunctionDecl * dereferenceOperator = nullptr;
+ast::StructDecl   * dtorStruct = nullptr;
+ast::FunctionDecl * dtorStructDestroy = nullptr;
 
 }
@@ -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);
@@ -238 +233 @@
         const ast::Decl * namedTypePostamble( NamedTypeDecl * decl, const ast::NamedTypeDecl * node ) {
                 // base comes from constructor
+                decl->parameters = get<TypeDecl>().acceptL( node->params );
                 decl->assertions = get<DeclarationWithType>().acceptL( node->assertions );
                 declPostamble( decl, node );
@@ -607 +603 @@
 
                 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 +1213 @@
                 // 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 );
         }
 
         const ast::Type * postvisit( const ast::BaseInstType * old, ReferenceToType * ty ) {
+                ty->forall = get<TypeDecl>().acceptL( old->forall );
                 ty->parameters = get<Expression>().acceptL( old->params );
                 ty->hoistType = old->hoistType;
@@ -1319 +1301 @@
                         ty = new TypeInstType{
                                 cv( node ),
-                                node->typeString(),
+                                node->name,
                                 get<TypeDecl>().accept1( node->base ),
                                 get<Attribute>().acceptL( node->attributes )
@@ -1326 +1308 @@
                         ty = new TypeInstType{
                                 cv( node ),
-                                node->typeString(),
+                                node->name,
                                 node->kind == ast::TypeDecl::Ftype,
                                 get<Attribute>().acceptL( node->attributes )
@@ -1451 +1433 @@
         /// 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 +1567 @@
                 // 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 +1586 @@
                 cache.emplace( old, decl );
 
-                decl->assertions = std::move(assertions);
                 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
@@ -1735 +1704 @@
                 cache.emplace( old, decl );
                 decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
+                decl->params     = GET_ACCEPT_V(parameters, TypeDecl);
                 decl->extension  = old->extension;
                 decl->uniqueId   = old->uniqueId;
@@ -1750 +1720 @@
                 );
                 decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
+                decl->params     = GET_ACCEPT_V(parameters, TypeDecl);
                 decl->extension  = old->extension;
                 decl->uniqueId   = old->uniqueId;
@@ -2099 +2070 @@
         }
 
-        // 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 +2081 @@
                 }
 
+                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 +2614 @@
                         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 );
         }
 
         void postvisit( const ReferenceToType * old, ast::BaseInstType * ty ) {
+                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
                 ty->params = GET_ACCEPT_V( parameters, Expr );
                 ty->hoistType = old->hoistType;
@@ -2844 +2807 @@
         ConverterOldToNew c;
         ast::TranslationUnit unit;
-        if (Validate::SizeType) {
-                // this should be a BasicType.
-                auto old = strict_dynamic_cast<BasicType *>(Validate::SizeType);
-                ast::sizeType = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind };
-        }
-
         for(auto d : translationUnit) {
                 d->accept( c );