Changeset 490fb92e for src/AST

Timestamp:

Oct 23, 2020, 9:06:16 PM (4 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

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

Children:

37b7d95

Parents:

41b8ea4

Message:

move FixInit? to new ast

Location:

src/AST

Files:

• Convert.cpp (modified) (19 diffs)
• Decl.cpp (modified) (1 diff)
• Decl.hpp (modified) (1 diff)
• DeclReplacer.cpp (modified) (3 diffs)
• DeclReplacer.hpp (modified) (1 diff)
• Expr.cpp (modified) (2 diffs)
• Expr.hpp (modified) (4 diffs)
• Fwd.hpp (modified) (1 diff)
• Node.hpp (modified) (1 diff)
• Pass.hpp (modified) (2 diffs)
• Pass.impl.hpp (modified) (6 diffs)
• SymbolTable.cpp (modified) (1 diff)
• SymbolTable.hpp (modified) (1 diff)

src/AST/Convert.cpp ¶

@@ -47 +47 @@
 
 //================================================================================================
-namespace {
+namespace ast {
 
 // This is to preserve the FindSpecialDecls hack. It does not (and perhaps should not)
 // allow us to use the same stratagy in the new ast.
+// xxx - since convert back pass works, this concern seems to be unnecessary.
+
+// these need to be accessed in new FixInit now
 ast::Type * sizeType = nullptr;
 ast::FunctionDecl * dereferenceOperator = nullptr;
@@ -63 +66 @@
         using Cache = std::unordered_map< const ast::Node *, BaseSyntaxNode * >;
         Cache cache;
+
+        // Statements can no longer be shared.
+        // however, since StmtExprResult is now implemented, need to still maintain
+        // readonly references.
+        Cache readonlyCache;
 
         template<typename T>
@@ -154 +162 @@
         }
 
-        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
-                auto&& bfwd = get<Expression>().accept1( node->bitfieldWidth );
-                auto&& type = get<Type>().accept1( node->type );
-                auto&& init = get<Initializer>().accept1( node->init );
-                auto&& attr = get<Attribute>().acceptL( node->attributes );
+        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {        
                 if ( inCache( node ) ) {
                         return nullptr;
                 }
+                auto bfwd = get<Expression>().accept1( node->bitfieldWidth );
+                auto type = get<Type>().accept1( node->type );
+                auto attr = get<Attribute>().acceptL( node->attributes );
+
                 auto decl = new ObjectDecl(
                         node->name,
@@ -168 +176 @@
                         bfwd,
                         type->clone(),
-                        init,
+                        nullptr, // prevent infinite loop
                         attr,
                         Type::FuncSpecifiers( node->funcSpec.val )
                 );
-                return declWithTypePostamble( decl, node );
+
+                // handles the case where node->init references itself
+                // xxx - does it really happen?
+                declWithTypePostamble(decl, node);
+                auto init = get<Initializer>().accept1( node->init );
+                decl->init = init;
+                
+                this->node = decl;
+                return nullptr;
         }
 
@@ -205 +221 @@
                 decl->statements = get<CompoundStmt>().accept1( node->stmts );
                 decl->withExprs = get<Expression>().acceptL( node->withExprs );
-                if ( dereferenceOperator == node ) {
+                if ( ast::dereferenceOperator == node ) {
                         Validate::dereferenceOperator = decl;
                 }
-                if ( dtorStructDestroy == node ) {
+                if ( ast::dtorStructDestroy == node ) {
                         Validate::dtorStructDestroy = decl;
                 }
@@ -267 +283 @@
                 );
 
-                if ( dtorStruct == node ) {
+                if ( ast::dtorStruct == node ) {
                         Validate::dtorStruct = decl;
                 }
@@ -320 +336 @@
 
         const ast::Stmt * stmtPostamble( Statement * stmt, const ast::Stmt * node ) {
-                cache.emplace( node, stmt );
+                // force statements in old tree to be unique.
+                // cache.emplace( node, stmt );
+                readonlyCache.emplace( node, stmt );
                 stmt->location = node->location;
                 stmt->labels = makeLabelL( stmt, node->labels );
@@ -337 +355 @@
                 if ( inCache( node ) ) return nullptr;
                 auto stmt = new ExprStmt( nullptr );
-                cache.emplace( node, stmt );
                 stmt->expr = get<Expression>().accept1( node->expr );
                 return stmtPostamble( stmt, node );
@@ -1011 +1028 @@
                 auto stmts = node->stmts;
                 // disable sharing between multiple StmtExprs explicitly.
-                if (inCache(stmts)) {
-                        stmts = ast::deepCopy(stmts.get());
-                }
+                // this should no longer be true.
+
                 auto rslt = new StmtExpr(
                         get<CompoundStmt>().accept1(stmts)
@@ -1020 +1036 @@
                 rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
                 rslt->dtors       = get<Expression>().acceptL(node->dtors);
+                if (node->resultExpr) {
+                        // this MUST be found by children visit
+                        rslt->resultExpr  = strict_dynamic_cast<ExprStmt *>(readonlyCache.at(node->resultExpr));
+                }
 
                 auto expr = visitBaseExpr( node, rslt );
@@ -1036 +1056 @@
 
                 auto expr = visitBaseExpr( node, rslt );
-                this->node = expr;
+                this->node = expr->clone();
                 return nullptr;
         }
@@ -1126 +1146 @@
                 auto type = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
                 // I believe this should always be a BasicType.
-                if ( sizeType == node ) {
+                if ( ast::sizeType == node ) {
                         Validate::SizeType = type;
                 }
@@ -1529 +1549 @@
 
                 // function type is now derived from parameter decls instead of storing them
+
+                /*
                 auto ftype = new ast::FunctionType((ast::ArgumentFlag)old->type->isVarArgs, cv(old->type));
                 ftype->params.reserve(paramVars.size());
@@ -1540 +1562 @@
                 }
                 ftype->forall = std::move(forall);
-                visitType(old->type, ftype);
+                */
+
+                // can function type have attributes? seems not to be the case.
+                // visitType(old->type, ftype);
 
                 auto decl = new ast::FunctionDecl{
@@ -1546 +1571 @@
                         old->name,
                         // GET_ACCEPT_1(type, FunctionType),
+                        std::move(forall),
                         std::move(paramVars),
                         std::move(returnVars),
@@ -1552 +1578 @@
                         { old->linkage.val },
                         GET_ACCEPT_V(attributes, Attribute),
-                        { old->get_funcSpec().val }
+                        { old->get_funcSpec().val },
+                        old->type->isVarArgs
                 };
 
-                decl->type = ftype;
+                // decl->type = ftype;
                 cache.emplace( old, decl );
 
@@ -1570 +1597 @@
 
                 if ( Validate::dereferenceOperator == old ) {
-                        dereferenceOperator = decl;
+                        ast::dereferenceOperator = decl;
                 }
 
                 if ( Validate::dtorStructDestroy == old ) {
-                        dtorStructDestroy = decl;
+                        ast::dtorStructDestroy = decl;
                 }
         }
@@ -1599 +1626 @@
 
                 if ( Validate::dtorStruct == old ) {
-                        dtorStruct = decl;
+                        ast::dtorStruct = decl;
                 }
         }
@@ -2531 +2558 @@
                 // I believe this should always be a BasicType.
                 if ( Validate::SizeType == old ) {
-                        sizeType = type;
+                        ast::sizeType = type;
                 }
                 visitType( old, type );

src/AST/Decl.cpp ¶

@@ -48 +48 @@
 
 // --- FunctionDecl
+
+FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name, 
+                std::vector<ptr<TypeDecl>>&& forall,
+                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+                CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
+                std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
+          stmts( stmts ) {
+                  FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
+                  for (auto & param : this->params) {
+                          ftype->params.emplace_back(param->get_type());
+                  }
+                  for (auto & ret : this->returns) {
+                          ftype->returns.emplace_back(ret->get_type());
+                  }
+                  ftype->forall = std::move(forall);
+                  this->type = ftype;
+          }
+
 
 const Type * FunctionDecl::get_type() const { return type.get(); }

src/AST/Decl.hpp ¶

@@ -131 +131 @@
         std::vector< ptr<Expr> > withExprs;
 
-        FunctionDecl( const CodeLocation & loc, const std::string & name, 
+        FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
-                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {})
-        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
-          stmts( stmts ) {}
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+        // : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
+        //  stmts( stmts ) {}
 
         const Type * get_type() const override;

src/AST/DeclReplacer.cpp ¶

@@ -38 +38 @@
                         const ast::TypeInstType * previsit( const ast::TypeInstType * );
                 };
+
+                struct VarExprReplacer {
+                private:
+                        const ExprMap & exprMap;
+                        
+                public:
+                        VarExprReplacer(const ExprMap & exprMap): exprMap (exprMap) {}
+
+                        const Expr * postvisit (const VariableExpr *);
+                };
         }
 
@@ -54 +64 @@
                 DeclMap declMap;
                 return replace( node, declMap, typeMap, debug );
+        }
+
+        const ast::Node * replace( const ast::Node * node, const ExprMap & exprMap) {
+                Pass<VarExprReplacer> replacer = {exprMap};
+                return node->accept( replacer );
         }
 
@@ -88 +103 @@
                         return ninst;
                 }
+
+                const Expr * VarExprReplacer::postvisit( const VariableExpr * expr ) {
+                        if (!exprMap.count(expr->var)) return expr;
+
+                        return exprMap.at(expr->var);
+                }
+
         }
 }

src/AST/DeclReplacer.hpp ¶

@@ -23 +23 @@
         class DeclWithType;
         class TypeDecl;
+        class Expr;
 
         namespace DeclReplacer {
                 using DeclMap = std::unordered_map< const DeclWithType *, const DeclWithType * >;
                 using TypeMap = std::unordered_map< const TypeDecl *, const TypeDecl * >;
+                using ExprMap = std::unordered_map< const DeclWithType *, const Expr * >;
 
                 const Node * replace( const Node * node, const DeclMap & declMap, bool debug = false );
                 const Node * replace( const Node * node, const TypeMap & typeMap, bool debug = false );
                 const Node * replace( const Node * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
+                const Node * replace( const Node * node, const ExprMap & exprMap);
         }
 }

src/AST/Expr.cpp ¶

@@ -67 +67 @@
 // --- UntypedExpr
 
-UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, Expr * arg ) {
+UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, const Expr * arg ) {
         assert( arg );
 
@@ -92 +92 @@
 }
 
-UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs ) {
+UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs ) {
         assert( lhs && rhs );
 

src/AST/Expr.hpp ¶

@@ -226 +226 @@
 
         /// Creates a new dereference expression
-        static UntypedExpr * createDeref( const CodeLocation & loc, Expr * arg );
+        static UntypedExpr * createDeref( const CodeLocation & loc, const Expr * arg );
         /// Creates a new assignment expression
-        static UntypedExpr * createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs );
+        static UntypedExpr * createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -422 +422 @@
                 const CodeLocation & loc, const Type * ty, const std::string & r,
                         std::optional<unsigned long long> i )
-        : Expr( loc, ty ), rep( r ), ival( i ) {}
+        : Expr( loc, ty ), rep( r ), ival( i ), underlyer(ty) {}
 
         /// Gets the integer value of this constant, if one is appropriate to its type.
@@ -617 +617 @@
 
         ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
-        : Expr( loc, call->result ) { assert( call ); }
+        : Expr( loc, call->result ), callExpr(call) { assert( call ); assert(call->result); }
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -742 +742 @@
         std::vector<ptr<Expr>> dtors;              ///< destructor(s) for return variable(s)
 
+        readonly<ExprStmt> resultExpr;
+
         StmtExpr( const CodeLocation & loc, const CompoundStmt * ss );
 

src/AST/Fwd.hpp ¶

@@ -137 +137 @@
 typedef unsigned int UniqueId;
 
+extern Type * sizeType;
+extern FunctionDecl * dereferenceOperator;
+extern StructDecl   * dtorStruct;
+extern FunctionDecl * dtorStructDestroy;
+
 }

src/AST/Node.hpp ¶

@@ -49 +49 @@
 
         bool unique() const { return strong_count == 1; }
+        bool isManaged() const {return strong_count > 0; }
 
 private:

src/AST/Pass.hpp ¶

@@ -236 +236 @@
         const ast::Expr * call_accept( const ast::Expr * );
 
+        // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
+
+        const ast::Stmt * call_accept_as_compound(const ast::Stmt *);
+
         template< typename node_t >
         auto call_accept( const node_t * node ) -> typename std::enable_if<
@@ -257 +261 @@
         template<typename node_t, typename parent_t, typename child_t>
         void maybe_accept(const node_t * &, child_t parent_t::* child);
+
+        template<typename node_t, typename parent_t, typename child_t>
+        void maybe_accept_as_compound(const node_t * &, child_t parent_t::* child);
 
 private:

src/AST/Pass.impl.hpp ¶

@@ -167 +167 @@
                 __pedantic_pass_assert( stmt );
 
+                return stmt->accept( *this );
+        }
+
+        template< typename core_t >
+        const ast::Stmt * ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
+                __pedantic_pass_assert( __visit_children() );
+                __pedantic_pass_assert( stmt );
+
                 // add a few useful symbols to the scope
                 using __pass::empty;
@@ -324 +332 @@
 
                 auto new_val = call_accept( old_val );
+
+                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
+
+                if( __pass::differs(old_val, new_val) ) {
+                        auto new_parent = __pass::mutate<core_t>(parent);
+                        new_parent->*child = new_val;
+                        parent = new_parent;
+                }
+        }
+
+        template< typename core_t >
+        template<typename node_t, typename parent_t, typename child_t>
+        void ast::Pass< core_t >::maybe_accept_as_compound(
+                const node_t * & parent,
+                child_t parent_t::*child
+        ) {
+                static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
+
+                if(__pass::skip(parent->*child)) return;
+                const auto & old_val = __pass::get(parent->*child, 0);
+
+                static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
+
+                auto new_val = call_accept_as_compound( old_val );
 
                 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
@@ -703 +735 @@
                 maybe_accept( node, &IfStmt::inits    );
                 maybe_accept( node, &IfStmt::cond     );
-                maybe_accept( node, &IfStmt::thenPart );
-                maybe_accept( node, &IfStmt::elsePart );
+                maybe_accept_as_compound( node, &IfStmt::thenPart );
+                maybe_accept_as_compound( node, &IfStmt::elsePart );
         })
 
@@ -721 +753 @@
                 maybe_accept( node, &WhileStmt::inits );
                 maybe_accept( node, &WhileStmt::cond  );
-                maybe_accept( node, &WhileStmt::body  );
+                maybe_accept_as_compound( node, &WhileStmt::body  );
         })
 
@@ -736 +768 @@
                 // for statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
+                // xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
                 maybe_accept( node, &ForStmt::inits );
                 maybe_accept( node, &ForStmt::cond  );
                 maybe_accept( node, &ForStmt::inc   );
-                maybe_accept( node, &ForStmt::body  );
+                maybe_accept_as_compound( node, &ForStmt::body  );
         })
 
@@ -834 +867 @@
                 maybe_accept( node, &CatchStmt::decl );
                 maybe_accept( node, &CatchStmt::cond );
-                maybe_accept( node, &CatchStmt::body );
+                maybe_accept_as_compound( node, &CatchStmt::body );
         })
 

src/AST/SymbolTable.cpp ¶

@@ -335 +335 @@
 }
 
-/*
-void SymbolTable::addFunctionType( const FunctionType * ftype ) {
-        addTypes( ftype->forall );
-        addIds( ftype->returns );
-        addIds( ftype->params );
-}
-*/
+
+void SymbolTable::addFunction( const FunctionDecl * func ) {
+        addTypes( func->type->forall );
+        addIds( func->returns );
+        addIds( func->params );
+}
+
 
 void SymbolTable::lazyInitScope() {

src/AST/SymbolTable.hpp ¶

@@ -145 +145 @@
 
         /// convenience function for adding all of the declarations in a function type to the indexer
-        // void addFunctionType( const FunctionType * ftype );
+        void addFunction( const FunctionDecl * );
 
 private: