Changeset def751f for src/AST

Timestamp:

Jul 25, 2022, 3:17:25 PM (3 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

b0d9ff7

Parents:

4e2befe3 (diff), ffec1bf (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' into qualifiedEnum

Location:

src/AST

Files:

• Expr.cpp (modified) (1 diff)
• Pass.hpp (modified) (2 diffs)
• Pass.impl.hpp (modified) (13 diffs)
• SymbolTable.cpp (modified) (2 diffs)
• TypeSubstitution.cpp (modified) (1 diff)

src/AST/Expr.cpp

@@ -272 +272 @@
         // Adjust the length of the string for the terminator.
         const Expr * strSize = from_ulong( loc, str.size() + 1 );
-        const Type * strType = new ArrayType( charType, strSize, FixedLen, StaticDim );
+        const Type * strType = new ArrayType( charType, strSize, FixedLen, DynamicDim );
         const std::string strValue = "\"" + str + "\"";
         return new ConstantExpr( loc, strType, strValue, std::nullopt );

src/AST/Pass.hpp

@@ -264 +264 @@
         __pass::result1<ast::Stmt> call_accept_as_compound(const ast::Stmt *);
 
+        // requests type environment to be updated (why is it implemented like this?)
+        __pass::result1<ast::Expr> call_accept_top(const ast::Expr *);
+
         template< template <class...> class container_t >
         __pass::resultNstmt<container_t> call_accept( const container_t< ptr<Stmt> > & );
@@ -277 +280 @@
         template<typename node_t, typename parent_t, typename field_t>
         void maybe_accept_as_compound(const node_t * &, field_t parent_t::* field);
+
+        template<typename node_t, typename parent_t, typename field_t>
+        void maybe_accept_top(const node_t * &, field_t parent_t::* field);
 
 private:

src/AST/Pass.impl.hpp

@@ -155 +155 @@
                 __pedantic_pass_assert( expr );
 
-                const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
-                if ( typeSubs_ptr && expr->env ) {
-                        *typeSubs_ptr = expr->env;
-                }
-
                 auto nval = expr->accept( *this );
                 return { nval != expr, nval };
@@ -171 +166 @@
                 const ast::Stmt * nval = stmt->accept( *this );
                 return { nval != stmt, nval };
+        }
+
+        template< typename core_t >
+        __pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept_top( const ast::Expr * expr ) {
+                __pedantic_pass_assert( __visit_children() );
+                __pedantic_pass_assert( expr );
+
+                const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
+                if ( typeSubs_ptr && expr->env ) {
+                        *typeSubs_ptr = expr->env;
+                }
+
+                auto nval = expr->accept( *this );
+                return { nval != expr, nval };
         }
 
@@ -410 +419 @@
 
                 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( new_val.differs ) {
+                        auto new_parent = __pass::mutate<core_t>(parent);
+                        new_val.apply(new_parent, field);
+                        parent = new_parent;
+                }
+        }
+
+        template< typename core_t >
+        template<typename node_t, typename super_t, typename field_t>
+        void ast::Pass< core_t >::maybe_accept_top(
+                const node_t * & parent,
+                field_t super_t::*field
+        ) {
+                static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
+
+                if(__pass::skip(parent->*field)) return;
+                const auto & old_val = __pass::get(parent->*field, 0);
+
+                static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
+
+                auto new_val = call_accept_top( old_val );
 
                 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR");
@@ -756 +789 @@
 
         if ( __visit_children() ) {
-                maybe_accept( node, &StaticAssertDecl::cond );
+                maybe_accept_top( node, &StaticAssertDecl::cond );
                 maybe_accept( node, &StaticAssertDecl::msg  );
         }
@@ -798 +831 @@
 
         if ( __visit_children() ) {
-                maybe_accept( node, &ExprStmt::expr );
+                maybe_accept_top( node, &ExprStmt::expr );
         }
 
@@ -839 +872 @@
                 guard_symtab guard { *this };
                 maybe_accept( node, &IfStmt::inits    );
-                maybe_accept( node, &IfStmt::cond     );
+                maybe_accept_top( node, &IfStmt::cond     );
                 maybe_accept_as_compound( node, &IfStmt::then );
                 maybe_accept_as_compound( node, &IfStmt::else_ );
@@ -857 +890 @@
                 guard_symtab guard { *this };
                 maybe_accept( node, &WhileDoStmt::inits );
-                maybe_accept( node, &WhileDoStmt::cond  );
+                maybe_accept_top( node, &WhileDoStmt::cond  );
                 maybe_accept_as_compound( node, &WhileDoStmt::body  );
         }
@@ -875 +908 @@
                 // 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_top( node, &ForStmt::cond  );
+                maybe_accept_top( node, &ForStmt::inc   );
                 maybe_accept_as_compound( node, &ForStmt::body  );
         }
@@ -890 +923 @@
 
         if ( __visit_children() ) {
-                maybe_accept( node, &SwitchStmt::cond  );
+                maybe_accept_top( node, &SwitchStmt::cond  );
                 maybe_accept( node, &SwitchStmt::cases );
         }
@@ -904 +937 @@
 
         if ( __visit_children() ) {
-                maybe_accept( node, &CaseClause::cond  );
+                maybe_accept_top( node, &CaseClause::cond  );
                 maybe_accept( node, &CaseClause::stmts );
         }
@@ -926 +959 @@
 
         if ( __visit_children() ) {
-                maybe_accept( node, &ReturnStmt::expr );
+                maybe_accept_top( node, &ReturnStmt::expr );
         }
 
@@ -971 +1004 @@
                 guard_symtab guard { *this };
                 maybe_accept( node, &CatchClause::decl );
-                maybe_accept( node, &CatchClause::cond );
+                maybe_accept_top( node, &CatchClause::cond );
                 maybe_accept_as_compound( node, &CatchClause::body );
         }
@@ -2058 +2091 @@
 
         if ( __visit_children() ) {
-                maybe_accept( node, &SingleInit::value );
+                maybe_accept_top( node, &SingleInit::value );
         }
 

src/AST/SymbolTable.cpp

@@ -65 +65 @@
 
 Expr * SymbolTable::IdData::combine( const CodeLocation & loc, ResolvExpr::Cost & cost ) const {
-        Expr * ret = ( baseExpr ) ?
-                (Expr *)new MemberExpr{ loc, id, referenceToRvalueConversion( baseExpr, cost ) } :
-                (Expr *)new VariableExpr{ loc, id };
+        Expr * ret;
+        if ( baseExpr ) {
+                if (baseExpr->env) {
+                        Expr * base = shallowCopy(baseExpr);
+                        const TypeSubstitution * subs = baseExpr->env;
+                        base->env = nullptr;
+                        ret = new MemberExpr{loc, id, referenceToRvalueConversion( base, cost )};
+                        ret->env = subs;
+                }
+                else {
+                        ret = new MemberExpr{ loc, id, referenceToRvalueConversion( baseExpr, cost ) };
+                }
+        }
+        else {
+                ret = new VariableExpr{ loc, id };
+        }
         if ( deleter ) { ret = new DeletedExpr{ loc, ret, deleter }; }
         return ret;
@@ -772 +785 @@
                                                 && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
                                         ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
+                                        ast::ptr<ast::TypeSubstitution> tmp = expr->env;
+                                        expr = mutate_field(expr, &Expr::env, nullptr);
                                         const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
+                                        base = mutate_field(base, &Expr::env, tmp);
+
                                         addMembers(
                                                 rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );

src/AST/TypeSubstitution.cpp

@@ -97 +97 @@
                 TypeSubstitution * newEnv;
                 EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
-                void previsit( FunctionType * ftype ) {
+                void previsit( const FunctionType * ftype ) {
                         // transfer known bindings for seen type variables
                         for (auto & formal : ftype->forall) {