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

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(
@@ -510 +509 @@
                 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.
@@ -587 +581 @@
         ast::FunctionType const * type = decl->type;
         if ( isDynRet( type ) && decl->linkage != ast::Linkage::C ) {
-                //retval = type->returns.front();
                 retval = decl->returns.front();
 
@@ -748 +741 @@
 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();
         }
@@ -1063 +1051 @@
                 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, "?=?", {
@@ -1245 +1229 @@
                         }
                         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
-                ast::Storage::Classes(), // storage
-                ast::Linkage::C // linkage
-                // attrs
-                // fs
-                // isVarArgs
+                {}, // storage
+                ast::Linkage::C
         );
 
@@ -1314 +1295 @@
         // 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, "?=?" ) );
@@ -1546 +1518 @@
 
 // --------------------------------------------------------------------------
-/// Creates the adapter functions. TODO
+/// Modifies declarations to accept implicit parameters.
 /// * Move polymorphic returns in function types to pointer-type parameters.
 /// * Adds type size and assertion parameters to parameter lists.
-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 );
+struct DeclAdapter final {
         ast::FunctionDecl const * previsit( ast::FunctionDecl const * decl );
-        ast::DeclWithType const * postvisit( ast::FunctionDecl const * decl );
-        void previsit( ast::CompoundStmt const * stmt );
+        ast::FunctionDecl const * postvisit( ast::FunctionDecl const * decl );
 private:
-        ast::FunctionDecl * addAdapters( ast::FunctionDecl * decl );
-
-        std::map<UniqueId, std::string> adapterName;
+        void addAdapters( ast::FunctionDecl * decl, TypeVarMap & localTypeVars );
 };
 
-// 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 );
+// 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 );
 }
 
 ast::FunctionDecl const * DeclAdapter::previsit( ast::FunctionDecl const * decl ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( decl, scopeTypeVars );
+        TypeVarMap localTypeVars = { ast::TypeData() };
+        makeTypeVarMap( decl, localTypeVars );
 
         auto mutDecl = mutate( decl );
@@ -1639 +1561 @@
 
         // Add size/align and assertions for type parameters to parameter list.
-        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 );
+        ast::vector<ast::DeclWithType> inferredParams;
+        ast::vector<ast::DeclWithType> layoutParams;
         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 );
 
-                        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;
+                        auto sizeParam = makeObj( typeParam->location, sizeofName( paramName ) );
+                        layoutParams.emplace_back( sizeParam );
+
+                        auto alignParam = makeObj( typeParam->location, alignofName( paramName ) );
+                        layoutParams.emplace_back( alignParam );
                 }
                 // TODO: These should possibly all be gone.
@@ -1696 +1600 @@
         // Add size/align for generic parameter types to parameter list.
         std::set<std::string> seenTypes;
-        std::vector<ast::ptr<ast::DeclWithType>> otypeParams;
+        ast::vector<ast::DeclWithType> otypeParams;
         for ( ast::ptr<ast::DeclWithType> & funcParam : mutDecl->params ) {
-                ast::Type const * polyType = isPolyType( funcParam->get_type(), scopeTypeVars );
+                ast::Type const * polyType = isPolyType( funcParam->get_type(), localTypeVars );
                 if ( !polyType || dynamic_cast<ast::TypeInstType const *>( polyType ) ) {
                         continue;
@@ -1704 +1608 @@
                 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 );
+                seenTypes.insert( typeName );
+
+                auto sizeParam = makeObj( funcParam->location, sizeofName( typeName ) );
                 otypeParams.emplace_back( sizeParam );
 
-                ast::ObjectDecl * alignParam = ast::deepCopy( &newObj );
-                alignParam->location = funcParam->location;
-                alignParam->name = alignofName( typeName );
+                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 ) ) {
-                        // 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 );
-        }
-
-        // 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 );
+                                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 );
 
         return mutDecl;
 }
 
-ast::DeclWithType const * DeclAdapter::postvisit(
+ast::FunctionDecl const * DeclAdapter::postvisit(
                 ast::FunctionDecl const * decl ) {
         ast::FunctionDecl * mutDecl = mutate( decl );
@@ -1773 +1670 @@
 }
 
-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;
+void DeclAdapter::addAdapters(
+                ast::FunctionDecl * mutDecl, TypeVarMap & localTypeVars ) {
+        ast::vector<ast::FunctionType> functions;
         for ( ast::ptr<ast::DeclWithType> & arg : mutDecl->params ) {
                 ast::Type const * type = arg->get_type();
-                type = findAndReplaceFunction( type, functions, scopeTypeVars, needsAdapter );
+                type = findAndReplaceFunction( type, functions, localTypeVars, 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, scopeTypeVars );
+                std::string mangleName = mangleAdapterName( func, localTypeVars );
                 if ( adaptersDone.find( mangleName ) != adaptersDone.end() ) {
                         continue;
@@ -1804 +1688 @@
                 mutDecl->params.insert( mutDecl->params.begin(), new ast::ObjectDecl(
                         mutDecl->location, adapterName,
-                        new ast::PointerType( makeAdapterType( func, scopeTypeVars ) ),
+                        new ast::PointerType( makeAdapterType( func, localTypeVars ) ),
                         nullptr, {}, {}, nullptr,
                         { new ast::Attribute( "unused" ) } ) );
                 adaptersDone.insert( adaptersDone.begin(), mangleName );
         }
-        return mutDecl;
 }
 
@@ -1926 +1809 @@
         /// Namer for VLA (variable length array) buffers.
         UniqueName bufNamer;
-        /// AddressExpr argument is MemberExpr? (TODO: What?)
-        ast::Expr const * addrMember = nullptr;
+        /// If the argument of an AddressExpr is MemberExpr, it is stored here.
+        ast::MemberExpr const * addrMember = nullptr;
         /// Used to avoid recursing too deep in type declarations.
         bool expect_func_type = false;
@@ -1959 +1842 @@
         beginTypeScope( decl->type );
 
-        // - 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.
+        // TODO: Going though dec->params does not work for some reason.
         for ( ast::ptr<ast::Type> const & funcParam : decl->type->params ) {
                 // Condition here duplicates that in `DeclAdapter::previsit( FunctionDecl const * )`
@@ -2019 +1898 @@
 ast::StructDecl const * PolyGenericCalculator::previsit(
                 ast::StructDecl const * decl ) {
-        //return strict_dynamic_cast<ast::StructDecl *>( mutateMembers( decl ) );
         auto mutDecl = mutate( decl );
         mutateMembers( mutDecl );
@@ -2027 +1905 @@
 ast::UnionDecl const * PolyGenericCalculator::previsit(
                 ast::UnionDecl const * decl ) {
-        //return strict_dynamic_cast<ast::UnionDecl *>( mutateMembers( decl ) );
         auto mutDecl = mutate( decl );
         mutateMembers( mutDecl );
@@ -2088 +1965 @@
         auto mutDecl = mutate( decl );
 
-        //mutDecl->attributes.remove_if( matchAndMove );
-        // TODO: This common helper might work, but does not officially support
-        // side effects.
+        // Forally, side effects are not safe in this function. But it works.
         erase_if( mutDecl->attributes, matchAndMove );
 
@@ -2198 +2073 @@
         // the substitution manually. For some reason this is not currently the
         // case. This requires more investigation.
-        ast::Type const * memberType = deepCopy( expr->member->get_type() );
+        ast::ptr<ast::Type> memberType = deepCopy( expr->member->get_type() );
         ast::TypeSubstitution sub = genericSubstitution( objectType );
-        auto result = sub.apply( memberType );
-        memberType = result.node.get(); // .release();
+        sub.apply( memberType );
+
         // Not all members of a polymorphic type are themselves of a polymorphic
         // type; in this cas the member expression should be wrapped and
@@ -2217 +2092 @@
 
 void PolyGenericCalculator::previsit( ast::AddressExpr const * expr ) {
-        // Is the argument a MemberExpr before mutating?
         GuardValue( addrMember ) = expr->arg.as<ast::MemberExpr>();
 }
@@ -2233 +2107 @@
         // MemberExpr was converted to pointer + offset; and it is not valid C to
         // take the address of an addition, so stript the address-of.
-        // TODO: should expr->arg->result be changed to expr->result?
-        ast::Expr * ret = mutate( expr->arg.get() );
-        ret->env = expr->env;
-        return ret;
+        // It also preserves the env value.
+        return ast::mutate_field( expr->arg.get(), &ast::Expr::env, expr->env );
 }
 
@@ -2572 +2444 @@
                 public BoxPass,
                 public ast::WithGuards {
-        template<typename decl_t>
-        decl_t const * handleDecl( decl_t const * decl, ast::Type const * type );
+        void guardTypeVarMap( ast::Type const * type ) {
+                GuardScope( scopeTypeVars );
+                makeTypeVarMap( type, scopeTypeVars );
+        }
 
         ast::ObjectDecl const * previsit( ast::ObjectDecl const * decl );
@@ -2585 +2459 @@
 };
 
-template<typename decl_t>
-decl_t const * Eraser::handleDecl(
-                decl_t const * decl, ast::Type const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+ast::ObjectDecl const * Eraser::previsit( ast::ObjectDecl const * decl ) {
+        guardTypeVarMap( decl->type );
         return scrubAllTypeVars( decl );
 }
 
-ast::ObjectDecl const * Eraser::previsit( ast::ObjectDecl const * decl ) {
-        return handleDecl( decl, decl->type );
-}
-
 ast::FunctionDecl const * Eraser::previsit( ast::FunctionDecl const * decl ) {
-        return handleDecl( decl, decl->type );
+        guardTypeVarMap( decl->type );
+        return scrubAllTypeVars( decl );
 }
 
 ast::TypedefDecl const * Eraser::previsit( ast::TypedefDecl const * decl ) {
-        return handleDecl( decl, decl->base );
+        guardTypeVarMap( decl->base );
+        return scrubAllTypeVars( decl );
 }
 
@@ -2608 +2477 @@
 template<typename node_t>
 node_t const * stripGenericMembers( node_t const * decl ) {
-        if ( !decl->params.empty() ) {
-                auto mutDecl = ast::mutate( decl );
-                mutDecl->members.clear();
-                return mutDecl;
-        }
-        return decl;
+        if ( decl->params.empty() ) return decl;
+        auto mutDecl = ast::mutate( decl );
+        mutDecl->members.clear();
+        return mutDecl;
 }
 
@@ -2629 +2496 @@
 
 void Eraser::previsit( ast::PointerType const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+        guardTypeVarMap( type );
 }
 
 void Eraser::previsit( ast::FunctionType const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+        guardTypeVarMap( type );
 }