Changeset b067d9b for src/SymTab/Indexer.h

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

773db65, 9421f3d8

Parents:

7951100 (diff), 8364209 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/SymTab/Indexer.h (modified) (3 diffs)

src/SymTab/Indexer.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:38:55 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 17 16:09:12 2017
-// Update Count     : 8
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Mar  8 13:55:00 2019
+// Update Count     : 9
 //
 
 #pragma once
 
-#include <iosfwd>             // for ostream
-#include <list>               // for list
-#include <string>             // for string
-#include <functional>         // for function
+#include <functional>              // for function
+#include <list>                    // for list
+#include <memory>                  // for shared_ptr, enable_shared_from_this
+#include <string>                  // for string
 
-#include "SynTree/Visitor.h"  // for Visitor
-#include "SynTree/SynTree.h"  // for AST nodes
+#include "Common/PersistentMap.h"  // for PersistentMap
+#include "SynTree/SynTree.h"       // for AST nodes
 
 namespace ResolvExpr {
-class Cost;
+        class Cost;
 }
 
 namespace SymTab {
-        class Indexer {
-          public:
+        class Indexer : public std::enable_shared_from_this<SymTab::Indexer> {
+        public:
                 explicit Indexer();
+                virtual ~Indexer();
 
-                Indexer( const Indexer &that );
-                Indexer( Indexer &&that );
-                virtual ~Indexer();
-                Indexer& operator= ( const Indexer &that );
-                Indexer& operator= ( Indexer &&that );
-
-                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to tell the indexer
-                // explicitly when scopes begin and end
+                // 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
+                        const DeclarationWithType * id = nullptr;
+                        const Expression * baseExpr = nullptr; // WithExpr
 
                         /// non-null if this declaration is deleted
-                        BaseSyntaxNode * deleteStmt = nullptr;
+                        const Declaration * 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 ) : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ) {}
+                        IdData(
+                                const DeclarationWithType * id, const Expression * baseExpr, const Declaration * deleteStmt,
+                                unsigned long scope )
+                                : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ), scope( scope ) {}
+                        IdData( const IdData& o, const Declaration * deleteStmt )
+                                : id( o.id ), baseExpr( o.baseExpr ), deleteStmt( deleteStmt ), scope( o.scope ) {}
 
                         Expression * combine( ResolvExpr::Cost & cost ) const;
@@ -59 +61 @@
 
                 /// Gets all declarations with the given ID
-                void lookupId( const std::string &id, std::list< IdData > &out ) const;
+                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;
+                const NamedTypeDecl * lookupType( const std::string & id ) const;
                 /// Gets the top-most struct declaration with the given ID
-                StructDecl *lookupStruct( const std::string &id ) const;
+                const StructDecl * lookupStruct( const std::string & id ) const;
                 /// Gets the top-most enum declaration with the given ID
-                EnumDecl *lookupEnum( const std::string &id ) const;
+                const EnumDecl * lookupEnum( const std::string & id ) const;
                 /// Gets the top-most union declaration with the given ID
-                UnionDecl *lookupUnion( const std::string &id ) const;
+                const UnionDecl * lookupUnion( const std::string & id ) const;
                 /// Gets the top-most trait declaration with the given ID
-                TraitDecl *lookupTrait( const std::string &id ) const;
+                const TraitDecl * lookupTrait( const std::string & id ) const;
 
-                void print( std::ostream &os, int indent = 0 ) const;
+                /// Gets the type declaration with the given ID at global scope
+                const NamedTypeDecl * globalLookupType( const std::string & id ) const;
+                /// Gets the struct declaration with the given ID at global scope
+                const StructDecl * globalLookupStruct( const std::string & id ) const;
+                /// Gets the union declaration with the given ID at global scope
+                const UnionDecl * globalLookupUnion( const std::string & id ) const;
+                /// Gets the enum declaration with the given ID at global scope
+                const EnumDecl * globalLookupEnum( const std::string & id ) const;
 
-                /// looks up a specific mangled ID at the given scope
-                IdData * lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope );
-                const IdData * lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) 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, unsigned long scope ) const;
-                /// 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, unsigned long scope ) const;
-                // equivalents to lookup functions that only look at tables at scope `scope` (which should be >= tables->scope)
-                NamedTypeDecl *lookupTypeAtScope( const std::string &id, unsigned long scope ) const;
-                StructDecl *lookupStructAtScope( const std::string &id, unsigned long scope ) const;
-                EnumDecl *lookupEnumAtScope( const std::string &id, unsigned long scope ) const;
-                UnionDecl *lookupUnionAtScope( const std::string &id, unsigned long scope ) const;
-                TraitDecl *lookupTraitAtScope( const std::string &id, unsigned long scope ) const;
+                void addId( const DeclarationWithType * decl, const Expression * baseExpr = nullptr );
+                void addDeletedId( const DeclarationWithType * decl, const Declaration * deleteStmt );
 
-                typedef std::function<bool(IdData &, const std::string &)> ConflictFunction;
-
-                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 );
+                void addType( const NamedTypeDecl * decl );
+                void addStruct( const std::string & id );
+                void addStruct( const StructDecl * decl );
+                void addEnum( const EnumDecl * decl );
+                void addUnion( const std::string & id );
+                void addUnion( const UnionDecl * decl );
+                void addTrait( const TraitDecl * decl );
 
                 /// adds all of the IDs from WithStmt exprs
-                void addWith( std::list< Expression * > & withExprs, BaseSyntaxNode * withStmt );
-
-                /// adds all of the members of the Aggregate (addWith helper)
-                void addMembers( AggregateDecl * aggr, Expression * expr, ConflictFunction );
+                void addWith( const std::list< Expression * > & withExprs, const Declaration * withStmt );
 
                 /// convenience function for adding a list of Ids to the indexer
@@ -113 +103 @@
 
                 /// convenience function for adding all of the declarations in a function type to the indexer
-                void addFunctionType( FunctionType * ftype );
+                void addFunctionType( const FunctionType * ftype );
 
-                bool doDebug = false; ///< Display debugging trace?
           private:
-                struct Impl;
+                /// Wraps a Decl * with a scope
+                template<typename Decl>
+                struct Scoped {
+                        const Decl * decl;           ///< declaration
+                        unsigned long scope;  ///< scope of this declaration
 
-                Impl *tables;         ///< Copy-on-write instance of table data structure
-                unsigned long scope;  ///< Scope index of this pointer
+                        Scoped(const Decl * d, unsigned long s) : decl(d), scope(s) {}
+                };
 
-                /// Takes a new ref to a table (returns null if null)
-                static Impl *newRef( Impl *toClone );
-                /// Clears a ref to a table (does nothing if null)
-                static void deleteRef( Impl *toFree );
+                using Ptr = std::shared_ptr<const Indexer>;
 
-                // Removes matching autogenerated constructors and destructors
-                // so that they will not be selected
-                // void removeSpecialOverrides( FunctionDecl *decl );
-                void removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const;
+                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> >;
 
-                /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope)
-                void makeWritable();
+                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;
+                        const Declaration * deleteStmt;  ///< Statement that deletes this expression
+
+                private:
+                        OnConflict() : mode(Error), deleteStmt(nullptr) {}
+                        OnConflict( const Declaration * d ) : mode(Delete), deleteStmt(d) {}
+                public:
+                        OnConflict( const OnConflict& ) = default;
+
+                        static OnConflict error() { return {}; }
+                        static OnConflict deleteWith( const Declaration * d ) { return { d }; }
+                };
+
+                /// true if the existing identifier conflicts with the added identifier
+                bool addedIdConflicts(
+                        const IdData & existing, const DeclarationWithType * added, OnConflict handleConflicts,
+                        const Declaration * deleteStmt );
 
                 /// common code for addId, addDeletedId, etc.
-                void addId( DeclarationWithType * decl, ConflictFunction, Expression * baseExpr = nullptr, BaseSyntaxNode * deleteStmt = nullptr );
+                void addId(const DeclarationWithType * decl, OnConflict handleConflicts,
+                        const Expression * baseExpr = nullptr, const Declaration * deleteStmt = nullptr );
+
+                /// adds all of the members of the Aggregate (addWith helper)
+                void addMembers( const AggregateDecl * aggr, const 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