Changes in src/ResolvExpr/Resolver.cc [60aaa51d:2b59f55]

File:

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

src/ResolvExpr/Resolver.cc

@@ -781 +781 @@
         }
 
-        bool isCharType( Type * t ) {
+        template< typename T >
+        bool isCharType( T t ) {
                 if ( BasicType * bt = dynamic_cast< BasicType * >( t ) ) {
                         return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar ||
@@ -1070 +1071 @@
                 };
 
-                /// Swaps argument into expression pointer, saving original environment
-                void swap_and_save_env( ast::ptr< ast::Expr > & expr, const ast::Expr * newExpr ) {
-                        ast::ptr< ast::TypeSubstitution > env = expr->env;
-                        expr.set_and_mutate( newExpr )->env = env;
-                }
-
                 /// Removes cast to type of argument (unlike StripCasts, also handles non-generated casts)
                 void removeExtraneousCast( ast::ptr<ast::Expr> & expr, const ast::SymbolTable & symtab ) {
@@ -1081 +1076 @@
                                 if ( typesCompatible( castExpr->arg->result, castExpr->result, symtab ) ) {
                                         // cast is to the same type as its argument, remove it
-                                        swap_and_save_env( expr, castExpr->arg );
+                                        ast::ptr< ast::TypeSubstitution > env = castExpr->env;
+                                        expr.set_and_mutate( castExpr->arg )->env = env;
                                 }
                         }
@@ -1179 +1175 @@
                         return findKindExpression( untyped, symtab, hasIntegralType, "condition" );
                 }
-
-                /// check if a type is a character type
-                bool isCharType( const ast::Type * t ) {
-                        if ( auto bt = dynamic_cast< const ast::BasicType * >( t ) ) {
-                                return bt->kind == ast::BasicType::Char 
-                                        || bt->kind == ast::BasicType::SignedChar 
-                                        || bt->kind == ast::BasicType::UnsignedChar;
-                        }
-                        return false;
-                }
         }
 
@@ -1227 +1213 @@
                 void previsit( const ast::WaitForStmt * );
 
-                const ast::SingleInit * previsit( const ast::SingleInit * );
-                const ast::ListInit * previsit( const ast::ListInit * );
+                void previsit( const ast::SingleInit * );
+                void previsit( const ast::ListInit * );
                 void previsit( const ast::ConstructorInit * );
         };
@@ -1377 +1363 @@
         const ast::CaseStmt * Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
                 if ( caseStmt->cond ) {
-                        std::deque< ast::InitAlternative > initAlts = currentObject.getOptions();
+                        std::vector< ast::InitAlternative > initAlts = currentObject.getOptions();
                         assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral "
                                 "expression." );
@@ -1388 +1374 @@
                         // whether it would perform a conversion.
                         if ( const ast::CastExpr * castExpr = newExpr.as< ast::CastExpr >() ) {
-                                swap_and_save_env( newExpr, castExpr->arg );
+                                ast::ptr< ast::TypeSubstitution > env = castExpr->env;
+                                newExpr.set_and_mutate( castExpr->arg )->env = env;
                         }
                         
@@ -1451 +1438 @@
         }
 
-
-
-        const ast::SingleInit * Resolver_new::previsit( const ast::SingleInit * singleInit ) {
-                visit_children = false;
-                // resolve initialization using the possibilities as determined by the `currentObject` 
-                // cursor.
-                ast::Expr * untyped = new ast::UntypedInitExpr{ 
-                        singleInit->location, singleInit->value, currentObject.getOptions() };
-                ast::ptr<ast::Expr> newExpr = findKindExpression( untyped, symtab );
-                const ast::InitExpr * initExpr = newExpr.strict_as< ast::InitExpr >();
-
-                // move cursor to the object that is actually initialized
-                currentObject.setNext( initExpr->designation );
-
-                // discard InitExpr wrapper and retain relevant pieces.
-                // `initExpr` may have inferred params in the case where the expression specialized a 
-                // function pointer, and newExpr may already have inferParams of its own, so a simple 
-                // swap is not sufficient
-                ast::Expr::InferUnion inferred = initExpr->inferred;
-                swap_and_save_env( newExpr, initExpr->expr );
-                newExpr.get_and_mutate()->inferred.splice( std::move(inferred) );
-
-                // get the actual object's type (may not exactly match what comes back from the resolver 
-                // due to conversions)
-                const ast::Type * initContext = currentObject.getCurrentType();
-
-                removeExtraneousCast( newExpr, symtab );
-
-                // check if actual object's type is char[]
-                if ( auto at = dynamic_cast< const ast::ArrayType * >( initContext ) ) {
-                        if ( isCharType( at->base ) ) {
-                                // check if the resolved type is char*
-                                if ( auto pt = newExpr->result.as< ast::PointerType >() ) {
-                                        if ( isCharType( pt->base ) ) {
-                                                // strip cast if we're initializing a char[] with a char* 
-                                                // e.g. char x[] = "hello"
-                                                if ( auto ce = newExpr.as< ast::CastExpr >() ) {
-                                                        swap_and_save_env( newExpr, ce->arg );
-                                                }
-                                        }
-                                }
-                        }
-                }
-
-                // move cursor to next object in preparation for next initializer
-                currentObject.increment();
-
-                // set initializer expression to resolved expression
-                return ast::mutate_field( singleInit, &ast::SingleInit::value, std::move(newExpr) );
-        }
-
-        const ast::ListInit * Resolver_new::previsit( const ast::ListInit * listInit ) {
-                // move cursor into brace-enclosed initializer-list
-                currentObject.enterListInit( listInit->location );
-
-                assert( listInit->designations.size() == listInit->initializers.size() );
-                for ( unsigned i = 0; i < listInit->designations.size(); ++i ) {
-                        // iterate designations and initializers in pairs, moving the cursor to the current 
-                        // designated object and resolving the initializer against that object
-                        #warning unimplemented; Resolver port in progress
-                        assert(false);
-                }
-
-                visit_children = false;
-                return listInit;
+        void Resolver_new::previsit( const ast::SingleInit * singleInit ) {
+                #warning unimplemented; Resolver port in progress
+                (void)singleInit;
+                assert(false);
+        }
+
+        void Resolver_new::previsit( const ast::ListInit * listInit ) {
+                #warning unimplemented; Resolver port in progress
+                (void)listInit;
+                assert(false);
         }