Changeset 4618319

Timestamp:

Jul 28, 2017, 11:29:47 AM (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:

b0440b7

Parents:

1461809

Message:

Update GenStructMemberCalls? pass for references

File:

• src/InitTweak/FixInit.cc (modified) (6 diffs)

src/InitTweak/FixInit.cc

@@ -239 +239 @@
                         SemanticError errors;
                   private:
-                        void handleFirstParam( Expression * firstParam );
                         template< typename... Params >
                         void emit( CodeLocation, const Params &... params );
@@ -1032 +1031 @@
 
                         if ( ! unhandled.empty() ) {
-                                // need to explicitly re-add function parameters in order to resolve copy constructors
+                                // need to explicitly re-add function parameters to the indexer in order to resolve copy constructors
                                 enterScope();
                                 maybeAccept( function->get_functionType(), *this );
@@ -1055 +1054 @@
                                         }
                                         InitExpander srcParam( arg2 );
-                                        SymTab::genImplicitCall( srcParam, new MemberExpr( field, new VariableExpr( thisParam ) ), function->get_name(), back_inserter( stmt ), field, isCtor );
+                                        // cast away reference type and construct field.
+                                        Expression * thisExpr = new CastExpr( new VariableExpr( thisParam ), thisParam->get_type()->stripReferences()->clone() );
+                                        Expression * memberDest = new MemberExpr( field, thisExpr );
+                                        SymTab::genImplicitCall( srcParam, memberDest, function->get_name(), back_inserter( stmt ), field, isCtor );
 
                                         assert( stmt.size() <= 1 );
@@ -1082 +1084 @@
                 }
 
+                /// true if expr is effectively just the 'this' parameter
+                bool isThisExpression( Expression * expr, DeclarationWithType * thisParam ) {
+                        // TODO: there are more complicated ways to pass 'this' to a constructor, e.g. &*, *&, etc.
+                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
+                                return varExpr->get_var() == thisParam;
+                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * > ( expr ) ) {
+                                return isThisExpression( castExpr->get_arg(), thisParam );
+                        }
+                        return false;
+                }
+
+                /// returns a MemberExpr if expr is effectively just member access on the 'this' parameter, else nullptr
+                MemberExpr * isThisMemberExpr( Expression * expr, DeclarationWithType * thisParam ) {
+                        if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( expr ) ) {
+                                if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
+                                        return memberExpr;
+                                }
+                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
+                                return isThisMemberExpr( castExpr->get_arg(), thisParam );
+                        }
+                        return nullptr;
+                }
+
                 void GenStructMemberCalls::visit( ApplicationExpr * appExpr ) {
                         if ( ! checkWarnings( function ) ) return;
@@ -1090 +1115 @@
                                 Expression * firstParam = appExpr->get_args().front();
 
-                                if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( firstParam ) ) {
+                                if ( isThisExpression( firstParam, thisParam ) ) {
                                         // if calling another constructor on thisParam, assume that function handles
                                         // all members - if it doesn't a warning will appear in that function.
-                                        if ( varExpr->get_var() == thisParam ) {
-                                                unhandled.clear();
-                                        }
-                                } else {
-                                        // if first parameter is a member expression then
-                                        // remove the member from unhandled set.
-                                        handleFirstParam( firstParam );
-                                }
-                        }
-
-                        Parent::visit( appExpr );
-                }
-
-                void GenStructMemberCalls::handleFirstParam( Expression * firstParam ) {
-                        using namespace std;
-                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( firstParam ) ) {
-                                if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( addrExpr->get_arg() ) ) {
-                                        if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
-                                                if ( getFunctionName( deref ) == "*?" && deref->get_args().size() == 1 ) {
-                                                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( deref->get_args().front() ) ) {
-                                                                if ( varExpr->get_var() == thisParam ) {
-                                                                        unhandled.erase( memberExpr->get_member() );
-                                                                }
-                                                        }
-                                                }
+                                        unhandled.clear();
+                                } else if ( MemberExpr * memberExpr = isThisMemberExpr( firstParam, thisParam ) ) {
+                                        // if first parameter is a member expression on the this parameter,
+                                        // then remove the member from unhandled set.
+                                        if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
+                                                unhandled.erase( memberExpr->get_member() );
                                         }
                                 }
                         }
+                        Parent::visit( appExpr );
                 }
 
@@ -1127 +1134 @@
                         if ( ! isCtor ) return;
 
-                        if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
-                                if ( getFunctionName( deref ) == "*?" && deref->get_args().size() == 1 ) {
-                                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( deref->get_args().front() ) ) {
-                                                if ( varExpr->get_var() == thisParam ) {
-                                                        if ( unhandled.count( memberExpr->get_member() ) ) {
-                                                                // emit a warning because a member was used before it was constructed
-                                                                usedUninit.insert( { memberExpr->get_member(), memberExpr->location } );
-                                                        }
-                                                }
-                                        }
+                        if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
+                                if ( unhandled.count( memberExpr->get_member() ) ) {
+                                        // emit a warning because a member was used before it was constructed
+                                        usedUninit.insert( { memberExpr->get_member(), memberExpr->location } );
                                 }
                         }