Changes in src/InitTweak/InitTweak.cc [490fb92e:954c954]

File:

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

src/InitTweak/InitTweak.cc

@@ -498 +498 @@
         }
 
-        const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func) {
-                assertf( func, "getParamThis: nullptr ftype" );
-                auto & params = func->params;
-                assertf( ! params.empty(), "getParamThis: ftype with 0 parameters: %s", toString( func ).c_str());
-                return params.front().strict_as<ast::ObjectDecl>();
-        }
-
         bool tryConstruct( DeclarationWithType * dwt ) {
                 ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );
@@ -518 +511 @@
         }
 
-        bool tryConstruct( const ast::DeclWithType * dwt ) {
-                auto objDecl = dynamic_cast< const ast::ObjectDecl * >( dwt );
-                if ( ! objDecl ) return false;
-                return (objDecl->init == nullptr ||
-                                ( objDecl->init != nullptr && objDecl->init->maybeConstructed ))
-                        && ! objDecl->storage.is_extern
-                        && isConstructable( objDecl->type );
-        }
-
-        bool isConstructable( const ast::Type * type ) {
-                return ! dynamic_cast< const ast::VarArgsType * >( type ) && ! dynamic_cast< const ast::ReferenceType * >( type ) 
-                && ! dynamic_cast< const ast::FunctionType * >( type ) && ! Tuples::isTtype( type );
-        }
-
         struct CallFinder_old {
                 CallFinder_old( const std::list< std::string > & names ) : names( names ) {}
@@ -557 +536 @@
 
         struct CallFinder_new final {
-                std::vector< const ast::Expr * > matches;
+                std::vector< ast::ptr< ast::Expr > > matches;
                 const std::vector< std::string > names;
 
@@ -579 +558 @@
         }
 
-        std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt ) {
+        std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt ) {
                 ast::Pass< CallFinder_new > finder{ std::vector< std::string >{ "?{}", "^?{}" } };
                 maybe_accept( stmt, finder );
@@ -717 +696 @@
                 template <typename Predicate>
                 bool allofCtorDtor( const ast::Stmt * stmt, const Predicate & pred ) {
-                        std::vector< const ast::Expr * > callExprs = collectCtorDtorCalls( stmt );
+                        std::vector< ast::ptr< ast::Expr > > callExprs = collectCtorDtorCalls( stmt );
                         return std::all_of( callExprs.begin(), callExprs.end(), pred );
                 }
@@ -960 +939 @@
         }
 
-        // looks like some other such codegen uses UntypedExpr and does not create fake function. should revisit afterwards
-        // following passes may accidentally resolve this expression if returned as untyped...
-        ast::Expr * createBitwiseAssignment (const ast::Expr * dst, const ast::Expr * src) {
-                static ast::ptr<ast::FunctionDecl> assign = nullptr;
-                if (!assign) {
-                        auto td = new ast::TypeDecl({}, "T", {}, nullptr, ast::TypeDecl::Dtype, true);
-                        assign = new ast::FunctionDecl({}, "?=?", {}, 
-                        { new ast::ObjectDecl({}, "_dst", new ast::ReferenceType(new ast::TypeInstType("T", td))),
-                          new ast::ObjectDecl({}, "_src", new ast::TypeInstType("T", td))},
-                        { new ast::ObjectDecl({}, "_ret", new ast::TypeInstType("T", td))}, nullptr, {}, ast::Linkage::Intrinsic);
-                }
-                if (dst->result.as<ast::ReferenceType>()) {
-                        for (int depth = dst->result->referenceDepth(); depth > 0; depth--) {
-                                dst = new ast::AddressExpr(dst);
-                        }
-                }
-                else {
-                        dst = new ast::CastExpr(dst, new ast::ReferenceType(dst->result, {}));
-                }
-                if (src->result.as<ast::ReferenceType>()) {
-                        for (int depth = src->result->referenceDepth(); depth > 0; depth--) {
-                                src = new ast::AddressExpr(src);
-                        }
-                }
-                return new ast::ApplicationExpr(dst->location, ast::VariableExpr::functionPointer(dst->location, assign), {dst, src});
-        }
-
         struct ConstExprChecker : public WithShortCircuiting {
                 // most expressions are not const expr