Changeset 13d326ec

Timestamp:

Jul 26, 2022, 4:45:07 PM (21 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, master, pthread-emulation

Children:

2af1943

Parents:

1b97cc87

Message:

More clean-up, including some removing some duplicate functions.

Location:

src

Files:

• GenPoly/SpecializeNew.cpp (modified) (3 diffs)
• InitTweak/InitTweak.cc (modified) (10 diffs)

src/GenPoly/SpecializeNew.cpp

@@ -230 +230 @@
         if ( auto tuple = type.as<ast::TupleType>() ) {
                 std::vector<ast::ptr<ast::Expr>> exprs;
-                for ( const ast::Type * t : *tuple ) {
+                for ( const ast::ptr<ast::Type> & t : *tuple ) {
                         exprs.push_back( structureArg( location, t, begin, end ) );
                 }
@@ -248 +248 @@
                         if (typeMap.count(typeInst->base)) {
                                 ast::TypeInstType * newInst = mutate(typeInst);
-                                newInst->expr_id = typeMap[typeInst->base].first;
-                                newInst->formal_usage = typeMap[typeInst->base].second;
+                                auto const & pair = typeMap[typeInst->base];
+                                newInst->expr_id = pair.first;
+                                newInst->formal_usage = pair.second;
                                 return newInst;
                         }
@@ -462 +463 @@
         if ( specialized != expr->arg ) {
                 // Assume that the specialization incorporates the cast.
-                // std::cerr << expr <<std::endl;
                 return specialized;
         } else {

src/InitTweak/InitTweak.cc

@@ -27 +27 @@
 #include "AST/Stmt.hpp"
 #include "AST/Type.hpp"
+#include "CodeGen/OperatorTable.h" // for isConstructor, isDestructor, isCto...
 #include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
@@ -770 +771 @@
                         std::list< Expression * > callExprs;
                         collectCtorDtorCalls( stmt, callExprs );
-                        // if ( callExprs.empty() ) return false; // xxx - do I still need this check?
                         return std::all_of( callExprs.begin(), callExprs.end(), pred);
                 }
@@ -901 +901 @@
                         } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
                                 return varExpr->get_var()->get_name();
-                        }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( func ) ) {
+                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( func ) ) {
                                 return funcName( castExpr->get_arg() );
                         } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( func ) ) {
@@ -923 +923 @@
                         } else if ( const ast::VariableExpr * varExpr = dynamic_cast< const ast::VariableExpr * >( func ) ) {
                                 return varExpr->var->name;
-                        }       else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( func ) ) {
+                        } else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( func ) ) {
                                 return funcName( castExpr->arg );
                         } else if ( const ast::MemberExpr * memberExpr = dynamic_cast< const ast::MemberExpr * >( func ) ) {
@@ -991 +991 @@
 
         Type * isPointerType( Type * type ) {
-                if ( getPointerBase( type ) ) return type;
-                else return nullptr;
+                return getPointerBase( type ) ? type : nullptr;
         }
 
@@ -1014 +1013 @@
                                 src = new AddressExpr( src );
                         }
-                        // src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
                 }
                 return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );
@@ -1167 +1165 @@
         }
 
-        bool isConstructor( const std::string & str ) { return str == "?{}"; }
-        bool isDestructor( const std::string & str ) { return str == "^?{}"; }
-        bool isAssignment( const std::string & str ) { return str == "?=?"; }
-        bool isCtorDtor( const std::string & str ) { return isConstructor( str ) || isDestructor( str ); }
-        bool isCtorDtorAssign( const std::string & str ) { return isCtorDtor( str ) || isAssignment( str ); }
-
         const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname ) {
                 const FunctionDecl * function = dynamic_cast< const FunctionDecl * >( decl );
@@ -1192 +1184 @@
 
 bool isAssignment( const ast::FunctionDecl * decl ) {
-        return isAssignment( decl->name ) && isCopyFunction( decl );
+        return CodeGen::isAssignment( decl->name ) && isCopyFunction( decl );
 }
 
 bool isDestructor( const ast::FunctionDecl * decl ) {
-        return isDestructor( decl->name );
+        return CodeGen::isDestructor( decl->name );
 }
 
 bool isDefaultConstructor( const ast::FunctionDecl * decl ) {
-        return isConstructor( decl->name ) && 1 == decl->params.size();
+        return CodeGen::isConstructor( decl->name ) && 1 == decl->params.size();
 }
 
 bool isCopyConstructor( const ast::FunctionDecl * decl ) {
-        return isConstructor( decl->name ) && 2 == decl->params.size();
+        return CodeGen::isConstructor( decl->name ) && 2 == decl->params.size();
 }
 
@@ -1222 +1214 @@
         }
         const FunctionDecl * isDestructor( const Declaration * decl ) {
-                if ( isDestructor( decl->name ) ) {
+                if ( CodeGen::isDestructor( decl->name ) ) {
                         return dynamic_cast< const FunctionDecl * >( decl );
                 }
@@ -1228 +1220 @@
         }
         const FunctionDecl * isDefaultConstructor( const Declaration * decl ) {
-                if ( isConstructor( decl->name ) ) {
+                if ( CodeGen::isConstructor( decl->name ) ) {
                         if ( const FunctionDecl * func = dynamic_cast< const FunctionDecl * >( decl ) ) {
                                 if ( func->type->parameters.size() == 1 ) {