Changes in src/ResolvExpr/Resolver.cc [2a6292d:c5283ba]

File:

• src/ResolvExpr/Resolver.cc (modified) (8 diffs)

src/ResolvExpr/Resolver.cc

@@ -30 +30 @@
 #include "RenameVars.h"                  // for RenameVars, global_renamer
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
+#include "ResolveTypeof.h"               // for resolveTypeof
 #include "Resolver.h"
 #include "SymTab/Autogen.h"              // for SizeType
@@ -56 +57 @@
                 void postvisit( FunctionDecl *functionDecl );
                 void previsit( ObjectDecl *objectDecll );
+                void previsit( TypeDecl *typeDecl );
                 void previsit( EnumDecl * enumDecl );
                 void previsit( StaticAssertDecl * assertDecl );
@@ -75 +77 @@
                 void previsit( CatchStmt *catchStmt );
                 void previsit( WaitForStmt * stmt );
+                void previsit( WithStmt * withStmt );
 
                 void previsit( SingleInit *singleInit );
@@ -85 +88 @@
                 void handlePtrType( PtrType * type );
 
+                void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts );
                 void fallbackInit( ConstructorInit * ctorInit );
 
@@ -90 +94 @@
                 CurrentObject currentObject = nullptr;
                 bool inEnumDecl = false;
-        };
-
-        struct ResolveWithExprs : public WithIndexer, public WithGuards, public WithVisitorRef<ResolveWithExprs>, public WithShortCircuiting, public WithStmtsToAdd {
-                void previsit( FunctionDecl * );
-                void previsit( WithStmt * );
-
-                void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts );
         };
 
@@ -305 +302 @@
         }
 
-
-        bool isStructOrUnion( const Alternative & alt ) {
-                Type * t = alt.expr->result->stripReferences();
-                return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
-        }
-
-        void resolveWithExprs( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<ResolveWithExprs> resolver;
-                acceptAll( translationUnit, resolver );
-        }
-
-        void ResolveWithExprs::resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts ) {
-                for ( Expression *& expr : withExprs )  {
-                        // only struct- and union-typed expressions are viable candidates
-                        findKindExpression( expr, indexer, "with statement", isStructOrUnion );
-
-                        // if with expression might be impure, create a temporary so that it is evaluated once
-                        if ( Tuples::maybeImpure( expr ) ) {
-                                static UniqueName tmpNamer( "_with_tmp_" );
-                                ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) );
-                                expr = new VariableExpr( tmp );
-                                newStmts.push_back( new DeclStmt( tmp ) );
-                                if ( InitTweak::isConstructable( tmp->type ) ) {
-                                        // generate ctor/dtor and resolve them
-                                        tmp->init = InitTweak::genCtorInit( tmp );
-                                        tmp->accept( *visitor );
-                                }
-                        }
-                }
-        }
-
-        void ResolveWithExprs::previsit( WithStmt * withStmt ) {
-                resolveWithExprs( withStmt->exprs, stmtsToAddBefore );
-        }
-
-        void ResolveWithExprs::previsit( FunctionDecl * functionDecl ) {
+        void Resolver::previsit( ObjectDecl *objectDecl ) {
+                Type *new_type = resolveTypeof( objectDecl->get_type(), indexer );
+                objectDecl->set_type( new_type );
+                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that class-variable
+                // initContext is changed multiple time because the LHS is analysed twice. The second analysis changes
+                // initContext because of a function type can contain object declarations in the return and parameter types. So
+                // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
+                // the RHS.
+                GuardValue( currentObject );
+                currentObject = CurrentObject( objectDecl->get_type() );
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
+                        // enumerator initializers should not use the enum type to initialize, since
+                        // the enum type is still incomplete at this point. Use signed int instead.
+                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                }
+        }
+
+        template< typename PtrType >
+        void Resolver::handlePtrType( PtrType * type ) {
+                if ( type->get_dimension() ) {
+                        findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
+                }
+        }
+
+        void Resolver::previsit( ArrayType * at ) {
+                handlePtrType( at );
+        }
+
+        void Resolver::previsit( PointerType * pt ) {
+                handlePtrType( pt );
+        }
+
+        void Resolver::previsit( TypeDecl *typeDecl ) {
+                if ( typeDecl->get_base() ) {
+                        Type *new_type = resolveTypeof( typeDecl->get_base(), indexer );
+                        typeDecl->set_base( new_type );
+                } // if
+        }
+
+        void Resolver::previsit( FunctionDecl *functionDecl ) {
+#if 0
+                std::cerr << "resolver visiting functiondecl ";
+                functionDecl->print( std::cerr );
+                std::cerr << std::endl;
+#endif
+                Type *new_type = resolveTypeof( functionDecl->type, indexer );
+                functionDecl->set_type( new_type );
+                GuardValue( functionReturn );
+                functionReturn = ResolvExpr::extractResultType( functionDecl->type );
+
                 {
                         // resolve with-exprs with parameters in scope and add any newly generated declarations to the
@@ -354 +365 @@
                         }
                 }
-        }
-
-        void Resolver::previsit( ObjectDecl *objectDecl ) {
-                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that class-variable
-                // initContext is changed multiple time because the LHS is analysed twice. The second analysis changes
-                // initContext because of a function type can contain object declarations in the return and parameter types. So
-                // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
-                // the RHS.
-                GuardValue( currentObject );
-                currentObject = CurrentObject( objectDecl->get_type() );
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
-                        // enumerator initializers should not use the enum type to initialize, since
-                        // the enum type is still incomplete at this point. Use signed int instead.
-                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
-                }
-        }
-
-        template< typename PtrType >
-        void Resolver::handlePtrType( PtrType * type ) {
-                if ( type->get_dimension() ) {
-                        findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
-                }
-        }
-
-        void Resolver::previsit( ArrayType * at ) {
-                handlePtrType( at );
-        }
-
-        void Resolver::previsit( PointerType * pt ) {
-                handlePtrType( pt );
-        }
-
-        void Resolver::previsit( FunctionDecl *functionDecl ) {
-#if 0
-                std::cerr << "resolver visiting functiondecl ";
-                functionDecl->print( std::cerr );
-                std::cerr << std::endl;
-#endif
-                GuardValue( functionReturn );
-                functionReturn = ResolvExpr::extractResultType( functionDecl->type );
         }
 
@@ -724 +695 @@
                         stmt->orelse.statement->accept( *visitor );
                 }
+        }
+
+        bool isStructOrUnion( const Alternative & alt ) {
+                Type * t = alt.expr->result->stripReferences();
+                return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
+        }
+
+        void Resolver::resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts ) {
+                for ( Expression *& expr : withExprs )  {
+                        // only struct- and union-typed expressions are viable candidates
+                        findKindExpression( expr, indexer, "with statement", isStructOrUnion );
+
+                        // if with expression might be impure, create a temporary so that it is evaluated once
+                        if ( Tuples::maybeImpure( expr ) ) {
+                                static UniqueName tmpNamer( "_with_tmp_" );
+                                ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) );
+                                expr = new VariableExpr( tmp );
+                                newStmts.push_back( new DeclStmt( tmp ) );
+                                if ( InitTweak::isConstructable( tmp->type ) ) {
+                                        // generate ctor/dtor and resolve them
+                                        tmp->init = InitTweak::genCtorInit( tmp );
+                                        tmp->accept( *visitor );
+                                }
+                        }
+                }
+        }
+
+        void Resolver::previsit( WithStmt * withStmt ) {
+                resolveWithExprs( withStmt->exprs, stmtsToAddBefore );
         }