source: src/SymTab/Indexer.h @ 28af389

//
// 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.
//
// Indexer.h --
//
// Author           : Richard C. Bilson
// Created On       : Sun May 17 21:38:55 2015
// Last Modified By : Aaron B. Moss
// Last Modified On : Fri Mar  8 13:55:00 2019
// Update Count     : 9
//

#pragma once

#include <functional>              // for function
#include <list>                    // for list
#include <memory>                  // for shared_ptr, enable_shared_from_this
#include <string>                  // for string

#include "Common/PersistentMap.h"  // for PersistentMap
#include "SynTree/SynTree.h"       // for AST nodes

namespace ResolvExpr {
        class Cost;
}

namespace SymTab {
        class Indexer : public std::enable_shared_from_this<SymTab::Indexer> {
        public:
                explicit Indexer();
                virtual ~Indexer();

                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to 
                // tell the indexer explicitly when scopes begin and end
                void enterScope();
                void leaveScope();

                struct IdData {
                        DeclarationWithType * id = nullptr;
                        Expression * baseExpr = nullptr; // WithExpr

                        /// non-null if this declaration is deleted
                        BaseSyntaxNode * deleteStmt = nullptr;
                        /// scope of identifier
                        unsigned long scope = 0;

                        // NOTE: shouldn't need either of these constructors, but gcc-4 does not properly support initializer lists with default members.
                        IdData() = default;
                        IdData( 
                                DeclarationWithType * id, Expression * baseExpr, BaseSyntaxNode * deleteStmt,
                                unsigned long scope ) 
                                : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ), scope( scope ) {}
                        IdData( const IdData& o, BaseSyntaxNode * deleteStmt )
                                : id( o.id ), baseExpr( o.baseExpr ), deleteStmt( deleteStmt ), scope( o.scope ) {}

                        Expression * combine( ResolvExpr::Cost & cost ) const;
                };

                /// Gets all declarations with the given ID
                void lookupId( const std::string &id, std::list< IdData > &out ) const;
                /// Gets the top-most type declaration with the given ID
                NamedTypeDecl *lookupType( const std::string &id ) const;
                /// Gets the top-most struct declaration with the given ID
                StructDecl *lookupStruct( const std::string &id ) const;
                /// Gets the top-most enum declaration with the given ID
                EnumDecl *lookupEnum( const std::string &id ) const;
                /// Gets the top-most union declaration with the given ID
                UnionDecl *lookupUnion( const std::string &id ) const;
                /// Gets the top-most trait declaration with the given ID
                TraitDecl *lookupTrait( const std::string &id ) const;

                /// Gets the type declaration with the given ID at global scope
                NamedTypeDecl *globalLookupType( const std::string &id ) const;
                /// Gets the struct declaration with the given ID at global scope
                StructDecl *globalLookupStruct( const std::string &id ) const;
                /// Gets the union declaration with the given ID at global scope
                UnionDecl *globalLookupUnion( const std::string &id ) const;
                /// Gets the enum declaration with the given ID at global scope
                EnumDecl *globalLookupEnum( const std::string &id ) const;

                void addId( DeclarationWithType * decl, Expression * baseExpr = nullptr );
                void addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt );

                void addType( NamedTypeDecl *decl );
                void addStruct( const std::string &id );
                void addStruct( StructDecl *decl );
                void addEnum( EnumDecl *decl );
                void addUnion( const std::string &id );
                void addUnion( UnionDecl *decl );
                void addTrait( TraitDecl *decl );

                /// adds all of the IDs from WithStmt exprs
                void addWith( std::list< Expression * > & withExprs, BaseSyntaxNode * withStmt );

                /// convenience function for adding a list of Ids to the indexer
                void addIds( const std::list< DeclarationWithType * > & decls );

                /// convenience function for adding a list of forall parameters to the indexer
                void addTypes( const std::list< TypeDecl * > & tds );

                /// convenience function for adding all of the declarations in a function type to the indexer
                void addFunctionType( FunctionType * ftype );

          private:
                /// Wraps a Decl* with a scope
                template<typename Decl>
                struct Scoped {
                        Decl* decl;           ///< declaration
                        unsigned long scope;  ///< scope of this declaration

                        Scoped(Decl* d, unsigned long s) : decl(d), scope(s) {}
                };

                using Ptr = std::shared_ptr<const Indexer>;

                using MangleTable = PersistentMap< std::string, IdData >;
                using IdTable = PersistentMap< std::string, MangleTable::Ptr >;
                using TypeTable = PersistentMap< std::string, Scoped<NamedTypeDecl> >;
                using StructTable = PersistentMap< std::string, Scoped<StructDecl> >;
                using EnumTable = PersistentMap< std::string, Scoped<EnumDecl> >;
                using UnionTable = PersistentMap< std::string, Scoped<UnionDecl> >;
                using TraitTable = PersistentMap< std::string, Scoped<TraitDecl> >;

                IdTable::Ptr idTable;          ///< identifier namespace
                TypeTable::Ptr typeTable;      ///< type namespace
                StructTable::Ptr structTable;  ///< struct namespace
                EnumTable::Ptr enumTable;      ///< enum namespace
                UnionTable::Ptr unionTable;    ///< union namespace
                TraitTable::Ptr traitTable;    ///< trait namespace

                Ptr prevScope;                 ///< reference to indexer for parent scope
                unsigned long scope;           ///< Scope index of this indexer
                unsigned long repScope;        ///< Scope index of currently represented scope

                /// Ensures that a proper backtracking scope exists before a mutation
                void lazyInitScope();

                /// Gets the indexer at the given scope
                const Indexer* atScope( unsigned long scope ) const;

                /// Removes matching autogenerated constructors and destructors so that they will not be 
                /// selected. If returns false, passed decl should not be added.
                bool removeSpecialOverrides( IdData& decl, MangleTable::Ptr& mangleTable );

                /// Options for handling identifier conflicts
                struct OnConflict {
                        enum {
                                Error,  ///< Throw a semantic error
                                Delete  ///< Delete the earlier version with the delete statement
                        } mode;
                        BaseSyntaxNode * deleteStmt;  ///< Statement that deletes this expression

                private:
                        OnConflict() : mode(Error), deleteStmt(nullptr) {}
                        OnConflict( BaseSyntaxNode * d ) : mode(Delete), deleteStmt(d) {}
                public:
                        OnConflict( const OnConflict& ) = default;

                        static OnConflict error() { return {}; }
                        static OnConflict deleteWith( BaseSyntaxNode * d ) { return { d }; }
                };

                /// true if the existing identifier conflicts with the added identifier
                bool addedIdConflicts(
                        const IdData& existing, DeclarationWithType * added, OnConflict handleConflicts, 
                        BaseSyntaxNode * deleteStmt );

                /// common code for addId, addDeletedId, etc.
                void addId( 
                        DeclarationWithType * decl, OnConflict handleConflicts, 
                        Expression * baseExpr = nullptr, BaseSyntaxNode * deleteStmt = nullptr );

                /// adds all of the members of the Aggregate (addWith helper)
                void addMembers( AggregateDecl * aggr, Expression * expr, OnConflict handleConflicts );

                /// returns true if there exists a declaration with C linkage and the given name with the same mangled name
                bool hasCompatibleCDecl( const std::string &id, const std::string &mangleName ) const;
                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
                bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const;
        };
} // namespace SymTab

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //