Changeset 4d4882a for src/InitTweak

Timestamp:

Sep 1, 2016, 4:53:22 PM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, 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:

44f6341

Parents:

fba44f8

Message:

implicitly insert missing copy constructors when appropriate, update test output

Location:

src/InitTweak

Files:

• FixInit.cc (modified) (2 diffs)
• InitTweak.cc (modified) (2 diffs)
• InitTweak.h (modified) (1 diff)

src/InitTweak/FixInit.cc ¶

@@ -787 +787 @@
                                         UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
                                         deref->get_args().push_back( new VariableExpr( thisParam ) );
-                                        InitExpander srcParam( (Initializer *)NULL ); // xxx - if copy ctor, need to pass appropriate argument - second param of this function dot member
+
+                                        Expression * arg2 = 0;
+                                        if ( isCopyConstructor( function ) ) {
+                                                // if copy ctor, need to pass second-param-of-this-function.member
+                                                std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
+                                                assert( params.size() == 2 );
+                                                arg2 = new MemberExpr( member, new VariableExpr( params.back() ) );
+                                        }
+                                        InitExpander srcParam( arg2 );
                                         SymTab::genImplicitCall( srcParam, new MemberExpr( member, deref ), function->get_name(), back_inserter( stmt ), member, isCtor );
 
@@ -832 +840 @@
                                         handleFirstParam( firstParam );
                                 }
-                        } else if ( fname == "?=?" && isIntrinsicCallExpr( appExpr ) ) {
-                                // forgive use of intrinsic assignment to construct, since instrinsic constructors
-                                // codegen as assignment anyway.
-                                assert( appExpr->get_args().size() == 2 );
-                                handleFirstParam( appExpr->get_args().front() );
                         }
 

src/InitTweak/InitTweak.cc ¶

@@ -7 +7 @@
 #include "SynTree/Attribute.h"
 #include "GenPoly/GenPoly.h"
+#include "ResolvExpr/typeops.h"
 
 namespace InitTweak {
@@ -439 +440 @@
         bool isDestructor( const std::string & str ) { return str == "^?{}"; }
         bool isCtorDtor( const std::string & str ) { return isConstructor( str ) || isDestructor( str ); }
+
+        FunctionDecl * isCopyConstructor( Declaration * decl ) {
+                FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl );
+                if ( ! function ) return 0;
+                if ( ! isConstructor( function->get_name() ) ) return 0;
+                FunctionType * ftype = function->get_functionType();
+                if ( ftype->get_parameters().size() != 2 ) return 0;
+
+                Type * t1 = ftype->get_parameters().front()->get_type();
+                Type * t2 = ftype->get_parameters().back()->get_type();
+                PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
+                assert( ptrType );
+
+                if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
+                        return function;
+                } else {
+                        return 0;
+                }
+        }
 }

src/InitTweak/InitTweak.h ¶

@@ -29 +29 @@
         bool isDestructor( const std::string & );
         bool isCtorDtor( const std::string & );
+
+        FunctionDecl * isCopyConstructor( Declaration * decl );
 
         /// transform Initializer into an argument list that can be passed to a call expression