Changes in src/GenPoly/Box.cc [e9b5043:331ee52c]

File:

• src/GenPoly/Box.cc (modified) (10 diffs)

src/GenPoly/Box.cc

@@ -14 +14 @@
 //
 
-#include "Box.h"
-
 #include <algorithm>                     // for mismatch
 #include <cassert>                       // for assert, strict_dynamic_cast
@@ -25 +23 @@
 #include <string>                        // for string, allocator, basic_string
 #include <utility>                       // for pair
+
+#include "Box.h"
 
 #include "CodeGen/OperatorTable.h"
@@ -37 +37 @@
 #include "InitTweak/InitTweak.h"         // for getFunctionName, isAssignment
 #include "Lvalue.h"                      // for generalizedLvalue
-#include "ResolvExpr/Unify.h"            // for typesCompatible
+#include "ResolvExpr/typeops.h"          // for typesCompatible
 #include "ScopedSet.h"                   // for ScopedSet, ScopedSet<>::iter...
 #include "ScrubTyVars.h"                 // for ScrubTyVars
@@ -488 +488 @@
                                 for ( FunctionType const * const funType : functions ) {
                                         std::string mangleName = mangleAdapterName( funType, scopeTyVars );
-                                        if ( !adapters.contains( mangleName ) ) {
+                                        if ( adapters.find( mangleName ) == adapters.end() ) {
                                                 std::string adapterName = makeAdapterName( mangleName );
                                                 adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( funType, scopeTyVars ) ), nullptr ) ) );
@@ -911 +911 @@
 
                         for ( FunctionType const * const funType : functions ) {
-                                std::string mangleName = SymTab::Mangler::mangle( funType );
+                                FunctionType *originalFunction = funType->clone();
+                                FunctionType *realFunction = funType->clone();
+                                std::string mangleName = SymTab::Mangler::mangle( realFunction );
 
                                 // only attempt to create an adapter or pass one as a parameter if we haven't already done so for this
                                 // pre-substitution parameter function type.
                                 // The second part of the insert result is "is the value new".
-                                if ( !adaptersDone.insert( mangleName ).second ) continue;
-
-                                // Apply substitution to type variables to figure out what the adapter's type should look like.
-                                assert( env );
-                                FunctionType *realType = funType->clone();
-                                env->apply( realType );
-                                mangleName = SymTab::Mangler::mangle( realType );
-                                mangleName += makePolyMonoSuffix( funType, exprTyVars );
-
-                                typedef ScopedMap< std::string, DeclarationWithType* >::iterator AdapterIter;
-                                AdapterIter adapter = adapters.find( mangleName );
-                                if ( adapter == adapters.end() ) {
-                                        // Adapter has not been created yet in the current scope, so define it.
-                                        FunctionDecl *newAdapter = makeAdapter( funType, realType, mangleName, exprTyVars );
-                                        std::pair< AdapterIter, bool > answer = adapters.insert( mangleName, newAdapter );
-                                        adapter = answer.first;
-                                        stmtsToAddBefore.push_back( new DeclStmt( newAdapter ) );
+                                if ( adaptersDone.insert( mangleName ).second ) {
+
+                                        // apply substitution to type variables to figure out what the adapter's type should look like
+                                        assert( env );
+                                        env->apply( realFunction );
+                                        mangleName = SymTab::Mangler::mangle( realFunction );
+                                        mangleName += makePolyMonoSuffix( originalFunction, exprTyVars );
+
+                                        typedef ScopedMap< std::string, DeclarationWithType* >::iterator AdapterIter;
+                                        AdapterIter adapter = adapters.find( mangleName );
+                                        if ( adapter == adapters.end() ) {
+                                                // adapter has not been created yet in the current scope, so define it
+                                                FunctionDecl *newAdapter = makeAdapter( funType, realFunction, mangleName, exprTyVars );
+                                                std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
+                                                adapter = answer.first;
+                                                stmtsToAddBefore.push_back( new DeclStmt( newAdapter ) );
+                                        } // if
+                                        assert( adapter != adapters.end() );
+
+                                        // add the appropriate adapter as a parameter
+                                        appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
                                 } // if
-                                assert( adapter != adapters.end() );
-
-                                // Add the appropriate adapter as a parameter.
-                                appExpr->args.push_front( new VariableExpr( adapter->second ) );
                         } // for
                 } // passAdapters
@@ -1487 +1489 @@
                                         if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
                                                 // do not try to monomorphize generic parameters
-                                                if ( scopeTyVars.contains( typeInst->get_name() ) && ! genericParams.count( typeInst->name ) ) {
+                                                if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() && ! genericParams.count( typeInst->name ) ) {
                                                         // polymorphic aggregate members should be converted into monomorphic members.
                                                         // Using char[size_T] here respects the expected sizing rules of an aggregate type.
@@ -1696 +1698 @@
 
                         if ( auto typeInst = dynamic_cast< TypeInstType const * >( ty ) ) {
-                                if ( scopeTyVars.contains( typeInst->get_name() ) ) {
+                                if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) {
                                         // NOTE assumes here that getting put in the scopeTyVars included having the layout variables set
                                         return true;
@@ -1704 +1706 @@
                                 // check if this type already has a layout generated for it
                                 std::string typeName = mangleType( ty );
-                                if ( knownLayouts.contains( typeName ) ) return true;
+                                if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true;
 
                                 // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
@@ -1741 +1743 @@
                                 // check if this type already has a layout generated for it
                                 std::string typeName = mangleType( ty );
-                                if ( knownLayouts.contains( typeName ) ) return true;
+                                if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true;
 
                                 // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
@@ -1832 +1834 @@
                         } else {
                                 std::string offsetName = offsetofName( mangleType( ty ) );
-                                if ( knownOffsets.contains( offsetName ) ) {
+                                if ( knownOffsets.find( offsetName ) != knownOffsets.end() ) {
                                         // use the already-generated offsets for this type
                                         ret = new NameExpr( offsetName );