Changeset 1d2b64f for src/ResolvExpr

Timestamp:

Dec 13, 2016, 5:20:54 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

d5556a3

Parents:

722617d

git-author:

Rob Schluntz <rschlunt@…> (12/13/16 17:16:27)

git-committer:

Rob Schluntz <rschlunt@…> (12/13/16 17:20:54)

Message:

combine environments and costs in tuple assignment, resolve ctor/dtors for tuple assignment temporaries

Location:

src/ResolvExpr

Files:

• Resolver.cc (modified) (10 diffs)
• Resolver.h (modified) (1 diff)

src/ResolvExpr/Resolver.cc

@@ -36 +36 @@
           public:
                 Resolver() : SymTab::Indexer( false ) {}
-
-                using SymTab::Indexer::visit;
+                Resolver( const SymTab:: Indexer & other ) : SymTab::Indexer( other ) {
+                        if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
+                                functionReturn = res->functionReturn;
+                                initContext = res->initContext;
+                                inEnumDecl = res->inEnumDecl;
+                        }
+                }
+
+                typedef SymTab::Indexer Parent;
+                using Parent::visit;
                 virtual void visit( FunctionDecl *functionDecl ) override;
                 virtual void visit( ObjectDecl *functionDecl ) override;
@@ -192 +200 @@
                         initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
                 }
-                SymTab::Indexer::visit( objectDecl );
+                Parent::visit( objectDecl );
                 if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
                         // delete newly created signed int type
@@ -212 +220 @@
         void Resolver::visit( ArrayType * at ) {
                 handlePtrType( at );
-                Visitor::visit( at );
+                Parent::visit( at );
         }
 
         void Resolver::visit( PointerType * pt ) {
                 handlePtrType( pt );
-                Visitor::visit( pt );
+                Parent::visit( pt );
         }
 
@@ -225 +233 @@
                         typeDecl->set_base( new_type );
                 } // if
-                SymTab::Indexer::visit( typeDecl );
+                Parent::visit( typeDecl );
         }
 
@@ -238 +246 @@
                 ValueGuard< Type * > oldFunctionReturn( functionReturn );
                 functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
-                SymTab::Indexer::visit( functionDecl );
+                Parent::visit( functionDecl );
         }
 
         void Resolver::visit( EnumDecl * enumDecl ) {
                 // in case we decide to allow nested enums
-                bool oldInEnumDecl = inEnumDecl;
+                ValueGuard< bool > oldInEnumDecl( inEnumDecl );
                 inEnumDecl = true;
-                SymTab::Indexer::visit( enumDecl );
-                inEnumDecl = oldInEnumDecl;
+                Parent::visit( enumDecl );
         }
 
         void Resolver::visit( ExprStmt *exprStmt ) {
-                if ( exprStmt->get_expr() ) {
-                        Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this );
-                        delete exprStmt->get_expr();
-                        exprStmt->set_expr( newExpr );
-                } // if
+                assertf( exprStmt->get_expr(), "ExprStmt has null Expression in resolver" );
+                Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this );
+                delete exprStmt->get_expr();
+                exprStmt->set_expr( newExpr );
         }
 
@@ -277 +283 @@
                 delete ifStmt->get_condition();
                 ifStmt->set_condition( newExpr );
-                Visitor::visit( ifStmt );
+                Parent::visit( ifStmt );
         }
 
@@ -284 +290 @@
                 delete whileStmt->get_condition();
                 whileStmt->set_condition( newExpr );
-                Visitor::visit( whileStmt );
+                Parent::visit( whileStmt );
         }
 
         void Resolver::visit( ForStmt *forStmt ) {
-                SymTab::Indexer::visit( forStmt );
+                Parent::visit( forStmt );
 
                 if ( forStmt->get_condition() ) {
@@ -318 +324 @@
 
         void Resolver::visit( CaseStmt *caseStmt ) {
-                Visitor::visit( caseStmt );
+                Parent::visit( caseStmt );
         }
 
@@ -482 +488 @@
                         } else {
                                 // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
-                                Visitor::visit( listInit );
+                                Parent::visit( listInit );
                         }
                 } else {
                         assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
-                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) );
+                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) || dynamic_cast < EnumInstType * > ( initContext ) );
                         // basic types are handled here
-                        Visitor::visit( listInit );
+                        Parent::visit( listInit );
                 }
 
@@ -554 +560 @@
         }
 
+        // needs to be callable from outside the resolver, so this is a standalone function
+        void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
+                assert( ctorInit );
+                Resolver resolver( indexer );
+                ctorInit->accept( resolver );
+        }
+
+        void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
+                assert( stmtExpr );
+                Resolver resolver( indexer );
+                stmtExpr->accept( resolver );
+        }
+
         void Resolver::visit( ConstructorInit *ctorInit ) {
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit

src/ResolvExpr/Resolver.h

@@ -25 +25 @@
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
         Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
+        void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
+        void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );
 } // namespace ResolvExpr