Changes in src/InitTweak/FixInit.cc [79970ed:03b812d2]

File:

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

src/InitTweak/FixInit.cc

@@ -33 +33 @@
 #include "GenPoly/PolyMutator.h"
 #include "SynTree/AddStmtVisitor.h"
-#include "CodeGen/GenType.h"  // for warnings
 
 bool ctordtorp = false;
@@ -175 +174 @@
                         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr );
                 };
-
-                class WarnStructMembers : public Visitor {
-                  public:
-                        typedef Visitor Parent;
-                        /// warn if a user-defined constructor or destructor is missing calls for
-                        /// a struct member or if a member is used before constructed
-                        static void warnings( std::list< Declaration * > & translationUnit );
-
-                        virtual void visit( FunctionDecl * funcDecl );
-
-                        virtual void visit( MemberExpr * memberExpr );
-                        virtual void visit( ApplicationExpr * appExpr );
-
-                  private:
-                        void handleFirstParam( Expression * firstParam );
-
-                        FunctionDecl * function = 0;
-                        std::set< DeclarationWithType * > unhandled;
-                        ObjectDecl * thisParam = 0;
-                };
         } // namespace
 
@@ -208 +187 @@
                 // FixCopyCtors must happen after FixInit, so that destructors are placed correctly
                 FixCopyCtors::fixCopyCtors( translationUnit );
-
-                WarnStructMembers::warnings( translationUnit );
         }
 
@@ -254 +231 @@
                 }
 
-                void WarnStructMembers::warnings( std::list< Declaration * > & translationUnit ) {
-                        if ( true ) { // fix this condition to skip this pass if warnings aren't enabled
-                                WarnStructMembers warner;
-                                acceptAll( translationUnit, warner );
-                        }
-                }
-
                 Expression * InsertImplicitCalls::mutate( ApplicationExpr * appExpr ) {
                         appExpr = dynamic_cast< ApplicationExpr * >( Mutator::mutate( appExpr ) );
@@ -272 +242 @@
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         assert( ftype );
-                                        if ( (isConstructor( funcDecl->get_name() ) || funcDecl->get_name() == "?=?") && ftype->get_parameters().size() == 2 ) {
+                                        if ( (funcDecl->get_name() == "?{}" || funcDecl->get_name() == "?=?") && ftype->get_parameters().size() == 2 ) {
                                                 Type * t1 = ftype->get_parameters().front()->get_type();
                                                 Type * t2 = ftype->get_parameters().back()->get_type();
@@ -283 +253 @@
                                                         return appExpr;
                                                 } // if
-                                        } else if ( isDestructor( funcDecl->get_name() ) ) {
+                                        } else if ( funcDecl->get_name() == "^?{}" ) {
                                                 // correctness: never copy construct arguments to a destructor
                                                 return appExpr;
@@ -700 +670 @@
                         } // switch
                 }
-
-                bool checkWarnings( FunctionDecl * funcDecl ) {
-                        // only check for warnings if the current function is a user-defined
-                        // constructor or destructor
-                        if ( ! funcDecl ) return false;
-                        if ( ! funcDecl->get_statements() ) return false;
-                        return isCtorDtor( funcDecl->get_name() ) && ! LinkageSpec::isOverridable( funcDecl->get_linkage() );
-                }
-
-                void WarnStructMembers::visit( FunctionDecl * funcDecl ) {
-                        WarnStructMembers old = *this;
-                        *this = WarnStructMembers();
-
-                        function = funcDecl;
-                        if ( checkWarnings( funcDecl ) ) {
-                                FunctionType * type = funcDecl->get_functionType();
-                                assert( ! type->get_parameters().empty() );
-                                thisParam = safe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
-                                PointerType * ptrType = safe_dynamic_cast< PointerType * > ( thisParam->get_type() );
-                                StructInstType * structType = dynamic_cast< StructInstType * >( ptrType->get_base() );
-                                if ( structType ) {
-                                        StructDecl * structDecl = structType->get_baseStruct();
-                                        for ( Declaration * member : structDecl->get_members() ) {
-                                                if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
-                                                        // record all of the struct type's members that need to be constructed or
-                                                        // destructed by the end of the function
-                                                        unhandled.insert( field );
-                                                }
-                                        }
-                                }
-                        }
-                        Parent::visit( funcDecl );
-
-                        for ( DeclarationWithType * member : unhandled ) {
-                                // emit a warning for each unhandled member
-                                warn( "in ", CodeGen::genType( function->get_functionType(), function->get_name() ), ", member ", member->get_name(), " may not have been ", isConstructor( funcDecl->get_name() ) ? "constructed" : "destructed" );
-                        }
-
-                        *this = old;
-                }
-
-                void WarnStructMembers::visit( ApplicationExpr * appExpr ) {
-                        if ( ! checkWarnings( function ) ) return;
-
-                        std::string fname = getFunctionName( appExpr );
-                        if ( fname == function->get_name() ) {
-                                // call to same kind of function
-                                Expression * firstParam = appExpr->get_args().front();
-
-                                if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( firstParam ) ) {
-                                        // 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 );
-                                }
-                        } 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() );
-                        }
-
-                        Parent::visit( appExpr );
-                }
-
-                void WarnStructMembers::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() );
-                                                                }
-                                                        }
-                                                }
-                                        }
-                                }
-                        }
-                }
-
-                void WarnStructMembers::visit( MemberExpr * memberExpr ) {
-                        if ( ! checkWarnings( function ) ) return;
-                        if ( ! isConstructor( function->get_name() ) );
-
-                        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
-                                                                warn( "in ", CodeGen::genType( function->get_functionType(), function->get_name() ), ", member ", memberExpr->get_member()->get_name(), " used before being constructed" );
-                                                        }
-                                                }
-                                        }
-                                }
-                        }
-                        Parent::visit( memberExpr );
-                }
         } // namespace
 } // namespace InitTweak