Changeset 235b41f for src/SymTab

Timestamp:

Sep 5, 2017, 3:41:04 PM (9 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

416cc86

Parents:

800d275 (diff), 3f8dd01 (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

Location:

src/SymTab

Files:

• Indexer.cc (modified) (2 diffs)
• Validate.cc (modified) (11 diffs)

src/SymTab/Indexer.cc

@@ -398 +398 @@
         void Indexer::visit( LabelAddressExpr *labAddressExpr ) {
                 acceptNewScope( labAddressExpr->get_result(), *this );
-                maybeAccept( labAddressExpr->get_arg(), *this );
         }
 
@@ -554 +553 @@
 
 
-        void Indexer::visit( TraitInstType *contextInst ) {
-                acceptAll( contextInst->get_parameters(), *this );
-                acceptAll( contextInst->get_members(), *this );
+        void Indexer::visit( TraitInstType *traitInst ) {
+                acceptAll( traitInst->get_parameters(), *this );
         }
 

src/SymTab/Validate.cc

@@ -127 +127 @@
           public:
                 LinkReferenceToTypes( bool doDebug, const Indexer *indexer );
-                using Parent::visit;
+                using Parent::visit;
+                void visit( TypeInstType *typeInst ) final;
+
                 void visit( EnumInstType *enumInst ) final;
                 void visit( StructInstType *structInst ) final;
                 void visit( UnionInstType *unionInst ) final;
-                void visit( TraitInstType *contextInst ) final;
+                void visit( TraitInstType *traitInst ) final;
+
                 void visit( EnumDecl *enumDecl ) final;
                 void visit( StructDecl *structDecl ) final;
                 void visit( UnionDecl *unionDecl ) final;
-                void visit( TypeInstType *typeInst ) final;
+                void visit( TraitDecl * traitDecl ) final;
+
           private:
                 const Indexer *indexer;
@@ -240 +244 @@
         };
 
+        struct LabelAddressFixer final : public WithGuards {
+                std::set< Label > labels;
+
+                void premutate( FunctionDecl * funcDecl );
+                Expression * postmutate( AddressExpr * addrExpr );
+        };
 
         FunctionDecl * dereferenceOperator = nullptr;
@@ -253 +263 @@
                 PassVisitor<ValidateGenericParameters> genericParams;
                 PassVisitor<FindSpecialDeclarations> finder;
+                PassVisitor<LabelAddressFixer> labelAddrFixer;
 
                 EliminateTypedef::eliminateTypedef( translationUnit );
@@ -270 +281 @@
                 ArrayLength::computeLength( translationUnit );
                 acceptAll( translationUnit, finder );
+                mutateAll( translationUnit, labelAddrFixer );
         }
 
@@ -287 +299 @@
 
         HoistStruct::HoistStruct() : inStruct( false ) {
-        }
-
-        void filter( std::list< Declaration * > &declList, bool (*pred)( Declaration * ), bool doDelete ) {
-                std::list< Declaration * >::iterator i = declList.begin();
-                while ( i != declList.end() ) {
-                        std::list< Declaration * >::iterator next = i;
-                        ++next;
-                        if ( pred( *i ) ) {
-                                if ( doDelete ) {
-                                        delete *i;
-                                } // if
-                                declList.erase( i );
-                        } // if
-                        i = next;
-                } // while
         }
 
@@ -453 +450 @@
         }
 
-        void LinkReferenceToTypes::visit( TraitInstType *traitInst ) {
+        template< typename Decl >
+        void normalizeAssertions( std::list< Decl * > & assertions ) {
+                // ensure no duplicate trait members after the clone
+                auto pred = [](Decl * d1, Decl * d2) {
+                        // only care if they're equal
+                        DeclarationWithType * dwt1 = dynamic_cast<DeclarationWithType *>( d1 );
+                        DeclarationWithType * dwt2 = dynamic_cast<DeclarationWithType *>( d2 );
+                        if ( dwt1 && dwt2 ) {
+                                if ( dwt1->get_name() == dwt2->get_name() && ResolvExpr::typesCompatible( dwt1->get_type(), dwt2->get_type(), SymTab::Indexer() ) ) {
+                                        // std::cerr << "=========== equal:" << std::endl;
+                                        // std::cerr << "d1: " << d1 << std::endl;
+                                        // std::cerr << "d2: " << d2 << std::endl;
+                                        return false;
+                                }
+                        }
+                        return d1 < d2;
+                };
+                std::set<Decl *, decltype(pred)> unique_members( assertions.begin(), assertions.end(), pred );
+                // if ( unique_members.size() != assertions.size() ) {
+                //      std::cerr << "============different" << std::endl;
+                //      std::cerr << unique_members.size() << " " << assertions.size() << std::endl;
+                // }
+
+                std::list< Decl * > order;
+                order.splice( order.end(), assertions );
+                std::copy_if( order.begin(), order.end(), back_inserter( assertions ), [&]( Decl * decl ) {
+                        return unique_members.count( decl );
+                });
+        }
+
+        // expand assertions from trait instance, performing the appropriate type variable substitutions
+        template< typename Iterator >
+        void expandAssertions( TraitInstType * inst, Iterator out ) {
+                assertf( inst->baseTrait, "Trait instance not linked to base trait: %s", toString( inst ).c_str() );
+                std::list< DeclarationWithType * > asserts;
+                for ( Declaration * decl : inst->baseTrait->members ) {
+                        asserts.push_back( safe_dynamic_cast<DeclarationWithType *>( decl->clone() ) );
+                }
+                // substitute trait decl parameters for instance parameters
+                applySubstitution( inst->baseTrait->parameters.begin(), inst->baseTrait->parameters.end(), inst->parameters.begin(), asserts.begin(), asserts.end(), out );
+        }
+
+        void LinkReferenceToTypes::visit( TraitDecl * traitDecl ) {
+                Parent::visit( traitDecl );
+
+                if ( traitDecl->name == "sized" ) {
+                        // "sized" is a special trait - flick the sized status on for the type variable
+                        assertf( traitDecl->parameters.size() == 1, "Built-in trait 'sized' has incorrect number of parameters: %zd", traitDecl->parameters.size() );
+                        TypeDecl * td = traitDecl->parameters.front();
+                        td->set_sized( true );
+                }
+
+                // move assertions from type parameters into the body of the trait
+                for ( TypeDecl * td : traitDecl->parameters ) {
+                        for ( DeclarationWithType * assert : td->assertions ) {
+                                if ( TraitInstType * inst = dynamic_cast< TraitInstType * >( assert->get_type() ) ) {
+                                        expandAssertions( inst, back_inserter( traitDecl->members ) );
+                                } else {
+                                        traitDecl->members.push_back( assert->clone() );
+                                }
+                        }
+                        deleteAll( td->assertions );
+                        td->assertions.clear();
+                } // for
+        }
+
+        void LinkReferenceToTypes::visit( TraitInstType * traitInst ) {
                 Parent::visit( traitInst );
-                if ( traitInst->get_name() == "sized" ) {
-                        // "sized" is a special trait with no members - just flick the sized status on for the type variable
-                        if ( traitInst->get_parameters().size() != 1 ) {
-                                throw SemanticError( "incorrect number of trait parameters: ", traitInst );
-                        }
-                        TypeExpr * param = safe_dynamic_cast< TypeExpr * > ( traitInst->get_parameters().front() );
-                        TypeInstType * inst = safe_dynamic_cast< TypeInstType * > ( param->get_type() );
-                        TypeDecl * decl = inst->get_baseType();
-                        decl->set_sized( true );
-                        // since "sized" is special, the next few steps don't apply
-                        return;
-                }
-
                 // handle other traits
-                TraitDecl *traitDecl = indexer->lookupTrait( traitInst->get_name() );
+                TraitDecl *traitDecl = indexer->lookupTrait( traitInst->name );
                 if ( ! traitDecl ) {
-                        throw SemanticError( "use of undeclared trait " + traitInst->get_name() );
+                        throw SemanticError( "use of undeclared trait " + traitInst->name );
                 } // if
                 if ( traitDecl->get_parameters().size() != traitInst->get_parameters().size() ) {
                         throw SemanticError( "incorrect number of trait parameters: ", traitInst );
                 } // if
-
-                for ( TypeDecl * td : traitDecl->get_parameters() ) {
-                        for ( DeclarationWithType * assert : td->get_assertions() ) {
-                                traitInst->get_members().push_back( assert->clone() );
-                        } // for
-                } // for
-
-                // need to clone members of the trait for ownership purposes
-                std::list< Declaration * > members;
-                std::transform( traitDecl->get_members().begin(), traitDecl->get_members().end(), back_inserter( members ), [](Declaration * dwt) { return dwt->clone(); } );
-
-                applySubstitution( traitDecl->get_parameters().begin(), traitDecl->get_parameters().end(), traitInst->get_parameters().begin(), members.begin(), members.end(), back_inserter( traitInst->get_members() ) );
+                traitInst->baseTrait = traitDecl;
 
                 // need to carry over the 'sized' status of each decl in the instance
@@ -498 +537 @@
                         }
                 }
+                // normalizeAssertions( traitInst->members );
         }
 
@@ -561 +601 @@
         void forallFixer( Type * func ) {
                 for ( TypeDecl * type : func->get_forall() ) {
-                        std::list< DeclarationWithType * > toBeDone, nextRound;
-                        toBeDone.splice( toBeDone.end(), type->get_assertions() );
-                        while ( ! toBeDone.empty() ) {
-                                for ( DeclarationWithType * assertion : toBeDone ) {
-                                        if ( TraitInstType *traitInst = dynamic_cast< TraitInstType * >( assertion->get_type() ) ) {
-                                                // expand trait instance into all of its members
-                                                for ( Declaration * member : traitInst->get_members() ) {
-                                                        DeclarationWithType *dwt = safe_dynamic_cast< DeclarationWithType * >( member );
-                                                        nextRound.push_back( dwt->clone() );
-                                                }
-                                                delete traitInst;
-                                        } else {
-                                                // pass assertion through
-                                                FixFunction fixer;
-                                                assertion = assertion->acceptMutator( fixer );
-                                                if ( fixer.get_isVoid() ) {
-                                                        throw SemanticError( "invalid type void in assertion of function ", func );
-                                                }
-                                                type->get_assertions().push_back( assertion );
-                                        } // if
-                                } // for
-                                toBeDone.clear();
-                                toBeDone.splice( toBeDone.end(), nextRound );
-                        } // while
+                        std::list< DeclarationWithType * > asserts;
+                        asserts.splice( asserts.end(), type->assertions );
+                        // expand trait instances into their members
+                        for ( DeclarationWithType * assertion : asserts ) {
+                                if ( TraitInstType *traitInst = dynamic_cast< TraitInstType * >( assertion->get_type() ) ) {
+                                        // expand trait instance into all of its members
+                                        expandAssertions( traitInst, back_inserter( type->assertions ) );
+                                        delete traitInst;
+                                } else {
+                                        // pass other assertions through
+                                        type->assertions.push_back( assertion );
+                                } // if
+                        } // for
+                        // apply FixFunction to every assertion to check for invalid void type
+                        for ( DeclarationWithType *& assertion : type->assertions ) {
+                                FixFunction fixer;
+                                assertion = assertion->acceptMutator( fixer );
+                                if ( fixer.get_isVoid() ) {
+                                        throw SemanticError( "invalid type void in assertion of function ", func );
+                                } // if
+                        } // for
+                        // normalizeAssertions( type->assertions );
                 } // for
         }
@@ -752 +790 @@
                 CompoundStmt *ret = Mutator::mutate( compoundStmt );
                 scopeLevel -= 1;
-                std::list< Statement * >::iterator i = compoundStmt->get_kids().begin();
-                while ( i != compoundStmt->get_kids().end() ) {
-                        std::list< Statement * >::iterator next = i+1;
-                        if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( *i ) ) {
+                // remove and delete decl stmts
+                filter( compoundStmt->kids, [](Statement * stmt) {
+                        if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
                                 if ( dynamic_cast< TypedefDecl * >( declStmt->get_decl() ) ) {
-                                        delete *i;
-                                        compoundStmt->get_kids().erase( i );
+                                        return true;
                                 } // if
                         } // if
-                        i = next;
-                } // while
+                        return false;
+                }, true);
                 typedefNames.endScope();
                 return ret;
@@ -771 +807 @@
         template<typename AggDecl>
         AggDecl *EliminateTypedef::handleAggregate( AggDecl * aggDecl ) {
-                std::list<Declaration *>::iterator it = aggDecl->get_members().begin();
-                for ( ; it != aggDecl->get_members().end(); ) {
-                        std::list< Declaration * >::iterator next = it+1;
-                        if ( dynamic_cast< TypedefDecl * >( *it ) ) {
-                                delete *it;
-                                aggDecl->get_members().erase( it );
-                        } // if
-                        it = next;
-                }
+                filter( aggDecl->members, isTypedef, true );
                 return aggDecl;
         }
@@ -957 +985 @@
         }
 
+        struct LabelFinder {
+                std::set< Label > & labels;
+                LabelFinder( std::set< Label > & labels ) : labels( labels ) {}
+                void previsit( Statement * stmt ) {
+                        for ( Label & l : stmt->labels ) {
+                                labels.insert( l );
+                        }
+                }
+        };
+
+        void LabelAddressFixer::premutate( FunctionDecl * funcDecl ) {
+                GuardValue( labels );
+                PassVisitor<LabelFinder> finder( labels );
+                funcDecl->accept( finder );
+        }
+
+        Expression * LabelAddressFixer::postmutate( AddressExpr * addrExpr ) {
+                // convert &&label into label address
+                if ( AddressExpr * inner = dynamic_cast< AddressExpr * >( addrExpr->arg ) ) {
+                        if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( inner->arg ) ) {
+                                if ( labels.count( nameExpr->name ) ) {
+                                        Label name = nameExpr->name;
+                                        delete addrExpr;
+                                        return new LabelAddressExpr( name );
+                                }
+                        }
+                }
+                return addrExpr;
+        }
+
         void FindSpecialDeclarations::previsit( FunctionDecl * funcDecl ) {
                 if ( ! dereferenceOperator ) {