Changeset d1caa6c

Timestamp:

Mar 9, 2016, 12:30:14 PM (8 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

0531b5d

Parents:

ac633d0

Message:

Refactor ConcreteType?, InstantiationMap? to be more generically useful

File:

• src/GenPoly/Box.cc (modified) (7 diffs)

src/GenPoly/Box.cc

@@ -62 +62 @@
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
 
-                /// Key for a unique concrete type; generic base type paired with type parameter list
-                struct ConcreteType {
-                        ConcreteType() : base(NULL), params() {}
-
-                        ConcreteType(AggregateDecl *_base, const std::list< Type* >& _params) : base(_base), params() { cloneAll(_params, params); }
-
-                        ConcreteType(const ConcreteType& that) : base(that.base), params() { cloneAll(that.params, params); }
+                /// Abstracts type equality for a list of parameter types
+                struct TypeList {
+                        TypeList() : params() {}
+                        TypeList( const std::list< Type* > &_params ) : params() { cloneAll(_params, params); }
+                        TypeList( std::list< Type* > &&_params ) : params( _params ) {}
+
+                        TypeList( const TypeList &that ) : params() { cloneAll(that.params, params); }
+                        TypeList( TypeList &&that ) : params( std::move( that.params ) ) {}
 
                         /// Extracts types from a list of TypeExpr*
-                        ConcreteType(AggregateDecl *_base, const std::list< TypeExpr* >& _params) : base(_base), params() {
+                        TypeList( const std::list< TypeExpr* >& _params ) : params() {
                                 for ( std::list< TypeExpr* >::const_iterator param = _params.begin(); param != _params.end(); ++param ) {
                                         params.push_back( (*param)->get_type()->clone() );
@@ -77 +78 @@
                         }
 
-                        ConcreteType& operator= (const ConcreteType& that) {
+                        TypeList& operator= ( const TypeList &that ) {
                                 deleteAll( params );
+
                                 params.clear();
-
-                                base = that.base;
                                 cloneAll( that.params, params );
 
@@ -87 +87 @@
                         }
 
-                        ~ConcreteType() { deleteAll( params ); }
-
-                        bool operator== (const ConcreteType& that) const {
-                                if ( base != that.base ) return false;
+                        TypeList& operator= ( TypeList &&that ) {
+                                deleteAll( params );
+
+                                params = std::move( that.params );
+
+                                return *this;
+                        }
+
+                        ~TypeList() { deleteAll( params ); }
+
+                        bool operator== ( const TypeList& that ) const {
+                                if ( params.size() != that.params.size() ) return false;
 
                                 SymTab::Indexer dummy;
-                                if ( params.size() != that.params.size() ) return false;
                                 for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) {
                                         if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false;
@@ -100 +107 @@
                         }
 
-                        AggregateDecl *base;        ///< Base generic type
                         std::list< Type* > params;  ///< Instantiation parameters
                 };
 
-                /// Maps a concrete type to the some value, accounting for scope
-                template< typename Value >
+                /// Maps a key and a TypeList to the some value, accounting for scope
+                template< typename Key, typename Value >
                 class InstantiationMap {
-                        /// Information about a specific instantiation of a generic type
-                        struct Instantiation {
-                                ConcreteType key;  ///< Instantiation parameters for this type
-                                Value *value;      ///< Value for this instantiation
-
-                                Instantiation() : key(), value(0) {}
-                                Instantiation(const ConcreteType &_key, Value *_value) : key(_key), value(_value) {}
-                        };
-                        /// Map of generic types to instantiations of them
-                        typedef std::map< AggregateDecl*, std::vector< Instantiation > > Scope;
+                        /// Wraps value for a specific (Key, TypeList) combination
+                        typedef std::pair< TypeList, Value* > Instantiation;
+                        /// Map of keys to instantiations of them
+                        typedef std::map< Key*, std::vector< Instantiation > > Scope;
 
                         std::vector< Scope > scopes;  ///< list of scopes, from outermost to innermost
@@ -135 +135 @@
                         InstantiationMap() { beginScope(); }
 
-                        /// Gets the value for the concrete instantiation of this type, assuming it has already been instantiated in the current scope.
-                        /// Returns NULL on none such.
-                        Value *lookup( AggregateDecl *generic, const std::list< TypeExpr* >& params ) {
-                                ConcreteType key(generic, params);
+                        /// Gets the value for the (key, typeList) pair, returns NULL on none such.
+                        Value *lookup( Key *key, const std::list< TypeExpr* >& params ) {
+                                TypeList typeList( params );
+                                
                                 // scan scopes from innermost out
                                 for ( typename std::vector< Scope >::const_reverse_iterator scope = scopes.rbegin(); scope != scopes.rend(); ++scope ) {
-                                        // skip scope if no instantiations of this generic type
-                                        typename Scope::const_iterator insts = scope->find( generic );
+                                        // skip scope if nothing for this key
+                                        typename Scope::const_iterator insts = scope->find( key );
                                         if ( insts == scope->end() ) continue;
-                                        // look through instantiations for matches to concrete type
+                                        // look through instantiations for matches to typeList
                                         for ( typename std::vector< Instantiation >::const_iterator inst = insts->second.begin(); inst != insts->second.end(); ++inst ) {
-                                                if ( inst->key == key ) return inst->value;
+                                                if ( inst->first == typeList ) return inst->second;
                                         }
                                 }
@@ -153 +153 @@
                         }
 
-                        /// Adds a value for a concrete type to the current scope
-                        void insert( AggregateDecl *generic, const std::list< TypeExpr* > &params, Value *value ) {
-                                ConcreteType key(generic, params);
-                                scopes.back()[generic].push_back( Instantiation( key, value ) );
+                        /// Adds a value for a (key, typeList) pair to the current scope
+                        void insert( Key *key, const std::list< TypeExpr* > &params, Value *value ) {
+                                scopes.back()[key].push_back( Instantiation( TypeList( params ), value ) );
                         }
                 };
@@ -245 +244 @@
                 class GenericInstantiator : public DeclMutator {
                         /// Map of (generic type, parameter list) pairs to concrete type instantiations
-                        InstantiationMap< AggregateDecl > instantiations;
+                        InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
                         /// Namer for concrete types
                         UniqueName typeNamer;