Changeset fa2c005

Timestamp:

Jun 8, 2023, 3:19:43 PM (4 months ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT

Parents:

044ae62

Message:

Finish Adt POC

Location:

src

Files:

• AST/Convert.cpp (modified) (5 diffs)
• AST/Decl.hpp (modified) (2 diffs)
• AST/Fwd.hpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (4 diffs)
• AST/Pass.proto.hpp (modified) (3 diffs)
• AST/Print.cpp (modified) (1 diff)
• AST/SymbolTable.cpp (modified) (3 diffs)
• AST/SymbolTable.hpp (modified) (2 diffs)
• AST/Type.cpp (modified) (1 diff)
• AST/Visitor.hpp (modified) (1 diff)
• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• Common/CodeLocationTools.cpp (modified) (1 diff)
• Common/PassVisitor.h (modified) (3 diffs)
• Common/PassVisitor.impl.h (modified) (3 diffs)
• Common/PassVisitor.proto.h (modified) (2 diffs)
• GenPoly/Box.cc (modified) (2 diffs)
• Parser/DeclarationNode.cc (modified) (5 diffs)
• Parser/DeclarationNode.h (modified) (1 diff)
• Parser/TypeData.cc (modified) (4 diffs)
• Parser/TypeData.h (modified) (2 diffs)
• SymTab/Validate.cc (modified) (2 diffs)
• SynTree/Declaration.h (modified) (2 diffs)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/Type.h (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)
• Validate/EliminateTypedef.cpp (modified) (2 diffs)
• Validate/FixQualifiedTypes.cpp (modified) (1 diff)
• Validate/HoistStruct.cpp (modified) (4 diffs)
• Validate/HoistStruct.hpp (modified) (1 diff)
• Validate/LinkReferenceToTypes.cpp (modified) (3 diffs)
• Validate/NoIdSymbolTable.hpp (modified) (2 diffs)
• Validate/ReplaceTypedef.cpp (modified) (4 diffs)

src/AST/Convert.cpp

@@ -321 +321 @@
                         get<Type>().accept1(node->base)
                 );
-                // decl->data_constructors = get<StructDecl>().acceptL( node->data_constructors );
-                // decl->data_union = get<UnionDecl>().accept1( node->data_union );
-                // decl->tag = get<EnumDecl>().accept1( node->tag );
-                // decl->tag_union = get<StructDecl>().accept1( node->tag_union );
                 return aggregatePostamble( decl, node );
         }
@@ -334 +330 @@
                         get<Attribute>().acceptL( node->attributes ),
                         LinkageSpec::Spec( node->linkage.val ),
-                        get<StructDecl>().acceptL( node->data_constructors ),
                         get<UnionDecl>().accept1( node->data_union ),
                         get<EnumDecl>().accept1( node->tag ),
@@ -1344 +1339 @@
         }
 
+        const ast::Type * visit( [[maybe_unused]]const ast::AdtInstType * node ) override final {
+                return nullptr;
+        }
+
         const ast::Type * visit( const ast::UnionInstType * node ) override final {
                 UnionInstType * ty;
@@ -1824 +1823 @@
                 decl->uniqueId = old->uniqueId;
                 decl->storage = { old->storageClasses.val };
-                decl->data_constructors = GET_ACCEPT_V( data_constructors, StructDecl );
                 decl->data_union = GET_ACCEPT_1( data_union, UnionDecl );
                 decl->tag = GET_ACCEPT_1( tag, EnumDecl );
@@ -2876 +2874 @@
                 postvisit( old, ty );
         }
+        
+        virtual void visit( const AdtInstType * old ) override final {
+                ast::AdtInstType * ty;
+                if ( old->baseAdt ) {
+                        ty = new ast::AdtInstType{
+                                GET_ACCEPT_1( baseAdt, AdtDecl ),
+                                cv( old ),
+                                GET_ACCEPT_V( attributes, Attribute )
+                        };
+                } else {
+                        ty = new ast::AdtInstType{
+                                old->name,
+                                cv( old ),
+                                GET_ACCEPT_V( attributes, Attribute )
+                        };
+                }
+                postvisit( old, ty );
+        }
 
         virtual void visit( const UnionInstType * old ) override final {

src/AST/Decl.hpp

@@ -248 +248 @@
 class AggregateDecl : public Decl {
 public:
-        enum Aggregate { Struct, Union, Enum, Exception, Trait, Generator, Coroutine, Monitor, Thread, NoAggregate, Adt };
+        enum Aggregate { Undecided, Struct, Union, Enum, Exception, Trait, Generator, Coroutine, Monitor, Thread, NoAggregate, Adt };
         static const char * aggrString( Aggregate aggr );
 
@@ -346 +346 @@
 class AdtDecl final : public AggregateDecl {
 public:
-        std::vector<ptr<StructDecl>> data_constructors; // Todo: members?
         ptr<UnionDecl> data_union;
         ptr<EnumDecl> tag;

src/AST/Fwd.hpp

@@ -123 +123 @@
 using UnionInstType = SueInstType<UnionDecl>;
 using EnumInstType = SueInstType<EnumDecl>;
+using AdtInstType = SueInstType<AdtDecl>;
 class TraitInstType;
 class TypeInstType;

src/AST/Pass.hpp

@@ -219 +219 @@
         const ast::Type *             visit( const ast::FunctionType         * ) override final;
         const ast::Type *             visit( const ast::StructInstType       * ) override final;
+        const ast::Type *             visit( const ast::AdtInstType          * ) override final; 
         const ast::Type *             visit( const ast::UnionInstType        * ) override final;
         const ast::Type *             visit( const ast::EnumInstType         * ) override final;

src/AST/Pass.impl.hpp

@@ -585 +585 @@
 
 //--------------------------------------------------------------------------
+// AdtDecl
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::AdtDecl * node ) {
+        VISIT_START( node );
+
+        __pass::symtab::addAdtFwd( core, 0, node );
+
+        if ( __visit_children() ) {
+                guard_symtab guard { *this };
+                maybe_accept( node, &AdtDecl::params );
+                maybe_accept( node, &AdtDecl::members );
+                maybe_accept( node, &AdtDecl::attributes );
+
+                maybe_accept( node, &AdtDecl::data_union );
+                maybe_accept( node, &AdtDecl::tag );
+                maybe_accept( node, &AdtDecl::tag_union );
+        }
+
+        __pass::symtab::addAdt( core, 0, node );
+        VISIT_END( Decl, node );
+}
+
+//--------------------------------------------------------------------------
 // UnionDecl
 template< typename core_t >
@@ -620 +643 @@
                         maybe_accept( node, &EnumDecl::members    );
                         maybe_accept( node, &EnumDecl::attributes );
-
-                        // maybe_accept( node, &EnumDecl::data_constructors );
-                        // maybe_accept( node, &EnumDecl::data_union );
-                        // maybe_accept( node, &EnumDecl::tag );
-                        // maybe_accept( node, &EnumDecl::tag_union );
                 } else {
                         maybe_accept( node, &EnumDecl::base );
@@ -630 +648 @@
                         maybe_accept( node, &EnumDecl::members    );
                         maybe_accept( node, &EnumDecl::attributes );
-
-                        // maybe_accept( node, &EnumDecl::data_constructors );
-                        // maybe_accept( node, &EnumDecl::data_union );
-                        // maybe_accept( node, &EnumDecl::tag );
-                        // maybe_accept( node, &EnumDecl::tag_union );
-                }
-        }
-
-        VISIT_END( Decl, node );
-}
-
-template< typename core_t >
-const ast::Decl * ast::Pass< core_t >::visit( const ast::AdtDecl * node ) {
-        VISIT_START( node );
-
-        __pass::symtab::addAdt( core, 0, node );
-
-        if ( __visit_children() ) {
-                guard_symtab guard { *this };
-                maybe_accept( node, &AdtDecl::params );
-                maybe_accept( node, &AdtDecl::members );
-                maybe_accept( node, &AdtDecl::attributes );
-
-                maybe_accept( node, &AdtDecl::data_constructors );
-                maybe_accept( node, &AdtDecl::data_union );
-                maybe_accept( node, &AdtDecl::tag );
-                maybe_accept( node, &AdtDecl::tag_union );
+                }
         }
 
@@ -1967 +1959 @@
 
 //--------------------------------------------------------------------------
+// AdtInstType
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::AdtInstType * node ) {
+        VISIT_START( node );
+
+        __pass::symtab::addAdt( core, 0, node->name );
+
+        if ( __visit_children() ) {
+                guard_symtab guard { *this };
+                maybe_accept( node, &AdtInstType::params );
+        }
+
+        VISIT_END( Type, node );
+}
+
+//--------------------------------------------------------------------------
 // UnionInstType
 template< typename core_t >

src/AST/Pass.proto.hpp

@@ -477 +477 @@
 
         template<typename core_t>
+        static inline auto addAdtFwd( core_t & core, int, const ast::AdtDecl * decl ) -> decltype( core.symtab.addAdt( decl ), void() ) {
+                ast::AdtDecl * fwd = new ast::AdtDecl( decl->location, decl->name );
+                for ( const auto & param : decl->params ) {
+                        fwd->params.push_back( deepCopy( param.get() ) );
+                }
+                core.symtab.addAdt( fwd );
+        }
+
+        template<typename core_t>
+        static inline auto addAdtFwd( core_t &, long, const ast::AdtDecl * ) {}
+
+        template<typename core_t>
         static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) {
                 ast::UnionDecl * fwd = new ast::UnionDecl( decl->location, decl->name );
@@ -489 +501 @@
 
         template<typename core_t>
-        static inline auto addAdtFwd( core_t & core, int, const ast::AdtDecl * decl ) -> decltype( core.symtab.addAdt( decl ), void() ) {
-                ast::AdtDecl * fwd = new ast::AdtDecl( decl->location, decl->name );
-                for ( const auto & param : decl->params ) {
-                        fwd->params.push_back( deepCopy( param.get() ) );
-                }
-                // Experimental
-                for ( const auto & ctor : decl->data_constructors ) {
-                        addStructFwd( core, 0, ctor  );
-                } 
-                core.symtab.addAdt( fwd );
-        }
-
-        template<typename core_t>
-        static inline auto addAdtFwd( core_t &, long, const ast::AdtDecl) {}
-
-        template<typename core_t>
         static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) {
                 if ( ! core.symtab.lookupStruct( str ) ) {
@@ -513 +509 @@
         template<typename core_t>
         static inline void addStruct( core_t &, long, const std::string & ) {}
+
+                template<typename core_t>
+        static inline auto addAdt( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addAdt( str ), void() ) {
+                if ( ! core.symtab.lookupAdt( str ) ) {
+                        core.symtab.addAdt( str );
+                }
+        }
+
+        template<typename core_t>
+        static inline void addAdt( core_t &, long, const std::string & ) {}
 
         template<typename core_t>

src/AST/Print.cpp

@@ -1501 +1501 @@
         }
 
+        virtual const ast::Type * visit( const ast::AdtInstType * node ) override final {
+                preprint( node );
+                os << "instance of Adt " << node->name;
+                print( node->params );
+                return node;
+        }
+
         virtual const ast::Type * visit( const ast::UnionInstType * node ) override final {
                 preprint( node );

src/AST/SymbolTable.cpp

@@ -218 +218 @@
 }
 
+const AdtDecl * SymbolTable::lookupAdt( const std::string &id ) const {
+        ++*stats().lookup_calls;
+        if ( ! adtTable ) return nullptr;
+        auto it = adtTable->find( id );
+        return it == adtTable->end() ? nullptr : it->second.decl;
+}
+
 const EnumDecl * SymbolTable::lookupEnum( const std::string &id ) const {
         ++*stats().lookup_calls;
@@ -339 +346 @@
 }
 
-void SymbolTable::addEnum( const EnumDecl *decl ) {
-        ++*stats().add_calls;
-        const std::string &id = decl->name;
-
-        if ( ! enumTable ) {
-                enumTable = EnumTable::new_ptr();
-        } else {
-                ++*stats().map_lookups;
-                auto existing = enumTable->find( id );
-                if ( existing != enumTable->end()
-                        && existing->second.scope == scope
-                        && addedDeclConflicts( existing->second.decl, decl ) ) return;
-        }
-
-        lazyInitScope();
-        ++*stats().map_mutations;
-        enumTable = enumTable->set( id, scoped<EnumDecl>{ decl, scope } );
+void SymbolTable::addAdt( const std::string &id ) {
+        addAdt( new AdtDecl( CodeLocation(), id ) );
 }
 
@@ -377 +369 @@
         adtTable = adtTable->set( id, scoped<AdtDecl>{ decl, scope });
 }
+
+void SymbolTable::addEnum( const EnumDecl *decl ) {
+        ++*stats().add_calls;
+        const std::string &id = decl->name;
+
+        if ( ! enumTable ) {
+                enumTable = EnumTable::new_ptr();
+        } else {
+                ++*stats().map_lookups;
+                auto existing = enumTable->find( id );
+                if ( existing != enumTable->end()
+                        && existing->second.scope == scope
+                        && addedDeclConflicts( existing->second.decl, decl ) ) return;
+        }
+
+        lazyInitScope();
+        ++*stats().map_mutations;
+        enumTable = enumTable->set( id, scoped<EnumDecl>{ decl, scope } );
+}
+
 
 void SymbolTable::addUnion( const std::string &id ) {

src/AST/SymbolTable.hpp

@@ -111 +111 @@
         /// Gets the top-most struct declaration with the given ID
         const StructDecl * lookupStruct( const std::string &id ) const;
+
+        const AdtDecl * lookupAdt( const std::string &id ) const;
         /// Gets the top-most enum declaration with the given ID
         const EnumDecl * lookupEnum( const std::string &id ) const;
@@ -141 +143 @@
         void addEnum( const EnumDecl * decl );
         /// Adds an adt declaration to the symbol table
+        void addAdt( const std::string & id );
         void addAdt( const AdtDecl * decl );
         /// Adds a union declaration to the symbol table by name

src/AST/Type.cpp

@@ -138 +138 @@
 template class SueInstType<UnionDecl>;
 template class SueInstType<EnumDecl>;
+template class SueInstType<AdtDecl>;
 
 // --- TraitInstType

src/AST/Visitor.hpp

@@ -111 +111 @@
     virtual const ast::Type *             visit( const ast::TraitInstType        * ) = 0;
     virtual const ast::Type *             visit( const ast::TypeInstType         * ) = 0;
+    virtual const ast::Type *             visit( const ast::AdtInstType          * ) = 0;
     virtual const ast::Type *             visit( const ast::TupleType            * ) = 0;
     virtual const ast::Type *             visit( const ast::TypeofType           * ) = 0;

src/CodeGen/CodeGenerator.cc

@@ -296 +296 @@
 
         void CodeGenerator::handleData( EnumDecl * ) {
-                // output << " /** data type */" << endl;
-                // for ( StructDecl * decl : dataDecl->data_constructors ) {
-                //      postvisit(decl);
-                //      output << ";" << endl;
-                // }
-                // postvisit( dataDecl->data_union );
-                // output << ";" << endl;
-                // postvisit( dataDecl->tag );
-                // output << ";" << endl;
-                // postvisit( dataDecl->tag_union );
-                // output << ";" << endl;
                 assert(false);
         }
 
         void CodeGenerator::postvisit( EnumDecl * enumDecl ) {
-                // if ( enumDecl->data_constructors.size() > 0 ) return handleData( enumDecl );
                 extension( enumDecl );
                 std::list< Declaration* > &memb = enumDecl->get_members();
@@ -350 +338 @@
         }
 
-        void CodeGenerator::postvisit( AdtDecl * ) {
-                // TODO
+        // Temporary fix, But visitor should be able to handle this
+        void CodeGenerator::postvisit( AdtDecl * adtDecl ) {
+                output << endl << "/* AdtDecl Code Section */" << endl;
+                postvisit( adtDecl->tag );
+                output << ";" << endl;
+                postvisit( adtDecl->data_union );
+                output << ";" << endl;
+                postvisit( adtDecl->tag_union );
         }
 

src/Common/CodeLocationTools.cpp

@@ -185 +185 @@
     macro(FunctionType, Type) \
     macro(StructInstType, Type) \
+    macro(AdtInstType, Type) \
     macro(UnionInstType, Type) \
     macro(EnumInstType, Type) \

src/Common/PassVisitor.h

@@ -226 +226 @@
         virtual void visit( StructInstType * aggregateUseType ) override final;
         virtual void visit( const StructInstType * aggregateUseType ) override final;
+        virtual void visit( AdtInstType * aggregateUseType ) override final;
+        virtual void visit( const AdtInstType * aggregateUseType ) override final;
         virtual void visit( UnionInstType * aggregateUseType ) override final;
         virtual void visit( const UnionInstType * aggregateUseType ) override final;
@@ -351 +353 @@
         virtual Type * mutate( FunctionType * functionType ) override final;
         virtual Type * mutate( StructInstType * aggregateUseType ) override final;
+        virtual Type * mutate( AdtInstType * aggregateUseType ) override final;
         virtual Type * mutate( UnionInstType * aggregateUseType ) override final;
         virtual Type * mutate( EnumInstType * aggregateUseType ) override final;
@@ -442 +445 @@
         void indexerAddStructFwd( const StructDecl          * node  ) { indexer_impl_addStructFwd( pass, 0, node ); }
         void indexerAddEnum     ( const EnumDecl            * node  ) { indexer_impl_addEnum     ( pass, 0, node ); }
+        void indexerAddAdt              ( const std::string                     & id    ) { indexer_impl_addAdt      ( pass, 0, id   ); }
         void indexerAddAdt              ( const AdtDecl                         * node  ) { indexer_impl_addAdt          ( pass, 0, node ); }
         void indexerAddAdtFwd   ( const AdtDecl                         * node  ) { indexer_impl_addAdtFwd   ( pass, 0, node  ); }

src/Common/PassVisitor.impl.h

@@ -688 +688 @@
 
 //--------------------------------------------------------------------------
+// AdtDecl
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( AdtDecl * node ) {
+        VISIT_START( node );
+
+        indexerAddAdtFwd( node );
+
+        maybeAccept_impl( node->data_union, *this );
+        maybeAccept_impl( node->tag, *this );
+
+        maybeAccept_impl( node->parameters, *this );
+        maybeAccept_impl( node->members   , *this );
+        maybeAccept_impl( node->attributes, *this );
+
+        indexerAddAdt( node );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( const AdtDecl * node ) {
+        VISIT_START( node );
+
+        indexerAddAdtFwd( node );
+
+        maybeAccept_impl( node->data_union, *this );
+        maybeAccept_impl( node->tag, *this );
+
+        maybeAccept_impl( node->parameters, *this );
+        maybeAccept_impl( node->members   , *this );
+        maybeAccept_impl( node->attributes, *this );
+
+        indexerAddAdt( node );
+
+        VISIT_END( node );
+}  
+
+template< typename pass_type >
+Declaration * PassVisitor< pass_type >::mutate( AdtDecl * node ) {
+        MUTATE_START( node );
+        
+        indexerAddAdtFwd( node );
+
+        maybeMutate_impl( node->data_union, *this );
+        maybeMutate_impl( node->tag, *this );
+
+        maybeMutate_impl( node->parameters, *this );
+        maybeMutate_impl( node->members   , *this );
+        maybeMutate_impl( node->attributes, *this );
+
+        indexerAddAdt( node );
+
+        MUTATE_END( Declaration, node );
+}
+
+
+//--------------------------------------------------------------------------
 // UnionDecl
 template< typename pass_type >
@@ -789 +846 @@
 }
 
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( AdtDecl * node ) {
-        VISIT_START( node );
-
-        indexerAddAdtFwd( node );
-
-        // unlike structs, traits, and unions, enums inject their members into the global scope
-        maybeAccept_impl( node->data_constructors, *this );
-        maybeAccept_impl( node->data_union, *this );
-        maybeAccept_impl( node->tag, *this );
-
-        maybeAccept_impl( node->parameters, *this );
-        maybeAccept_impl( node->members   , *this );
-        maybeAccept_impl( node->attributes, *this );
-
-        VISIT_END( node );
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( const AdtDecl * node ) {
-        VISIT_START( node );
-
-        indexerAddAdtFwd( node );
-
-        maybeAccept_impl( node->data_constructors, *this );
-        maybeAccept_impl( node->data_union, *this );
-        maybeAccept_impl( node->tag, *this );
-
-        maybeAccept_impl( node->parameters, *this );
-        maybeAccept_impl( node->members   , *this );
-        maybeAccept_impl( node->attributes, *this );
-
-
-        VISIT_END( node );
-}  
-
-template< typename pass_type >
-Declaration * PassVisitor< pass_type >::mutate( AdtDecl * node ) {
-        MUTATE_START( node );
-        
-        indexerAddAdtFwd( node );
-
-        maybeMutate_impl( node->data_constructors, *this );
-        maybeMutate_impl( node->data_union, *this );
-        maybeMutate_impl( node->tag, *this );
-
-        maybeMutate_impl( node->parameters, *this );
-        maybeMutate_impl( node->members   , *this );
-        maybeMutate_impl( node->attributes, *this );
-
-        MUTATE_END( Declaration, node );
-}
 
 //--------------------------------------------------------------------------
@@ -3540 +3545 @@
 
         indexerAddStruct( node->name );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutate_impl( node->forall    , *this );
+                maybeMutate_impl( node->parameters, *this );
+        }
+
+        MUTATE_END( Type, node );
+}
+
+//--------------------------------------------------------------------------
+// AdtInstType
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( AdtInstType * node ) {
+        VISIT_START( node );
+
+        indexerAddAdt( node->name );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept_impl( node->forall    , *this );
+                maybeAccept_impl( node->parameters, *this );
+        }
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( const AdtInstType * node ) {
+        VISIT_START( node );
+
+        indexerAddAdt( node->name );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept_impl( node->forall    , *this );
+                maybeAccept_impl( node->parameters, *this );
+        }
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( AdtInstType * node ) {
+        MUTATE_START( node );
+
+        indexerAddAdt( node->name );
 
         {

src/Common/PassVisitor.proto.h

@@ -256 +256 @@
         cloneAll( decl->parameters, fwd->parameters );
 
-        // Experimental
-        for ( const StructDecl * ctor : fwd->data_constructors ) {
-                indexer_impl_addStructFwd( pass, 0, ctor );
-        }
-
         pass.indexer.addAdt( fwd );
 } 
@@ -288 +283 @@
 
 template<typename pass_type>
+static inline auto indexer_impl_addAdt( pass_type & pass, int, const std::string & str ) -> decltype( pass.indexer.addAdt( str ), void() ) {
+        assert( false );
+        if ( ! pass.indexer.lookupAdt( str )) {
+                pass.indexer.addAdt( str );
+        }
+}
+
+template<typename pass_type>
+static inline auto indexer_impl_addAdt( pass_type &, long, const std::string & ) {
+        assert( false );
+}
+
+template<typename pass_type>
 static inline auto indexer_impl_addUnion( pass_type & pass, int, const std::string & str ) -> decltype( pass.indexer.addUnion( str ), void() ) {
         if ( ! pass.indexer.lookupUnion( str ) ) {

src/GenPoly/Box.cc

@@ -185 +185 @@
                         void premutate( StructDecl * );
                         void premutate( UnionDecl * );
+                        void premutate( AdtDecl * );
 
                         void beginScope();
@@ -1513 +1514 @@
                 }
 
+                void PolyGenericCalculator::premutate( AdtDecl * adtDecl ) {
+                        mutateMembers( adtDecl );
+                }
+
                 void PolyGenericCalculator::premutate( DeclStmt *declStmt ) {
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {

src/Parser/DeclarationNode.cc

@@ -1104 +1104 @@
         std::back_insert_iterator<std::vector<ast::ptr<ast::StructDecl>>> out( outputList );
         for ( const DeclarationNode * cur = firstNode; cur; cur = strict_next( cur ) ) {
-                // td->kind == TypeData::Symbolic
+
                 assert( cur->type->kind == TypeData::Symbolic );
                 const std::string * name = cur->name;
@@ -1125 +1125 @@
                         member->name = "field_" + std::to_string(i);
                 }
+
                 *out++ = ctor;          
         }
@@ -1130 +1131 @@
 }
 
-ast::UnionDecl * buildDataUnion( const CodeLocation & loc, const std::vector<ast::ptr<ast::StructDecl>> & typeList ) {
+void buildDataConstructorsAsMember( DeclarationNode * firstNode, ast::AdtDecl * adtDecl ) {
+        std::back_insert_iterator<std::vector<ast::ptr<ast::Decl>>> out( adtDecl->members );
+        for ( const DeclarationNode * cur = firstNode; cur; cur = strict_next( cur ) ) {
+
+                assert( cur->type->kind == TypeData::Symbolic );
+                const std::string * name = cur->name;
+                auto ctor = new ast::StructDecl( cur->location,
+                        std::string(*name),
+                        ast::AggregateDecl::Aggregate::Struct
+                );
+                ctor->set_body(true);
+                TypeData * td = cur->type;
+                TypeData::Symbolic_t st = td->symbolic;
+                DeclarationNode * params = st.params;
+                
+                if ( params ) {
+                        buildList( params, ctor->members );
+                }
+
+                for ( std::size_t i = 0; i < ctor->members.size(); ++i ) {
+                        assert(ctor->members[i]->name == "");
+                        ast::Decl * member = ctor->members[i].get_and_mutate();
+                        member->name = "field_" + std::to_string(i);
+                }
+
+                *out++ = ctor;          
+        }
+}
+
+ast::UnionDecl * buildDataUnion( const CodeLocation & loc, const std::vector<ast::ptr<ast::Decl>> & typeList ) {
         ast::UnionDecl * out = new ast::UnionDecl( loc, "temp_data_union" );
         // size_t index = 0;
         if ( typeList.size() > 0 ) out->set_body( true );
         size_t i = 0;
-        for (const ast::ptr<ast::StructDecl> structDecl : typeList ) {
-                ast::StructInstType * inst = new ast::StructInstType(structDecl);
+        for (const ast::ptr<ast::Decl> structDecl : typeList ) {
+                ast::StructInstType * inst = new ast::StructInstType( structDecl.as< ast::StructDecl >() );
                 ast::ObjectDecl * instObj = new ast::ObjectDecl(
                         structDecl->location,
@@ -1149 +1179 @@
 }
 
-ast::EnumDecl * buildTag( const CodeLocation & loc, std::vector<ast::ptr<ast::StructDecl>> & typeList ) {
+ast::EnumDecl * buildTag( const CodeLocation & loc, std::vector<ast::ptr<ast::Decl>> & typeList ) {
         ast::EnumDecl * out = new ast::EnumDecl( loc, "temp_data_tag" );
         if ( typeList.size() > 0 ) out->set_body( true );
-        for ( const ast::ptr<ast::StructDecl> structDecl : typeList ) {
+        for ( const ast::ptr<ast::Decl> structDecl : typeList ) {
                 ast::EnumInstType * inst = new ast::EnumInstType( out );
                 assert( inst->base != nullptr );
@@ -1167 +1197 @@
 ast::StructDecl * buildTaggedUnions( const TypeData * data, const ast::EnumDecl * tags, const ast::UnionDecl * data_union ) {
         assert( tags->members.size() == data_union->members.size() );
-        ast::StructDecl * out = new ast::StructDecl( data->location, *(data->adt.name) );
+        ast::StructDecl * out = new ast::StructDecl( data->location, (*(data->adt.name)) + "_tag_union" );
         out->kind = ast::AggregateDecl::Adt;
 

src/Parser/DeclarationNode.h

@@ -218 +218 @@
 
 std::vector<ast::ptr<ast::StructDecl>> buildDataConstructors( DeclarationNode * firstNode );
-ast::UnionDecl * buildDataUnion( const CodeLocation & loc, const std::vector<ast::ptr<ast::StructDecl>> & typeList );
-ast::EnumDecl * buildTag( const CodeLocation & loc, std::vector<ast::ptr<ast::StructDecl>> & typeList );
+void buildDataConstructorsAsMember( DeclarationNode * firstNode, ast::AdtDecl * adtDecl );
+ast::UnionDecl * buildDataUnion( const CodeLocation & loc, const std::vector<ast::ptr<ast::Decl>> & typeList );
+ast::EnumDecl * buildTag( const CodeLocation & loc, std::vector<ast::ptr<ast::Decl>> & typeList );
 ast::StructDecl * buildTaggedUnions( const TypeData * data, const ast::EnumDecl * tag, const ast::UnionDecl * data_union );
 

src/Parser/TypeData.cc

@@ -81 +81 @@
         case Symbolic:
         case SymbolicInst:
+                aggregate.kind =  ast::AggregateDecl::Aggregate::Undecided;
+                
                 symbolic.name = nullptr;
                 symbolic.params = nullptr;
@@ -225 +227 @@
                 newtype->enumeration.body = enumeration.body;
                 newtype->enumeration.anon = enumeration.anon;
-                newtype->enumeration.data_constructors = maybeClone( enumeration.data_constructors );
                 break;
         case Adt:
-                newtype->adt.data_constructors = maybeClone( enumeration.data_constructors );
+                newtype->adt.data_constructors = maybeClone( adt.data_constructors );
                 newtype->adt.name = new string ( *adt.name );
                 break;
@@ -1276 +1277 @@
         );
         buildList( td->enumeration.constants, ret->members );
-        if ( td->enumeration.data_constructors != nullptr ) {
-                assert( false );
-                // ret->data_constructors = buildDataConstructors( td->enumeration.data_constructors );
-                // ret->data_union = buildDataUnion( td->location, ret->data_constructors );
-                // ret->tag = buildTag( td->location, ret->data_constructors );
-                // ret->tag_union = buildTaggedUnions( td, ret->tag.get(), ret->data_union.get() );
-        }
-
-        // if ( ret->data_constructors.size() > 0 ) ret->isData = true;
+
         auto members = ret->members.begin();
         ret->hide = td->enumeration.hiding == EnumHiding::Hide ? ast::EnumDecl::EnumHiding::Hide : ast::EnumDecl::EnumHiding::Visible;
@@ -1317 +1310 @@
         assert( td->kind == TypeData::Adt );
         ast::AdtDecl * ret = new ast::AdtDecl( td->location, *(td->adt.name) );
-        ret->data_constructors = buildDataConstructors( td->adt.data_constructors );
-        ret->data_union = buildDataUnion( td->location, ret->data_constructors );
-        ret->tag = buildTag( td->location, ret->data_constructors );
+
+        buildDataConstructorsAsMember( td->adt.data_constructors, ret );
+
+        ret->data_union = buildDataUnion( td->location, ret->members );
+        ret->tag = buildTag( td->location, ret->members );
         ret->tag_union = buildTaggedUnions( td, ret->tag.get(), ret->data_union.get() );
         return ret;

src/Parser/TypeData.h

@@ -25 +25 @@
 struct TypeData {
         enum Kind { Basic, Pointer, Reference, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
-                                SymbolicInst, Tuple, Basetypeof, Typeof, Vtable, Builtin, GlobalScope, Qualified, Adt, Ctor, Unknown };
+                                SymbolicInst, Tuple, Basetypeof, Typeof, Vtable, Builtin, GlobalScope, Qualified, Adt, Unknown };
 
         struct Aggregate_t {
@@ -59 +59 @@
                 EnumHiding hiding;
                 bool isData = false;
-
-                DeclarationNode * data_constructors = nullptr;
         };
 

src/SymTab/Validate.cc

@@ -210 +210 @@
                 void previsit( StructDecl * aggregateDecl );
                 void previsit( UnionDecl * aggregateDecl );
+                void previsit( AdtDecl * AggregateDecl );
                 void previsit( CompoundStmt * compoundStmt );
         };
@@ -569 +570 @@
 
         void EliminateTypedef::previsit( UnionDecl * aggregateDecl ) {
+                handleAggregate( aggregateDecl );
+        }
+
+        void EliminateTypedef::previsit( AdtDecl * aggregateDecl ) {
                 handleAggregate( aggregateDecl );
         }

src/SynTree/Declaration.h

@@ -365 +365 @@
         typedef AggregateDecl Parent;
   public:
-        std::list<StructDecl*> data_constructors;
         UnionDecl * data_union;
         EnumDecl * tag;
@@ -373 +372 @@
          const std::list< Attribute * > & attributes = std::list< class Attribute * >(),
          LinkageSpec::Spec linkage = LinkageSpec::Cforall, 
-         const std::list< StructDecl* > data_constructors = std::list< StructDecl * >(),
          UnionDecl * data_union = nullptr, EnumDecl * tag = nullptr, StructDecl * tag_union = nullptr )
-         : Parent( name, attributes, linkage ), data_constructors(data_constructors), 
+         : Parent( name, attributes, linkage ), 
          data_union( data_union ), tag( tag ), tag_union( tag_union ) {}
 

src/SynTree/Mutator.h

@@ -110 +110 @@
         virtual Type * mutate( FunctionType * functionType ) = 0;
         virtual Type * mutate( StructInstType * aggregateUseType ) = 0;
+        virtual Type * mutate( AdtInstType * aggregateUseType ) = 0;
         virtual Type * mutate( UnionInstType * aggregateUseType ) = 0;
         virtual Type * mutate( EnumInstType * aggregateUseType ) = 0;

src/SynTree/SynTree.h

@@ -119 +119 @@
 class UnionInstType;
 class EnumInstType;
+class AdtInstType;
 class TraitInstType;
 class TypeInstType;

src/SynTree/Type.h

@@ -476 +476 @@
 };
 
+class AdtInstType : public ReferenceToType {
+        typedef ReferenceToType  Parent;
+  public:
+        AdtDecl * baseAdt;
+
+        AdtInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseAdt( 0 ) {}
+        AdtInstType( const Type::Qualifiers & tq, AdtDecl * baseAdt, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        AdtInstType( const AdtInstType & other ) : Parent( other ), baseAdt( other.baseAdt ) {}
+
+        AdtDecl * get_baseAdt() const { return baseAdt; }
+        void set_baseAdt( AdtDecl * newValue ) { baseAdt = newValue; }
+        
+        std::list<TypeDecl*> * get_baseParameters();
+        const std::list<TypeDecl*> * get_baseParameters() const;
+
+        virtual bool isComplete() const override;
+
+        virtual AggregateDecl * getAggr() const override;
+        
+        virtual TypeSubstitution genericSubstitution() const override;
+
+        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
+
+        virtual AdtInstType * clone() const override { return new AdtInstType( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+
+        virtual void print( std::ostream & os, Indenter indenter = {} ) const override;
+  private:
+        virtual std::string typeString() const override;
+};
+
 class UnionInstType : public ReferenceToType {
         typedef ReferenceToType Parent;

src/SynTree/Visitor.h

@@ -196 +196 @@
         virtual void visit( UnionInstType * node ) { visit( const_cast<const UnionInstType *>(node) ); }
         virtual void visit( const UnionInstType * aggregateUseType ) = 0;
+        virtual void visit( AdtInstType * node ) { visit( const_cast<const AdtInstType *>(node) ); }
+        virtual void visit( const AdtInstType * node ) = 0;
         virtual void visit( EnumInstType * node ) { visit( const_cast<const EnumInstType *>(node) ); }
         virtual void visit( const EnumInstType * aggregateUseType ) = 0;

src/Validate/EliminateTypedef.cpp

@@ -31 +31 @@
         ast::StructDecl const * previsit( ast::StructDecl const * decl );
         ast::UnionDecl const * previsit( ast::UnionDecl const * decl );
+        ast::AdtDecl const * previsit( ast::AdtDecl const * decl );
         // Remove typedefs from statement lists.
         ast::CompoundStmt const * previsit( ast::CompoundStmt const * stmt );
@@ -65 +66 @@
 }
 
+ast::AdtDecl const * EliminateTypedefCore::previsit( ast::AdtDecl const * decl ) {
+        return field_erase_if( decl, &ast::AdtDecl::members, isTypedef );
+}
+
 ast::CompoundStmt const * EliminateTypedefCore::previsit( ast::CompoundStmt const * stmt ) {
         return field_erase_if( stmt, &ast::CompoundStmt::kids, isTypedefStmt );

src/Validate/FixQualifiedTypes.cpp

@@ -59 +59 @@
                                 instp = inst;
                         } else if ( auto inst = parent.as<ast::UnionInstType>() ) {
+                                aggr = inst->base;
+                                instp = inst;
+                        } else if ( auto inst = parent.as<ast::AdtInstType>() ) {
                                 aggr = inst->base;
                                 instp = inst;

src/Validate/HoistStruct.cpp

@@ -28 +28 @@
         return dynamic_cast< ast::StructDecl const * >( decl )
                 || dynamic_cast< ast::UnionDecl const * >( decl )
-                || dynamic_cast< ast::StaticAssertDecl const * >( decl );
+                || dynamic_cast< ast::StaticAssertDecl const * >( decl )
+                || dynamic_cast< ast::AdtDecl const * >( decl );
 }
 
@@ -45 +46 @@
         ast::UnionInstType const * previsit( ast::UnionInstType const * type );
         ast::EnumInstType const * previsit( ast::EnumInstType const * type );
+        ast::AdtDecl const * previsit( ast::AdtDecl const * decl );
+        ast::AdtDecl const * postvisit( ast::AdtDecl const * decl );
 
 private:
@@ -100 +103 @@
 }
 
+ast::AdtDecl const * HoistStructCore::previsit( ast::AdtDecl const * decl ) {
+        return preAggregate( decl );
+}
+
+ast::AdtDecl const * HoistStructCore::postvisit( ast::AdtDecl const * decl ) {
+        return postAggregate( decl );
+}
+
 ast::StructDecl const * HoistStructCore::postvisit( ast::StructDecl const * decl ) {
         return postAggregate( decl );
@@ -138 +149 @@
 }
 
-void hoistAdt( [[maybe_unused]] ast::TranslationUnit & trnaslationUnit ) {
-        
-}
-
 } // namespace Validate
 

src/Validate/HoistStruct.hpp

@@ -24 +24 @@
 /// Flattens nested type declarations. (Run right after Fix Qualified Types.)
 void hoistStruct( ast::TranslationUnit & translationUnit );
-void hoistAdt( ast::TranslationUnit & trnaslationUnit );
 
 }

src/Validate/LinkReferenceToTypes.cpp

@@ -20 +20 @@
 #include "Validate/ForallPointerDecay.hpp"
 #include "Validate/NoIdSymbolTable.hpp"
+#include <assert.h>
 
 namespace Validate {
@@ -35 +36 @@
         ast::UnionInstType const * postvisit( ast::UnionInstType const * type );
         ast::TraitInstType const * postvisit( ast::TraitInstType const * type );
+        ast::AdtInstType const * postvisit( ast::AdtInstType const * type );
         void previsit( ast::QualifiedType const * type );
         void postvisit( ast::QualifiedType const * type );
@@ -107 +109 @@
                 auto mut = ast::mutate( type );
                 forwardStructs[ mut->name ].push_back( mut );
+                type = mut;
+        }
+        return type;
+}
+
+ast::AdtInstType const * LinkTypesCore::postvisit( ast::AdtInstType const * type ) {
+        ast::AdtDecl const * decl = symtab.lookupAdt( type->name );
+        assert( decl != nullptr );
+        if ( decl ) {
+                auto mut = ast::mutate( type );
+                mut->base = const_cast<ast::AdtDecl *>( decl );
                 type = mut;
         }

src/Validate/NoIdSymbolTable.hpp

@@ -41 +41 @@
         FORWARD_1( lookupUnion , const std::string & )
         FORWARD_1( lookupTrait , const std::string & )
+        FORWARD_1( lookupAdt   , const std::string & )
         FORWARD_1( addType  , const ast::NamedTypeDecl * )
         FORWARD_1( addStruct, const ast::StructDecl *    )
@@ -49 +50 @@
         FORWARD_1( addStruct, const std::string &        )
         FORWARD_1( addUnion , const std::string &        )
+        FORWARD_1( addAdt   , const std::string &                )
         FORWARD_2( addWith  , const std::vector< ast::ptr<ast::Expr> > &, const ast::Decl * )
 

src/Validate/ReplaceTypedef.cpp

@@ -60 +60 @@
         ast::StructDecl const * previsit( ast::StructDecl const * );
         ast::UnionDecl const * previsit( ast::UnionDecl const * );
+        ast::AdtDecl const * previsit( ast::AdtDecl const * );
         void previsit( ast::EnumDecl const * );
         void previsit( ast::TraitDecl const * );
@@ -90 +91 @@
 }
 
+// Here, 5/30
 ast::Type const * ReplaceTypedefCore::postvisit(
                 ast::TypeInstType const * type ) {
         // Instances of typedef types will come here. If it is an instance
         // of a typedef type, link the instance to its actual type.
-        TypedefMap::const_iterator def = typedefNames.find( type->name );
+        TypedefMap::const_iterator def = typedefNames.find( type->name ); // because of this
         if ( def != typedefNames.end() ) {
                 ast::Type * ret = ast::deepCopy( def->second.first->base );
@@ -260 +262 @@
 }
 
+ast::AdtDecl const * ReplaceTypedefCore::previsit( ast::AdtDecl const * decl ) {
+        visit_children = false;
+        addImplicitTypedef( decl );
+        return handleAggregate( decl );
+}
+
 ast::UnionDecl const * ReplaceTypedefCore::previsit( ast::UnionDecl const * decl ) {
         visit_children = false;
@@ -287 +295 @@
         } else if ( auto enumDecl = dynamic_cast<const ast::EnumDecl *>( aggrDecl ) ) {
                 type = new ast::EnumInstType( enumDecl->name );
+        } else if ( auto adtDecl = dynamic_cast<const ast::AdtDecl *>( aggrDecl )) {
+                type = new ast::AdtInstType( adtDecl->name );
         }
         assert( type );