Changeset 53449a4 for src/AST/Convert.cpp

Timestamp:

Dec 16, 2020, 4:01:57 PM (3 years ago)

Author:

Colby Alexander Parsons <caparsons@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

8ba363e, c8025a21

Parents:

b3c8496 (diff), 3e5dd913 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

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

src/AST/Convert.cpp

@@ -55 +55 @@
 
 // these need to be accessed in new FixInit now
-ast::Type * sizeType = nullptr;
-ast::FunctionDecl * dereferenceOperator = nullptr;
-ast::StructDecl   * dtorStruct = nullptr;
-ast::FunctionDecl * dtorStructDestroy = nullptr;
+ast::ptr<ast::Type> sizeType = nullptr;
+const ast::FunctionDecl * dereferenceOperator = nullptr;
+const ast::StructDecl   * dtorStruct = nullptr;
+const ast::FunctionDecl * dtorStructDestroy = nullptr;
 
 }
@@ -205 +205 @@
                 ftype->parameters = get<DeclarationWithType>().acceptL(node->params);
 
-                ftype->forall = get<TypeDecl>().acceptL( node->type->forall );
+                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);
+                }
 
                 visitType(node->type, ftype);
@@ -233 +238 @@
         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 );
@@ -603 +607 @@
 
                 for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
-                        rslt->add( src_i->first,
+                        rslt->add( src_i->first.typeString(),
                                    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) );
                 }
 
@@ -1213 +1212 @@
                 // ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
                 // ty->parameters = get<DeclarationWithType>().acceptL( node->params );
-                ty->forall = get<TypeDecl>().acceptL( node->forall );
+
+                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);
+                        }
+                }
+
                 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;
@@ -1301 +1319 @@
                         ty = new TypeInstType{
                                 cv( node ),
-                                node->name,
+                                node->typeString(),
                                 get<TypeDecl>().accept1( node->base ),
                                 get<Attribute>().acceptL( node->attributes )
@@ -1308 +1326 @@
                         ty = new TypeInstType{
                                 cv( node ),
-                                node->name,
+                                node->typeString(),
                                 node->kind == ast::TypeDecl::Ftype,
                                 get<Attribute>().acceptL( node->attributes )
@@ -1433 +1451 @@
         /// 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::ptr<ast::Node> > cache = {};
+        std::unordered_map< const BaseSyntaxNode *, ast::readonly<ast::Node> > cache = {};
 
         // Local Utilities:
@@ -1567 +1585 @@
                 // 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{
@@ -1586 +1616 @@
                 cache.emplace( old, decl );
 
+                decl->assertions = std::move(assertions);
                 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
@@ -1704 +1735 @@
                 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;
@@ -1720 +1750 @@
                 );
                 decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
-                decl->params     = GET_ACCEPT_V(parameters, TypeDecl);
                 decl->extension  = old->extension;
                 decl->uniqueId   = old->uniqueId;
@@ -2070 +2099 @@
         }
 
+        // 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();
 
@@ -2081 +2114 @@
                 }
 
-                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;
+                */
         }
 
@@ -2614 +2643 @@
                         ty->params.emplace_back(v->get_type());
                 }
-                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
+                // 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));
+                        }
+                }
                 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;
@@ -2807 +2844 @@
         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 );