source: src/Common/CodeLocationTools.cpp@ 0f7a0ea

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// CodeLocationTools.cpp -- Additional tools for code locations.
//
// Author           : Andrew Beach
// Created On       : Fri Dec  4 15:42:00 2020
// Last Modified By : Andrew Beach
// Last Modified On : Mon Dec  7 15:15:00 2020
// Update Count     : 0
//

#include "CodeLocationTools.hpp"

#include <type_traits>

#include "AST/Pass.hpp"
#include "AST/TranslationUnit.hpp"
#include "Common/CodeLocation.h"

namespace {

template<typename node_t>
struct has_code_location : public std::is_base_of<ast::ParseNode, node_t> {};

// Fill every location
class FillCore : public ast::WithGuards {
        CodeLocation const * parent;

        // This mimics a partially specialized method.
        template<typename node_t, bool has_location>
        struct FillNode;
        template<typename node_t, bool has_location>
        friend struct FillNode;

        template<typename node_t>
        struct FillNode<node_t, true> {
                static node_t const * go( FillCore * core, node_t const * node ) {
                        node_t * newNode = nullptr;
                        if ( node->location.isUnset() ) {
                                // Just hoping that top level nodes are always marked.
                                assert( core->parent );
                                newNode = ast::mutate( node );
                                newNode->location = *core->parent;
                        }
                        core->GuardValue( core->parent );
                        core->parent = &node->location;
                        return (newNode) ? newNode : node;
                }
        };

        template<typename node_t>
        struct FillNode<node_t, false> {
                static node_t const * go( FillCore *, node_t const * node ) {
                        return node;
                }
        };
public:
        FillCore() : parent( nullptr ) {}

        template<typename node_t>
        node_t const * previsit( node_t const * node ) {
                using Filler = FillNode<node_t, has_code_location<node_t>::value>;
                return Filler::go( this, node );
        }
};

template<typename node_t, bool has_location>
struct __GetCL;

template<typename node_t>
struct __GetCL<node_t, true> {
        static CodeLocation const * get( node_t const * node ) {
                return &node->location;
        }
};

template<typename node_t>
struct __GetCL<node_t, false> {
        static CodeLocation const * get( node_t const * ) {
                return nullptr;
        }
};

template<typename node_t>
CodeLocation const * get_code_location( node_t const * node ) {
        return __GetCL< node_t, has_code_location< node_t >::value >::get( node );
}

// Collect pointers to all the nodes with unset code locations.
class CollectCore {
        std::list< ast::ptr< ast::Node > > & unset;
public:
        CollectCore( std::list< ast::ptr< ast::Node > > & unset ) :
                unset( unset )
        {}

        template<typename node_t>
        void previsit( node_t const * node ) {
                CodeLocation const * location = get_code_location( node );
                if ( location && location->isUnset() ) {
                        unset.push_back( node );
                }
        }
};

} // namespace

void checkAllCodeLocations( ast::TranslationUnit const & unit ) {
        std::list< ast::ptr< ast::Node > > unsetNodes;
        {
                ast::Pass<CollectCore> collector( unsetNodes );
                for ( auto node : unit.decls ) {
                        node->accept( collector );
                }
        }
        if ( unsetNodes.empty() ) {
                return;
        }

        std::cerr << "Total nodes without a set code location: "
                << unsetNodes.size() << std::endl;

        assert( unsetNodes.empty() );
}

void forceFillCodeLocations( ast::TranslationUnit & unit ) {
        ast::Pass<FillCore>::run( unit );
}