Changeset c1398e4

Timestamp:

Jun 24, 2019, 1:49:47 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

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:

08c0780

Parents:

c1ea11b

Message:

Port necessary parts of validate to new AST

Location:

src

Files:

• AST/TypeSubstitution.hpp (modified) (1 diff)
• SymTab/Validate.cc (modified) (5 diffs)

src/AST/TypeSubstitution.hpp

@@ -200 +200 @@
 }
 
-/// Instantiate each member of the context given the actual parameters specified, and store the
-/// instantiations for use by the indexer
-template< typename FormalIterator, typename ActualIterator, typename MemberIterator, typename OutputIterator >
-void applySubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actual, MemberIterator memberBegin, MemberIterator memberEnd, OutputIterator out ) {
-        TypeSubstitution sub = TypeSubstitution( formalBegin, formalEnd, actual );
-        for ( auto i = memberBegin; i != memberEnd; ++i ) {
-                sub.apply( *i );
-                *out++ = *i;
-        } // for
-}
-
 } // namespace ast
 

src/SymTab/Validate.cc

@@ -53 +53 @@
 #include "AST/SymbolTable.hpp"
 #include "AST/Type.hpp"
+#include "AST/TypeSubstitution.hpp"
 #include "CodeGen/CodeGenerator.h"     // for genName
 #include "CodeGen/OperatorTable.h"     // for isCtorDtor, isCtorDtorAssign
@@ -1430 +1431 @@
         };
 
+        /// expand assertions from a trait instance, performing appropriate type variable substitutions
+        void expandAssertions( 
+                const ast::TraitInstType * inst, std::vector< ast::ptr< ast::DeclWithType > > & out 
+        ) {
+                assertf( inst->base, "Trait instance not linked to base trait: %s", toCString( inst ) );
+
+                // build list of trait members, substituting trait decl parameters for instance parameters
+                ast::TypeSubstitution sub{ 
+                        inst->base->params.begin(), inst->base->params.end(), inst->params.begin() };
+                // deliberately take ast::ptr by-value to ensure this does not mutate inst->base
+                for ( ast::ptr< ast::Decl > decl : inst->base->members ) {
+                        auto member = decl.strict_as< ast::DeclWithType >();
+                        sub.apply( member );
+                        out.emplace_back( member );
+                }
+        }
+
         /// Associates forward declarations of aggregates with their definitions
         class LinkReferenceToTypes_new final 
@@ -1690 +1708 @@
                 const ast::Decl * postvisit( const ast::TraitDecl * traitDecl ) {
                         // set the "sized" status for the special "sized" trait
-                        if ( traitDecl->name != "sized" ) return traitDecl;
-
-                        assertf( traitDecl->params.size() == 1, "Built-in trait 'sized' has incorrect number "
-                                "of parameters: %zd", traitDecl->params.size() );
-
-                        return ast::mutate_field_index( 
-                                traitDecl, &ast::TraitDecl::params, 0, 
-                                ast::mutate_field( 
-                                        traitDecl->params.front().get(), &ast::TypeDecl::sized, true ) );
+                        if ( traitDecl->name == "sized" ) {
+                                assertf( traitDecl->params.size() == 1, "Built-in trait 'sized' has incorrect "
+                                        "number of parameters: %zd", traitDecl->params.size() );
+
+                                traitDecl = ast::mutate_field_index( 
+                                        traitDecl, &ast::TraitDecl::params, 0, 
+                                        ast::mutate_field( 
+                                                traitDecl->params.front().get(), &ast::TypeDecl::sized, true ) );
+                        }
+
+                        // move assertions from type parameters into the body of the trait
+                        std::vector< ast::ptr< ast::DeclWithType > > added;
+                        for ( const ast::TypeDecl * td : traitDecl->params ) {
+                                for ( const ast::DeclWithType * assn : td->assertions ) {
+                                        auto inst = dynamic_cast< const ast::TraitInstType * >( assn->get_type() );
+                                        if ( inst ) {
+                                                expandAssertions( inst, added );
+                                        } else {
+                                                added.emplace_back( assn );
+                                        }
+                                }
+                        }
+                        if ( ! added.empty() ) {
+                                auto mut = mutate( traitDecl );
+                                for ( const ast::DeclWithType * decl : added ) {
+                                        mut->members.emplace_back( decl );
+                                }
+                                traitDecl = mut;
+                        }
+                        
+                        return traitDecl;
                 }
         };
@@ -1704 +1744 @@
         /// Replaces array and function types in forall lists by appropriate pointer type and assigns 
         /// each object and function declaration a unique ID
-        struct ForallPointerDecay_new {
-                #warning incomplete
+        class ForallPointerDecay_new {
+                const CodeLocation & location;
+        public:
+                ForallPointerDecay_new( const CodeLocation & loc ) : location( loc ) {}
+
+                const ast::ObjectDecl * previsit( const ast::ObjectDecl * obj ) {
+                        // ensure that operator names only apply to functions or function pointers
+                        if ( 
+                                CodeGen::isOperator( obj->name ) 
+                                && ! dynamic_cast< const ast::FunctionType * >( obj->type->stripDeclarator() )
+                        ) {
+                                SemanticError( obj->location, toCString( "operator ", obj->name.c_str(), " is not "
+                                        "a function or function pointer." )  );
+                        }
+
+                        // ensure object has unique ID
+                        if ( obj->uniqueId ) return obj;
+                        auto mut = mutate( obj );
+                        mut->fixUniqueId();
+                        return mut;
+                }
+
+                const ast::FunctionDecl * previsit( const ast::FunctionDecl * func ) {
+                        // ensure function has unique ID
+                        if ( func->uniqueId ) return func;
+                        auto mut = mutate( func );
+                        mut->fixUniqueId();
+                        return mut;
+                }
+
+                /// Fix up assertions -- flattens assertion lists, removing all trait instances
+                template< typename node_t, typename parent_t >
+                static const node_t * forallFixer( 
+                        const CodeLocation & loc, const node_t * node, 
+                        ast::ParameterizedType::ForallList parent_t::* forallField
+                ) {
+                        for ( unsigned i = 0; i < (node->*forallField).size(); ++i ) {
+                                const ast::TypeDecl * type = (node->*forallField)[i];
+                                if ( type->assertions.empty() ) continue;
+
+                                std::vector< ast::ptr< ast::DeclWithType > > asserts;
+                                asserts.reserve( type->assertions.size() );
+
+                                // expand trait instances into their members
+                                for ( const ast::DeclWithType * assn : type->assertions ) {
+                                        auto traitInst = 
+                                                dynamic_cast< const ast::TraitInstType * >( assn->get_type() ); 
+                                        if ( traitInst ) {
+                                                // expand trait instance to all its members
+                                                expandAssertions( traitInst, asserts );
+                                        } else {
+                                                // pass other assertions through
+                                                asserts.emplace_back( assn );
+                                        }
+                                }
+
+                                // apply FixFunction to every assertion to check for invalid void type
+                                for ( ast::ptr< ast::DeclWithType > & assn : asserts ) {
+                                        bool isVoid = false;
+                                        assn = fixFunction( assn, isVoid );
+                                        if ( isVoid ) {
+                                                SemanticError( loc, node, "invalid type void in assertion of function " );
+                                        }
+                                }
+
+                                // place mutated assertion list in node
+                                auto mut = mutate( type );
+                                mut->assertions = move( asserts );
+                                node = ast::mutate_field_index( node, forallField, i, mut );
+                        }
+                        return node;
+                }
+
+                const ast::FunctionType * previsit( const ast::FunctionType * ftype ) {
+                        return forallFixer( location, ftype, &ast::FunctionType::forall );
+                }
+
+                const ast::StructDecl * previsit( const ast::StructDecl * aggrDecl ) {
+                        return forallFixer( aggrDecl->location, aggrDecl, &ast::StructDecl::params );
+                }
+
+                const ast::UnionDecl * previsit( const ast::UnionDecl * aggrDecl ) {
+                        return forallFixer( aggrDecl->location, aggrDecl, &ast::UnionDecl::params );
+                }
         };
 } // anonymous namespace
@@ -1713 +1835 @@
         ast::Pass< EnumAndPointerDecay_new > epc;
         ast::Pass< LinkReferenceToTypes_new > lrt{ loc, symtab };
-        ast::Pass< ForallPointerDecay_new > fpd;
+        ast::Pass< ForallPointerDecay_new > fpd{ loc };
 
         return type->accept( epc )->accept( lrt )->accept( fpd );