Changes in src/GenPoly/BoxNew.cpp [097c8d0:1ee0a4da]

File:

• src/GenPoly/BoxNew.cpp (modified) (25 diffs)

src/GenPoly/BoxNew.cpp

@@ -77 +77 @@
 };
 
+// Formally takeOtypeOnly
 /// Get all sized type declarations; those that affect a layout function.
 ast::vector<ast::TypeDecl> takeSizedParams(
@@ -509 +510 @@
                 ast::FunctionType const * function,
                 TypeVarMap const & typeVars ) {
+        // TODO
+        // NOTE: This function previously used isPolyObj, which failed to produce
+        // the correct thing in some situations. It's not clear to [Rob Schluntz]
+        // why this wasn't working.
+
         // If the return type or a parameter type involved polymorphic types,
         // then the adapter will need to take those polymorphic types as pointers.
@@ -581 +587 @@
         ast::FunctionType const * type = decl->type;
         if ( isDynRet( type ) && decl->linkage != ast::Linkage::C ) {
+                //retval = type->returns.front();
                 retval = decl->returns.front();
 
@@ -741 +748 @@
 ast::Expr const * CallAdapter::postvisit( ast::UntypedExpr const * expr ) {
         if ( isPolyDeref( expr, scopeTypeVars, typeSubs ) ) {
+                // TODO Pretty sure this is just a memory management change.
+                // Also, I don't understand what this is doing.
+                //ast::Expr const * ret = expr->args.front();
+                //expr->args.clear();
+                //return ret;
                 return expr->args.front();
         }
@@ -1051 +1063 @@
                 ast::ptr<ast::Type> newType = ast::deepCopy( param );
                 if ( typeSubs ) typeSubs->apply( newType );
+                // TODO: Is this right? (Why wouldn't it be?)
+                // I think this is to make sure we can write to the temporary.
+                //newType.get_and_mutate()->qt = ast::CV::Qualifiers();
+                //reset_qualifiers( newType );
                 ast::ObjectDecl * newObj = makeTemporary( location, newType );
                 auto assign = ast::UntypedExpr::createCall( location, "?=?", {
@@ -1229 +1245 @@
                         }
                         return new ast::ObjectDecl( location, pNamer.newName(), param );
-                } ),
+                } ), // params
                 map_range<ast::vector<ast::DeclWithType>>( adapterType->returns,
                                 [&rNamer, &location]( ast::ptr<ast::Type> const & retval ) {
                         return new ast::ObjectDecl( location, rNamer.newName(), retval );
-                } ),
+                } ), // returns
                 nullptr, // stmts
-                {}, // storage
-                ast::Linkage::C
+                ast::Storage::Classes(), // storage
+                ast::Linkage::C // linkage
+                // attrs
+                // fs
+                // isVarArgs
         );
 
@@ -1295 +1314 @@
         // Returns a polymorphic type.
         } else if ( isDynType( adaptee->returns.front(), typeVars ) ) {
+                if ( "" == (*paramDecl)->name ) {
+                        // TODO: Is it easier to make sure it has a name in the first
+                        // place? - I believe this is done, however, I could remove the
+                        // condition and just rename for clarity.
+                        assertf( false, "Wasn't expecting to get here." );
+                        auto mutParam = paramDecl->get_and_mutate();
+                        mutParam->name = "_ret";
+                        mutParam->linkage = ast::Linkage::C;
+                }
                 ast::UntypedExpr * assign = new ast::UntypedExpr( location,
                         new ast::NameExpr( location, "?=?" ) );
@@ -1518 +1546 @@
 
 // --------------------------------------------------------------------------
-/// Modifies declarations to accept implicit parameters.
+/// Creates the adapter functions. TODO
 /// * Move polymorphic returns in function types to pointer-type parameters.
 /// * Adds type size and assertion parameters to parameter lists.
-struct DeclAdapter final {
+struct DeclAdapter final :
+                public BoxPass,
+                public ast::WithGuards {
+        void handleAggrDecl();
+
+        void previsit( ast::StructDecl const * decl );
+        void previsit( ast::UnionDecl const * decl );
+        void previsit( ast::TraitDecl const * decl );
+        void previsit( ast::TypeDecl const * decl );
+        void previsit( ast::PointerType const * type );
+        void previsit( ast::FunctionType const * type );
         ast::FunctionDecl const * previsit( ast::FunctionDecl const * decl );
-        ast::FunctionDecl const * postvisit( ast::FunctionDecl const * decl );
+        ast::DeclWithType const * postvisit( ast::FunctionDecl const * decl );
+        void previsit( ast::CompoundStmt const * stmt );
 private:
-        void addAdapters( ast::FunctionDecl * decl, TypeVarMap & localTypeVars );
+        ast::FunctionDecl * addAdapters( ast::FunctionDecl * decl );
+
+        std::map<UniqueId, std::string> adapterName;
 };
 
-// size/align/offset parameters may not be used, so add the unused attribute.
-ast::ObjectDecl * makeObj(
-                CodeLocation const & location, std::string const & name ) {
-        return new ast::ObjectDecl( location, name,
-                makeSizeAlignType(),
-                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr,
-                { new ast::Attribute( "unused" ) } );
-}
-
-ast::ObjectDecl * makePtr(
-                CodeLocation const & location, std::string const & name ) {
-        return new ast::ObjectDecl( location, name,
-                new ast::PointerType( makeSizeAlignType() ),
-                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr );
+// at must point within [dst.begin(), dst.end()].
+template< typename T >
+void spliceAt( std::vector< T > & dst, typename std::vector< T >::iterator at,
+                std::vector< T > & src ) {
+        std::vector< T > tmp;
+        tmp.reserve( dst.size() + src.size() );
+        typename std::vector< T >::iterator it = dst.begin();
+        while ( it != at ) {
+                assert( it != dst.end() );
+                tmp.emplace_back( std::move( *it ) );
+                ++it;
+        }
+        for ( T & x : src ) { tmp.emplace_back( std::move( x ) ); }
+        while ( it != dst.end() ) {
+                tmp.emplace_back( std::move( *it ) );
+                ++it;
+        }
+
+        dst.clear();
+        src.clear();
+        tmp.swap( dst );
+}
+
+void DeclAdapter::previsit( ast::StructDecl const * ) {
+        // Prevent type vars from leaking into the containing scope.
+        GuardScope( scopeTypeVars );
+}
+
+void DeclAdapter::previsit( ast::UnionDecl const * ) {
+        // Prevent type vars from leaking into the containing scope.
+        GuardScope( scopeTypeVars );
+}
+
+void DeclAdapter::previsit( ast::TraitDecl const * ) {
+        // Prevent type vars from leaking into the containing scope.
+        GuardScope( scopeTypeVars );
+}
+
+void DeclAdapter::previsit( ast::TypeDecl const * decl ) {
+        addToTypeVarMap( decl, scopeTypeVars );
+}
+
+void DeclAdapter::previsit( ast::PointerType const * type ) {
+        GuardScope( scopeTypeVars );
+        makeTypeVarMap( type, scopeTypeVars );
+}
+
+// TODO: I think this code is redundent.
+void DeclAdapter::previsit( ast::FunctionType const * type ) {
+        GuardScope( scopeTypeVars );
+        makeTypeVarMap( type, scopeTypeVars );
 }
 
 ast::FunctionDecl const * DeclAdapter::previsit( ast::FunctionDecl const * decl ) {
-        TypeVarMap localTypeVars = { ast::TypeData() };
-        makeTypeVarMap( decl, localTypeVars );
+        GuardScope( scopeTypeVars );
+        makeTypeVarMap( decl, scopeTypeVars );
 
         auto mutDecl = mutate( decl );
@@ -1561 +1639 @@
 
         // Add size/align and assertions for type parameters to parameter list.
-        ast::vector<ast::DeclWithType> inferredParams;
-        ast::vector<ast::DeclWithType> layoutParams;
+        std::vector<ast::ptr<ast::DeclWithType>>::iterator last = mutDecl->params.begin();
+        std::vector<ast::ptr<ast::DeclWithType>> inferredParams;
+        // size/align/offset parameters may not be used in body, pass along with unused attribute.
+        // TODO: These should be created with proper location and name.
+        // TODO: makeSizeAlign[Out]Type are the same as these types, but they may
+        // be logically different.
+        ast::ObjectDecl newObj( mutDecl->location, "",
+                new ast::BasicType( ast::BasicType::LongUnsignedInt ),
+                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr,
+                { new ast::Attribute( "unused" ) } );
+        ast::ObjectDecl newPtr( mutDecl->location, "",
+                new ast::PointerType( new ast::BasicType( ast::BasicType::LongUnsignedInt ) ),
+                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr );
         for ( ast::ptr<ast::TypeDecl> & typeParam : mutDecl->type_params ) {
                 auto mutParam = mutate( typeParam.get() );
                 // Add all size and alignment parameters to parameter list.
                 if ( mutParam->isComplete() ) {
+                        //ast::TypeInstType paramType( typeParam->name, typeParam );
                         ast::TypeInstType paramType( mutParam );
                         std::string paramName = Mangle::mangleType( &paramType );
 
-                        auto sizeParam = makeObj( typeParam->location, sizeofName( paramName ) );
-                        layoutParams.emplace_back( sizeParam );
-
-                        auto alignParam = makeObj( typeParam->location, alignofName( paramName ) );
-                        layoutParams.emplace_back( alignParam );
+                        ast::ObjectDecl * sizeParam = ast::deepCopy( &newObj );
+                        sizeParam->location = typeParam->location;
+                        sizeParam->name = sizeofName( paramName );
+                        last = mutDecl->params.insert( last, sizeParam );
+                        ++last;
+
+                        ast::ObjectDecl * alignParam = ast::deepCopy( &newObj );
+                        alignParam->location = typeParam->location;
+                        alignParam->name = alignofName( paramName );
+                        last = mutDecl->params.insert( last, alignParam );
+                        ++last;
                 }
                 // TODO: These should possibly all be gone.
@@ -1600 +1696 @@
         // Add size/align for generic parameter types to parameter list.
         std::set<std::string> seenTypes;
-        ast::vector<ast::DeclWithType> otypeParams;
+        std::vector<ast::ptr<ast::DeclWithType>> otypeParams;
         for ( ast::ptr<ast::DeclWithType> & funcParam : mutDecl->params ) {
-                ast::Type const * polyType = isPolyType( funcParam->get_type(), localTypeVars );
+                ast::Type const * polyType = isPolyType( funcParam->get_type(), scopeTypeVars );
                 if ( !polyType || dynamic_cast<ast::TypeInstType const *>( polyType ) ) {
                         continue;
@@ -1608 +1704 @@
                 std::string typeName = Mangle::mangleType( polyType );
                 if ( seenTypes.count( typeName ) ) continue;
+
+                ast::ObjectDecl * sizeParam = ast::deepCopy( &newObj );
+                sizeParam->location = funcParam->location;
+                sizeParam->name = sizeofName( typeName );
+                otypeParams.emplace_back( sizeParam );
+
+                ast::ObjectDecl * alignParam = ast::deepCopy( &newObj );
+                alignParam->location = funcParam->location;
+                alignParam->name = alignofName( typeName );
+                otypeParams.emplace_back( alignParam );
+
+                if ( auto * polyStruct =
+                                dynamic_cast<ast::StructInstType const *>( polyType ) ) {
+                        // Zero-length arrays are illegal in C, so empty structs have no
+                        // offset array.
+                        if ( !polyStruct->base->members.empty() ) {
+                                ast::ObjectDecl * offsetParam = ast::deepCopy( &newPtr );
+                                offsetParam->location = funcParam->location;
+                                offsetParam->name = offsetofName( typeName );
+                                otypeParams.emplace_back( offsetParam );
+                        }
+                }
                 seenTypes.insert( typeName );
-
-                auto sizeParam = makeObj( funcParam->location, sizeofName( typeName ) );
-                otypeParams.emplace_back( sizeParam );
-
-                auto alignParam = makeObj( funcParam->location, alignofName( typeName ) );
-                otypeParams.emplace_back( alignParam );
-
-                // Zero-length arrays are illegal in C, so empty structs have no
-                // offset array.
-                if ( auto * polyStruct =
-                                dynamic_cast<ast::StructInstType const *>( polyType ) ;
-                                polyStruct && !polyStruct->base->members.empty() ) {
-                        auto offsetParam = makePtr( funcParam->location, offsetofName( typeName ) );
-                        otypeParams.emplace_back( offsetParam );
-                }
-        }
-
-        // Prepend each argument group. From last group to first. addAdapters
-        // does do the same, it just does it itself and see all other parameters.
-        spliceBegin( mutDecl->params, inferredParams );
-        spliceBegin( mutDecl->params, otypeParams );
-        spliceBegin( mutDecl->params, layoutParams );
-        addAdapters( mutDecl, localTypeVars );
+        }
+
+        // TODO: A unified way of putting these together might be nice.
+        // Put the list together: adapters (in helper) otype parameters,
+        // inferred params., layout params. (done) and finally explicit params.
+        spliceBegin( inferredParams, otypeParams );
+        spliceAt( mutDecl->params, last, inferredParams );
+        mutDecl = addAdapters( mutDecl );
 
         return mutDecl;
 }
 
-ast::FunctionDecl const * DeclAdapter::postvisit(
+ast::DeclWithType const * DeclAdapter::postvisit(
                 ast::FunctionDecl const * decl ) {
         ast::FunctionDecl * mutDecl = mutate( decl );
@@ -1670 +1773 @@
 }
 
-void DeclAdapter::addAdapters(
-                ast::FunctionDecl * mutDecl, TypeVarMap & localTypeVars ) {
-        ast::vector<ast::FunctionType> functions;
+void DeclAdapter::previsit( ast::CompoundStmt const * ) {
+        GuardScope( scopeTypeVars );
+        // TODO: It is entirely possible the scope doesn't need to spread
+        // across multiple functions. Otherwise, find a better clear.
+        std::set<TypeVarMap::key_type> keys;
+        for ( auto pair : const_cast<TypeVarMap const &>( scopeTypeVars ) ) {
+                keys.insert( pair.first );
+        }
+        for ( auto key : keys ) {
+                scopeTypeVars.erase( key );
+        }
+}
+
+// It actually does mutate in-place, but does the return for consistency.
+ast::FunctionDecl * DeclAdapter::addAdapters( ast::FunctionDecl * mutDecl ) {
+        std::vector<ast::ptr<ast::FunctionType>> functions;
         for ( ast::ptr<ast::DeclWithType> & arg : mutDecl->params ) {
                 ast::Type const * type = arg->get_type();
-                type = findAndReplaceFunction( type, functions, localTypeVars, needsAdapter );
+                type = findAndReplaceFunction( type, functions, scopeTypeVars, needsAdapter );
                 arg.get_and_mutate()->set_type( type );
         }
         std::set<std::string> adaptersDone;
         for ( ast::ptr<ast::FunctionType> const & func : functions ) {
-                std::string mangleName = mangleAdapterName( func, localTypeVars );
+                std::string mangleName = mangleAdapterName( func, scopeTypeVars );
                 if ( adaptersDone.find( mangleName ) != adaptersDone.end() ) {
                         continue;
@@ -1688 +1804 @@
                 mutDecl->params.insert( mutDecl->params.begin(), new ast::ObjectDecl(
                         mutDecl->location, adapterName,
-                        new ast::PointerType( makeAdapterType( func, localTypeVars ) ),
+                        new ast::PointerType( makeAdapterType( func, scopeTypeVars ) ),
                         nullptr, {}, {}, nullptr,
                         { new ast::Attribute( "unused" ) } ) );
                 adaptersDone.insert( adaptersDone.begin(), mangleName );
         }
+        return mutDecl;
 }
 
@@ -1809 +1926 @@
         /// Namer for VLA (variable length array) buffers.
         UniqueName bufNamer;
-        /// If the argument of an AddressExpr is MemberExpr, it is stored here.
-        ast::MemberExpr const * addrMember = nullptr;
+        /// AddressExpr argument is MemberExpr? (TODO: What?)
+        ast::Expr const * addrMember = nullptr;
         /// Used to avoid recursing too deep in type declarations.
         bool expect_func_type = false;
@@ -1842 +1959 @@
         beginTypeScope( decl->type );
 
-        // TODO: Going though dec->params does not work for some reason.
+        // - Tried inserting this code.
+        // Make sure that any type information passed into the function is
+        // accounted for.
+        // TODO: For some reason going through decl->params/->get_type() does
+        // not work. Possibly something is not getting updated.
         for ( ast::ptr<ast::Type> const & funcParam : decl->type->params ) {
                 // Condition here duplicates that in `DeclAdapter::previsit( FunctionDecl const * )`
@@ -1898 +2019 @@
 ast::StructDecl const * PolyGenericCalculator::previsit(
                 ast::StructDecl const * decl ) {
+        //return strict_dynamic_cast<ast::StructDecl *>( mutateMembers( decl ) );
         auto mutDecl = mutate( decl );
         mutateMembers( mutDecl );
@@ -1905 +2027 @@
 ast::UnionDecl const * PolyGenericCalculator::previsit(
                 ast::UnionDecl const * decl ) {
+        //return strict_dynamic_cast<ast::UnionDecl *>( mutateMembers( decl ) );
         auto mutDecl = mutate( decl );
         mutateMembers( mutDecl );
@@ -1965 +2088 @@
         auto mutDecl = mutate( decl );
 
-        // Forally, side effects are not safe in this function. But it works.
+        //mutDecl->attributes.remove_if( matchAndMove );
+        // TODO: This common helper might work, but does not officially support
+        // side effects.
         erase_if( mutDecl->attributes, matchAndMove );
 
@@ -2073 +2198 @@
         // the substitution manually. For some reason this is not currently the
         // case. This requires more investigation.
-        ast::ptr<ast::Type> memberType = deepCopy( expr->member->get_type() );
+        ast::Type const * memberType = deepCopy( expr->member->get_type() );
         ast::TypeSubstitution sub = genericSubstitution( objectType );
-        sub.apply( memberType );
-
+        auto result = sub.apply( memberType );
+        memberType = result.node.get(); // .release();
         // Not all members of a polymorphic type are themselves of a polymorphic
         // type; in this cas the member expression should be wrapped and
@@ -2092 +2217 @@
 
 void PolyGenericCalculator::previsit( ast::AddressExpr const * expr ) {
+        // Is the argument a MemberExpr before mutating?
         GuardValue( addrMember ) = expr->arg.as<ast::MemberExpr>();
 }
@@ -2107 +2233 @@
         // MemberExpr was converted to pointer + offset; and it is not valid C to
         // take the address of an addition, so stript the address-of.
-        // It also preserves the env value.
-        return ast::mutate_field( expr->arg.get(), &ast::Expr::env, expr->env );
+        // TODO: should expr->arg->result be changed to expr->result?
+        ast::Expr * ret = mutate( expr->arg.get() );
+        ret->env = expr->env;
+        return ret;
 }
 
@@ -2444 +2572 @@
                 public BoxPass,
                 public ast::WithGuards {
-        void guardTypeVarMap( ast::Type const * type ) {
-                GuardScope( scopeTypeVars );
-                makeTypeVarMap( type, scopeTypeVars );
-        }
+        template<typename decl_t>
+        decl_t const * handleDecl( decl_t const * decl, ast::Type const * type );
 
         ast::ObjectDecl const * previsit( ast::ObjectDecl const * decl );
@@ -2459 +2585 @@
 };
 
+template<typename decl_t>
+decl_t const * Eraser::handleDecl(
+                decl_t const * decl, ast::Type const * type ) {
+        GuardScope( scopeTypeVars );
+        makeTypeVarMap( type, scopeTypeVars );
+        return scrubAllTypeVars( decl );
+}
+
 ast::ObjectDecl const * Eraser::previsit( ast::ObjectDecl const * decl ) {
-        guardTypeVarMap( decl->type );
-        return scrubAllTypeVars( decl );
+        return handleDecl( decl, decl->type );
 }
 
 ast::FunctionDecl const * Eraser::previsit( ast::FunctionDecl const * decl ) {
-        guardTypeVarMap( decl->type );
-        return scrubAllTypeVars( decl );
+        return handleDecl( decl, decl->type );
 }
 
 ast::TypedefDecl const * Eraser::previsit( ast::TypedefDecl const * decl ) {
-        guardTypeVarMap( decl->base );
-        return scrubAllTypeVars( decl );
+        return handleDecl( decl, decl->base );
 }
 
@@ -2477 +2608 @@
 template<typename node_t>
 node_t const * stripGenericMembers( node_t const * decl ) {
-        if ( decl->params.empty() ) return decl;
-        auto mutDecl = ast::mutate( decl );
-        mutDecl->members.clear();
-        return mutDecl;
+        if ( !decl->params.empty() ) {
+                auto mutDecl = ast::mutate( decl );
+                mutDecl->members.clear();
+                return mutDecl;
+        }
+        return decl;
 }
 
@@ -2496 +2629 @@
 
 void Eraser::previsit( ast::PointerType const * type ) {
-        guardTypeVarMap( type );
+        GuardScope( scopeTypeVars );
+        makeTypeVarMap( type, scopeTypeVars );
 }
 
 void Eraser::previsit( ast::FunctionType const * type ) {
-        guardTypeVarMap( type );
+        GuardScope( scopeTypeVars );
+        makeTypeVarMap( type, scopeTypeVars );
 }