Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/CodeGen/CodeGenerator.cc (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -540,7 +540,10 @@ extension( nameExpr ); OperatorInfo opInfo; - if ( operatorLookup( nameExpr->get_name(), opInfo ) ) { - assert( opInfo.type == OT_CONSTANT ); - output << opInfo.symbol; + if ( operatorLookup( nameExpr->name, opInfo ) ) { + if ( opInfo.type == OT_CONSTANT ) { + output << opInfo.symbol; + } else { + output << opInfo.outputName; + } } else { output << nameExpr->get_name(); @@ -943,4 +946,67 @@ output << ";"; } + void CodeGenerator::postvisit( CatchStmt * stmt ) { + assertf( ! genC, "Catch statements should not reach code generation." ); + + output << ((stmt->get_kind() == CatchStmt::Terminate) ? + "catch" : "catchResume"); + output << "( "; + stmt->decl->accept( *visitor ); + output << " ) "; + + if( stmt->cond ) { + output << "if/when(?) ("; + stmt->cond->accept( *visitor ); + output << ") "; + } + stmt->body->accept( *visitor ); + } + + void CodeGenerator::postvisit( WaitForStmt * stmt ) { + assertf( ! genC, "Waitfor statements should not reach code generation." ); + + bool first = true; + for( auto & clause : stmt->clauses ) { + if(first) { output << "or "; first = false; } + if( clause.condition ) { + output << "when("; + stmt->timeout.condition->accept( *visitor ); + output << ") "; + } + output << "waitfor("; + clause.target.function->accept( *visitor ); + for( Expression * expr : clause.target.arguments ) { + output << ","; + expr->accept( *visitor ); + } + output << ") "; + clause.statement->accept( *visitor ); + } + + if( stmt->timeout.statement ) { + output << "or "; + if( stmt->timeout.condition ) { + output << "when("; + stmt->timeout.condition->accept( *visitor ); + output << ") "; + } + output << "timeout("; + stmt->timeout.time->accept( *visitor ); + output << ") "; + stmt->timeout.statement->accept( *visitor ); + } + + if( stmt->orelse.statement ) { + output << "or "; + if( stmt->orelse.condition ) { + output << "when("; + stmt->orelse.condition->accept( *visitor ); + output << ")"; + } + output << "else "; + stmt->orelse.statement->accept( *visitor ); + } + } + void CodeGenerator::postvisit( WhileStmt * whileStmt ) { Index: src/CodeGen/CodeGenerator.h =================================================================== --- src/CodeGen/CodeGenerator.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/CodeGen/CodeGenerator.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -100,4 +100,6 @@ void postvisit( ReturnStmt * ); void postvisit( ThrowStmt * ); + void postvisit( CatchStmt * ); + void postvisit( WaitForStmt * ); void postvisit( WhileStmt * ); void postvisit( ForStmt * ); Index: src/Common/PassVisitor.h =================================================================== --- src/Common/PassVisitor.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/Common/PassVisitor.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -10,4 +10,5 @@ #include "SymTab/Indexer.h" +#include "SynTree/Attribute.h" #include "SynTree/Initializer.h" #include "SynTree/Statement.h" @@ -53,181 +54,185 @@ pass_type pass; - virtual void visit( ObjectDecl *objectDecl ) override final; - virtual void visit( FunctionDecl *functionDecl ) override final; - virtual void visit( StructDecl *aggregateDecl ) override final; - virtual void visit( UnionDecl *aggregateDecl ) override final; - virtual void visit( EnumDecl *aggregateDecl ) override final; - virtual void visit( TraitDecl *aggregateDecl ) override final; - virtual void visit( TypeDecl *typeDecl ) override final; - virtual void visit( TypedefDecl *typeDecl ) override final; - virtual void visit( AsmDecl *asmDecl ) override final; - - virtual void visit( CompoundStmt *compoundStmt ) override final; - virtual void visit( ExprStmt *exprStmt ) override final; - virtual void visit( AsmStmt *asmStmt ) override final; - virtual void visit( IfStmt *ifStmt ) override final; - virtual void visit( WhileStmt *whileStmt ) override final; - virtual void visit( ForStmt *forStmt ) override final; - virtual void visit( SwitchStmt *switchStmt ) override final; - virtual void visit( CaseStmt *caseStmt ) override final; - virtual void visit( BranchStmt *branchStmt ) override final; - virtual void visit( ReturnStmt *returnStmt ) override final; - virtual void visit( ThrowStmt *throwStmt ) override final; - virtual void visit( TryStmt *tryStmt ) override final; - virtual void visit( CatchStmt *catchStmt ) override final; - virtual void visit( FinallyStmt *finallyStmt ) override final; - virtual void visit( WaitForStmt *waitforStmt ) override final; - virtual void visit( NullStmt *nullStmt ) override final; - virtual void visit( DeclStmt *declStmt ) override final; - virtual void visit( ImplicitCtorDtorStmt *impCtorDtorStmt ) override final; - - virtual void visit( ApplicationExpr *applicationExpr ) override final; - virtual void visit( UntypedExpr *untypedExpr ) override final; - virtual void visit( NameExpr *nameExpr ) override final; - virtual void visit( CastExpr *castExpr ) override final; - virtual void visit( VirtualCastExpr *castExpr ) override final; - virtual void visit( AddressExpr *addressExpr ) override final; - virtual void visit( LabelAddressExpr *labAddressExpr ) override final; - virtual void visit( UntypedMemberExpr *memberExpr ) override final; - virtual void visit( MemberExpr *memberExpr ) override final; - virtual void visit( VariableExpr *variableExpr ) override final; - virtual void visit( ConstantExpr *constantExpr ) override final; - virtual void visit( SizeofExpr *sizeofExpr ) override final; - virtual void visit( AlignofExpr *alignofExpr ) override final; - virtual void visit( UntypedOffsetofExpr *offsetofExpr ) override final; - virtual void visit( OffsetofExpr *offsetofExpr ) override final; - virtual void visit( OffsetPackExpr *offsetPackExpr ) override final; - virtual void visit( AttrExpr *attrExpr ) override final; - virtual void visit( LogicalExpr *logicalExpr ) override final; - virtual void visit( ConditionalExpr *conditionalExpr ) override final; - virtual void visit( CommaExpr *commaExpr ) override final; - virtual void visit( TypeExpr *typeExpr ) override final; - virtual void visit( AsmExpr *asmExpr ) override final; - virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr ) override final; - virtual void visit( ConstructorExpr * ctorExpr ) override final; - virtual void visit( CompoundLiteralExpr *compLitExpr ) override final; - virtual void visit( RangeExpr *rangeExpr ) override final; - virtual void visit( UntypedTupleExpr *tupleExpr ) override final; - virtual void visit( TupleExpr *tupleExpr ) override final; - virtual void visit( TupleIndexExpr *tupleExpr ) override final; - virtual void visit( TupleAssignExpr *assignExpr ) override final; - virtual void visit( StmtExpr * stmtExpr ) override final; - virtual void visit( UniqueExpr * uniqueExpr ) override final; - - virtual void visit( VoidType *basicType ) override final; - virtual void visit( BasicType *basicType ) override final; - virtual void visit( PointerType *pointerType ) override final; - virtual void visit( ArrayType *arrayType ) override final; - virtual void visit( ReferenceType *referenceType ) override final; - virtual void visit( FunctionType *functionType ) override final; - virtual void visit( StructInstType *aggregateUseType ) override final; - virtual void visit( UnionInstType *aggregateUseType ) override final; - virtual void visit( EnumInstType *aggregateUseType ) override final; - virtual void visit( TraitInstType *aggregateUseType ) override final; - virtual void visit( TypeInstType *aggregateUseType ) override final; - virtual void visit( TupleType *tupleType ) override final; - virtual void visit( TypeofType *typeofType ) override final; - virtual void visit( AttrType *attrType ) override final; - virtual void visit( VarArgsType *varArgsType ) override final; - virtual void visit( ZeroType *zeroType ) override final; - virtual void visit( OneType *oneType ) override final; - - virtual void visit( Designation *designation ) override final; - virtual void visit( SingleInit *singleInit ) override final; - virtual void visit( ListInit *listInit ) override final; - virtual void visit( ConstructorInit *ctorInit ) override final; - - virtual void visit( Subrange *subrange ) override final; - - virtual void visit( Constant *constant ) override final; - - virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override final; - virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override final; - virtual Declaration* mutate( StructDecl *aggregateDecl ) override final; - virtual Declaration* mutate( UnionDecl *aggregateDecl ) override final; - virtual Declaration* mutate( EnumDecl *aggregateDecl ) override final; - virtual Declaration* mutate( TraitDecl *aggregateDecl ) override final; - virtual Declaration* mutate( TypeDecl *typeDecl ) override final; - virtual Declaration* mutate( TypedefDecl *typeDecl ) override final; - virtual AsmDecl* mutate( AsmDecl *asmDecl ) override final; - - virtual CompoundStmt* mutate( CompoundStmt *compoundStmt ) override final; - virtual Statement* mutate( ExprStmt *exprStmt ) override final; - virtual Statement* mutate( AsmStmt *asmStmt ) override final; - virtual Statement* mutate( IfStmt *ifStmt ) override final; - virtual Statement* mutate( WhileStmt *whileStmt ) override final; - virtual Statement* mutate( ForStmt *forStmt ) override final; - virtual Statement* mutate( SwitchStmt *switchStmt ) override final; - virtual Statement* mutate( CaseStmt *caseStmt ) override final; - virtual Statement* mutate( BranchStmt *branchStmt ) override final; - virtual Statement* mutate( ReturnStmt *returnStmt ) override final; - virtual Statement* mutate( ThrowStmt *throwStmt ) override final; - virtual Statement* mutate( TryStmt *tryStmt ) override final; - virtual Statement* mutate( CatchStmt *catchStmt ) override final; - virtual Statement* mutate( FinallyStmt *finallyStmt ) override final; - virtual Statement* mutate( WaitForStmt *waitforStmt ) override final; - virtual NullStmt* mutate( NullStmt *nullStmt ) override final; - virtual Statement* mutate( DeclStmt *declStmt ) override final; - virtual Statement* mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) override final; - - virtual Expression* mutate( ApplicationExpr *applicationExpr ) override final; - virtual Expression* mutate( UntypedExpr *untypedExpr ) override final; - virtual Expression* mutate( NameExpr *nameExpr ) override final; - virtual Expression* mutate( AddressExpr *castExpr ) override final; - virtual Expression* mutate( LabelAddressExpr *labAddressExpr ) override final; - virtual Expression* mutate( CastExpr *castExpr ) override final; - virtual Expression* mutate( VirtualCastExpr *castExpr ) override final; - virtual Expression* mutate( UntypedMemberExpr *memberExpr ) override final; - virtual Expression* mutate( MemberExpr *memberExpr ) override final; - virtual Expression* mutate( VariableExpr *variableExpr ) override final; - virtual Expression* mutate( ConstantExpr *constantExpr ) override final; - virtual Expression* mutate( SizeofExpr *sizeofExpr ) override final; - virtual Expression* mutate( AlignofExpr *alignofExpr ) override final; - virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr ) override final; - virtual Expression* mutate( OffsetofExpr *offsetofExpr ) override final; - virtual Expression* mutate( OffsetPackExpr *offsetPackExpr ) override final; - virtual Expression* mutate( AttrExpr *attrExpr ) override final; - virtual Expression* mutate( LogicalExpr *logicalExpr ) override final; - virtual Expression* mutate( ConditionalExpr *conditionalExpr ) override final; - virtual Expression* mutate( CommaExpr *commaExpr ) override final; - virtual Expression* mutate( TypeExpr *typeExpr ) override final; - virtual Expression* mutate( AsmExpr *asmExpr ) override final; - virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr ) override final; - virtual Expression* mutate( ConstructorExpr *ctorExpr ) override final; - virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ) override final; - virtual Expression* mutate( RangeExpr *rangeExpr ) override final; - virtual Expression* mutate( UntypedTupleExpr *tupleExpr ) override final; - virtual Expression* mutate( TupleExpr *tupleExpr ) override final; - virtual Expression* mutate( TupleIndexExpr *tupleExpr ) override final; - virtual Expression* mutate( TupleAssignExpr *assignExpr ) override final; - virtual Expression* mutate( StmtExpr * stmtExpr ) override final; - virtual Expression* mutate( UniqueExpr * uniqueExpr ) override final; - - virtual Type* mutate( VoidType *basicType ) override final; - virtual Type* mutate( BasicType *basicType ) override final; - virtual Type* mutate( PointerType *pointerType ) override final; - virtual Type* mutate( ArrayType *arrayType ) override final; - virtual Type* mutate( ReferenceType *referenceType ) override final; - virtual Type* mutate( FunctionType *functionType ) override final; - virtual Type* mutate( StructInstType *aggregateUseType ) override final; - virtual Type* mutate( UnionInstType *aggregateUseType ) override final; - virtual Type* mutate( EnumInstType *aggregateUseType ) override final; - virtual Type* mutate( TraitInstType *aggregateUseType ) override final; - virtual Type* mutate( TypeInstType *aggregateUseType ) override final; - virtual Type* mutate( TupleType *tupleType ) override final; - virtual Type* mutate( TypeofType *typeofType ) override final; - virtual Type* mutate( AttrType *attrType ) override final; - virtual Type* mutate( VarArgsType *varArgsType ) override final; - virtual Type* mutate( ZeroType *zeroType ) override final; - virtual Type* mutate( OneType *oneType ) override final; - - virtual Designation* mutate( Designation *designation ) override final; - virtual Initializer* mutate( SingleInit *singleInit ) override final; - virtual Initializer* mutate( ListInit *listInit ) override final; - virtual Initializer* mutate( ConstructorInit *ctorInit ) override final; - - virtual Subrange *mutate( Subrange *subrange ) override final; - - virtual Constant *mutate( Constant *constant ) override final; + virtual void visit( ObjectDecl * objectDecl ) override final; + virtual void visit( FunctionDecl * functionDecl ) override final; + virtual void visit( StructDecl * aggregateDecl ) override final; + virtual void visit( UnionDecl * aggregateDecl ) override final; + virtual void visit( EnumDecl * aggregateDecl ) override final; + virtual void visit( TraitDecl * aggregateDecl ) override final; + virtual void visit( TypeDecl * typeDecl ) override final; + virtual void visit( TypedefDecl * typeDecl ) override final; + virtual void visit( AsmDecl * asmDecl ) override final; + + virtual void visit( CompoundStmt * compoundStmt ) override final; + virtual void visit( ExprStmt * exprStmt ) override final; + virtual void visit( AsmStmt * asmStmt ) override final; + virtual void visit( IfStmt * ifStmt ) override final; + virtual void visit( WhileStmt * whileStmt ) override final; + virtual void visit( ForStmt * forStmt ) override final; + virtual void visit( SwitchStmt * switchStmt ) override final; + virtual void visit( CaseStmt * caseStmt ) override final; + virtual void visit( BranchStmt * branchStmt ) override final; + virtual void visit( ReturnStmt * returnStmt ) override final; + virtual void visit( ThrowStmt * throwStmt ) override final; + virtual void visit( TryStmt * tryStmt ) override final; + virtual void visit( CatchStmt * catchStmt ) override final; + virtual void visit( FinallyStmt * finallyStmt ) override final; + virtual void visit( WaitForStmt * waitforStmt ) override final; + virtual void visit( NullStmt * nullStmt ) override final; + virtual void visit( DeclStmt * declStmt ) override final; + virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final; + + virtual void visit( ApplicationExpr * applicationExpr ) override final; + virtual void visit( UntypedExpr * untypedExpr ) override final; + virtual void visit( NameExpr * nameExpr ) override final; + virtual void visit( CastExpr * castExpr ) override final; + virtual void visit( VirtualCastExpr * castExpr ) override final; + virtual void visit( AddressExpr * addressExpr ) override final; + virtual void visit( LabelAddressExpr * labAddressExpr ) override final; + virtual void visit( UntypedMemberExpr * memberExpr ) override final; + virtual void visit( MemberExpr * memberExpr ) override final; + virtual void visit( VariableExpr * variableExpr ) override final; + virtual void visit( ConstantExpr * constantExpr ) override final; + virtual void visit( SizeofExpr * sizeofExpr ) override final; + virtual void visit( AlignofExpr * alignofExpr ) override final; + virtual void visit( UntypedOffsetofExpr * offsetofExpr ) override final; + virtual void visit( OffsetofExpr * offsetofExpr ) override final; + virtual void visit( OffsetPackExpr * offsetPackExpr ) override final; + virtual void visit( AttrExpr * attrExpr ) override final; + virtual void visit( LogicalExpr * logicalExpr ) override final; + virtual void visit( ConditionalExpr * conditionalExpr ) override final; + virtual void visit( CommaExpr * commaExpr ) override final; + virtual void visit( TypeExpr * typeExpr ) override final; + virtual void visit( AsmExpr * asmExpr ) override final; + virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override final; + virtual void visit( ConstructorExpr * ctorExpr ) override final; + virtual void visit( CompoundLiteralExpr * compLitExpr ) override final; + virtual void visit( RangeExpr * rangeExpr ) override final; + virtual void visit( UntypedTupleExpr * tupleExpr ) override final; + virtual void visit( TupleExpr * tupleExpr ) override final; + virtual void visit( TupleIndexExpr * tupleExpr ) override final; + virtual void visit( TupleAssignExpr * assignExpr ) override final; + virtual void visit( StmtExpr * stmtExpr ) override final; + virtual void visit( UniqueExpr * uniqueExpr ) override final; + + virtual void visit( VoidType * basicType ) override final; + virtual void visit( BasicType * basicType ) override final; + virtual void visit( PointerType * pointerType ) override final; + virtual void visit( ArrayType * arrayType ) override final; + virtual void visit( ReferenceType * referenceType ) override final; + virtual void visit( FunctionType * functionType ) override final; + virtual void visit( StructInstType * aggregateUseType ) override final; + virtual void visit( UnionInstType * aggregateUseType ) override final; + virtual void visit( EnumInstType * aggregateUseType ) override final; + virtual void visit( TraitInstType * aggregateUseType ) override final; + virtual void visit( TypeInstType * aggregateUseType ) override final; + virtual void visit( TupleType * tupleType ) override final; + virtual void visit( TypeofType * typeofType ) override final; + virtual void visit( AttrType * attrType ) override final; + virtual void visit( VarArgsType * varArgsType ) override final; + virtual void visit( ZeroType * zeroType ) override final; + virtual void visit( OneType * oneType ) override final; + + virtual void visit( Designation * designation ) override final; + virtual void visit( SingleInit * singleInit ) override final; + virtual void visit( ListInit * listInit ) override final; + virtual void visit( ConstructorInit * ctorInit ) override final; + + virtual void visit( Subrange * subrange ) override final; + + virtual void visit( Constant * constant ) override final; + + virtual void visit( Attribute * attribute ) override final; + + virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override final; + virtual DeclarationWithType * mutate( FunctionDecl * functionDecl ) override final; + virtual Declaration * mutate( StructDecl * aggregateDecl ) override final; + virtual Declaration * mutate( UnionDecl * aggregateDecl ) override final; + virtual Declaration * mutate( EnumDecl * aggregateDecl ) override final; + virtual Declaration * mutate( TraitDecl * aggregateDecl ) override final; + virtual Declaration * mutate( TypeDecl * typeDecl ) override final; + virtual Declaration * mutate( TypedefDecl * typeDecl ) override final; + virtual AsmDecl * mutate( AsmDecl * asmDecl ) override final; + + virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final; + virtual Statement * mutate( ExprStmt * exprStmt ) override final; + virtual Statement * mutate( AsmStmt * asmStmt ) override final; + virtual Statement * mutate( IfStmt * ifStmt ) override final; + virtual Statement * mutate( WhileStmt * whileStmt ) override final; + virtual Statement * mutate( ForStmt * forStmt ) override final; + virtual Statement * mutate( SwitchStmt * switchStmt ) override final; + virtual Statement * mutate( CaseStmt * caseStmt ) override final; + virtual Statement * mutate( BranchStmt * branchStmt ) override final; + virtual Statement * mutate( ReturnStmt * returnStmt ) override final; + virtual Statement * mutate( ThrowStmt * throwStmt ) override final; + virtual Statement * mutate( TryStmt * tryStmt ) override final; + virtual Statement * mutate( CatchStmt * catchStmt ) override final; + virtual Statement * mutate( FinallyStmt * finallyStmt ) override final; + virtual Statement * mutate( WaitForStmt * waitforStmt ) override final; + virtual NullStmt * mutate( NullStmt * nullStmt ) override final; + virtual Statement * mutate( DeclStmt * declStmt ) override final; + virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final; + + virtual Expression * mutate( ApplicationExpr * applicationExpr ) override final; + virtual Expression * mutate( UntypedExpr * untypedExpr ) override final; + virtual Expression * mutate( NameExpr * nameExpr ) override final; + virtual Expression * mutate( AddressExpr * castExpr ) override final; + virtual Expression * mutate( LabelAddressExpr * labAddressExpr ) override final; + virtual Expression * mutate( CastExpr * castExpr ) override final; + virtual Expression * mutate( VirtualCastExpr * castExpr ) override final; + virtual Expression * mutate( UntypedMemberExpr * memberExpr ) override final; + virtual Expression * mutate( MemberExpr * memberExpr ) override final; + virtual Expression * mutate( VariableExpr * variableExpr ) override final; + virtual Expression * mutate( ConstantExpr * constantExpr ) override final; + virtual Expression * mutate( SizeofExpr * sizeofExpr ) override final; + virtual Expression * mutate( AlignofExpr * alignofExpr ) override final; + virtual Expression * mutate( UntypedOffsetofExpr * offsetofExpr ) override final; + virtual Expression * mutate( OffsetofExpr * offsetofExpr ) override final; + virtual Expression * mutate( OffsetPackExpr * offsetPackExpr ) override final; + virtual Expression * mutate( AttrExpr * attrExpr ) override final; + virtual Expression * mutate( LogicalExpr * logicalExpr ) override final; + virtual Expression * mutate( ConditionalExpr * conditionalExpr ) override final; + virtual Expression * mutate( CommaExpr * commaExpr ) override final; + virtual Expression * mutate( TypeExpr * typeExpr ) override final; + virtual Expression * mutate( AsmExpr * asmExpr ) override final; + virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override final; + virtual Expression * mutate( ConstructorExpr * ctorExpr ) override final; + virtual Expression * mutate( CompoundLiteralExpr * compLitExpr ) override final; + virtual Expression * mutate( RangeExpr * rangeExpr ) override final; + virtual Expression * mutate( UntypedTupleExpr * tupleExpr ) override final; + virtual Expression * mutate( TupleExpr * tupleExpr ) override final; + virtual Expression * mutate( TupleIndexExpr * tupleExpr ) override final; + virtual Expression * mutate( TupleAssignExpr * assignExpr ) override final; + virtual Expression * mutate( StmtExpr * stmtExpr ) override final; + virtual Expression * mutate( UniqueExpr * uniqueExpr ) override final; + + virtual Type * mutate( VoidType * basicType ) override final; + virtual Type * mutate( BasicType * basicType ) override final; + virtual Type * mutate( PointerType * pointerType ) override final; + virtual Type * mutate( ArrayType * arrayType ) override final; + virtual Type * mutate( ReferenceType * referenceType ) override final; + virtual Type * mutate( FunctionType * functionType ) override final; + virtual Type * mutate( StructInstType * aggregateUseType ) override final; + virtual Type * mutate( UnionInstType * aggregateUseType ) override final; + virtual Type * mutate( EnumInstType * aggregateUseType ) override final; + virtual Type * mutate( TraitInstType * aggregateUseType ) override final; + virtual Type * mutate( TypeInstType * aggregateUseType ) override final; + virtual Type * mutate( TupleType * tupleType ) override final; + virtual Type * mutate( TypeofType * typeofType ) override final; + virtual Type * mutate( AttrType * attrType ) override final; + virtual Type * mutate( VarArgsType * varArgsType ) override final; + virtual Type * mutate( ZeroType * zeroType ) override final; + virtual Type * mutate( OneType * oneType ) override final; + + virtual Designation * mutate( Designation * designation ) override final; + virtual Initializer * mutate( SingleInit * singleInit ) override final; + virtual Initializer * mutate( ListInit * listInit ) override final; + virtual Initializer * mutate( ConstructorInit * ctorInit ) override final; + + virtual Subrange * mutate( Subrange * subrange ) override final; + + virtual Constant * mutate( Constant * constant ) override final; + + virtual Attribute * mutate( Attribute * attribute ) override final; private: Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/Common/PassVisitor.impl.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -321,4 +321,5 @@ maybeAccept ( node->init , *this ); maybeAccept ( node->bitfieldWidth, *this ); + maybeAccept ( node->attributes , *this ); if ( node->name != "" ) { @@ -336,4 +337,5 @@ maybeMutateRef ( node->init , *this ); maybeMutateRef ( node->bitfieldWidth, *this ); + maybeMutateRef ( node->attributes , *this ); if ( node->name != "" ) { @@ -358,4 +360,5 @@ maybeAccept( node->type, *this ); maybeAccept( node->statements, *this ); + maybeAccept( node->attributes, *this ); } @@ -375,4 +378,5 @@ maybeMutateRef( node->type, *this ); maybeMutateRef( node->statements, *this ); + maybeMutateRef( node->attributes, *this ); } @@ -1984,4 +1988,9 @@ } +template< typename pass_type > +void PassVisitor< pass_type >::visit( Attribute * node ) { + VISIT_BODY( node ); +} + //--------------------------------------------------------------------------------------------------------------- template< typename pass_type > @@ -2069,2 +2078,7 @@ MUTATE_BODY( Constant, node ); } + +template< typename pass_type > +Attribute * PassVisitor< pass_type >::mutate( Attribute * node ) { + MUTATE_BODY( Attribute, node ); +} Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/InitTweak/FixInit.cc (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -214,10 +214,10 @@ void emit( CodeLocation, const Params &... params ); - FunctionDecl * function = 0; + FunctionDecl * function = nullptr; std::set< DeclarationWithType * > unhandled; std::map< DeclarationWithType *, CodeLocation > usedUninit; - ObjectDecl * thisParam = 0; + ObjectDecl * thisParam = nullptr; bool isCtor = false; // true if current function is a constructor - StructDecl * structDecl = 0; + StructDecl * structDecl = nullptr; }; @@ -624,5 +624,5 @@ } - DeclarationWithType *FixInit::postmutate( ObjectDecl *objDecl ) { + DeclarationWithType * FixInit::postmutate( ObjectDecl *objDecl ) { // since this removes the init field from objDecl, it must occur after children are mutated (i.e. postmutate) if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) { @@ -722,22 +722,22 @@ } else { ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor ); - ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->get_callStmt() ); + ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->callStmt ); ApplicationExpr * ctorCall = nullptr; - if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->get_expr() )) && ctorCall->get_args().size() == 2 ) { + if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->expr )) && ctorCall->get_args().size() == 2 ) { // clean up intrinsic copy constructor calls by making them into SingleInits - objDecl->set_init( new SingleInit( ctorCall->get_args().back() ) ); - ctorCall->get_args().pop_back(); + objDecl->init = new SingleInit( ctorCall->args.back() ); + ctorCall->args.pop_back(); } else { stmtsToAddAfter.push_back( ctor ); - objDecl->set_init( nullptr ); - ctorInit->set_ctor( nullptr ); + objDecl->init = nullptr; + ctorInit->ctor = nullptr; } } // if - } else if ( Initializer * init = ctorInit->get_init() ) { - objDecl->set_init( init ); - ctorInit->set_init( nullptr ); + } else if ( Initializer * init = ctorInit->init ) { + objDecl->init = init; + ctorInit->init = nullptr; } else { // no constructor and no initializer, which is okay - objDecl->set_init( nullptr ); + objDecl->init = nullptr; } // if delete ctorInit; @@ -912,6 +912,19 @@ } + void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) { + for ( auto d : decls ) { + indexer.addId( d ); + } + } + + void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) { + for ( auto td : tds ) { + indexer.addType( td ); + addIds( indexer, td->assertions ); + } + } + void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) { - GuardValue( funcDecl ); + GuardValue( function ); GuardValue( unhandled ); GuardValue( usedUninit ); @@ -946,17 +959,4 @@ } - void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) { - for ( auto d : decls ) { - indexer.addId( d ); - } - } - - void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) { - for ( auto td : tds ) { - indexer.addType( td ); - addIds( indexer, td->assertions ); - } - } - void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) { // remove the unhandled objects from usedUninit, because a call is inserted Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/InitTweak/InitTweak.cc (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -270,4 +270,18 @@ } + Type * getThisType( FunctionType * ftype ) { + assertf( ftype, "getThisType: nullptr ftype" ); + ObjectDecl * thisParam = getThisParam( ftype ); + ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( thisParam->type ); + return refType->base; + } + + ObjectDecl * getThisParam( FunctionType * ftype ) { + assertf( ftype, "getThisParam: nullptr ftype" ); + auto & params = ftype->parameters; + assertf( ! params.empty(), "getThisParam: ftype with 0 parameters: %s", toString( ftype ).c_str() ); + return strict_dynamic_cast< ObjectDecl * >( params.front() ); + } + bool tryConstruct( DeclarationWithType * dwt ) { ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt ); Index: src/InitTweak/InitTweak.h =================================================================== --- src/InitTweak/InitTweak.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/InitTweak/InitTweak.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -29,4 +29,10 @@ FunctionDecl * isCopyConstructor( Declaration * decl ); FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname ); + + /// returns the base type of the first parameter to a constructor/destructor/assignment function + Type * getThisType( FunctionType * ftype ); + + /// returns the first parameter of a constructor/destructor/assignment function + ObjectDecl * getThisParam( FunctionType * ftype ); /// transform Initializer into an argument list that can be passed to a call expression Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/ResolvExpr/AlternativeFinder.cc (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -174,7 +174,7 @@ } - void AlternativeFinder::find( Expression *expr, bool adjust, bool prune ) { + void AlternativeFinder::find( Expression *expr, bool adjust, bool prune, bool failFast ) { expr->accept( *this ); - if ( alternatives.empty() ) { + if ( failFast && alternatives.empty() ) { throw SemanticError( "No reasonable alternatives for expression ", expr ); } @@ -191,5 +191,5 @@ AltList::iterator oldBegin = alternatives.begin(); pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ) ); - if ( alternatives.begin() == oldBegin ) { + if ( failFast && alternatives.begin() == oldBegin ) { std::ostringstream stream; AltList winners; @@ -214,6 +214,14 @@ } - void AlternativeFinder::findWithAdjustment( Expression *expr, bool prune ) { - find( expr, true, prune ); + void AlternativeFinder::findWithAdjustment( Expression *expr ) { + find( expr, true ); + } + + void AlternativeFinder::findWithoutPrune( Expression * expr ) { + find( expr, true, false ); + } + + void AlternativeFinder::maybeFind( Expression * expr ) { + find( expr, true, true, false ); } @@ -714,11 +722,8 @@ // find function operators + static NameExpr *opExpr = new NameExpr( "?()" ); AlternativeFinder funcOpFinder( indexer, env ); - NameExpr *opExpr = new NameExpr( "?()" ); - try { - funcOpFinder.findWithAdjustment( opExpr ); - } catch( SemanticError &e ) { - // it's ok if there aren't any defined function ops - } + // it's ok if there aren't any defined function ops + funcOpFinder.maybeFind( opExpr); PRINT( std::cerr << "known function ops:" << std::endl; @@ -928,6 +933,5 @@ AlternativeFinder finder( indexer, env ); // don't prune here, since it's guaranteed all alternatives will have the same type - // (giving the alternatives different types is half of the point of ConstructorExpr nodes) - finder.findWithAdjustment( castExpr->get_arg(), false ); + finder.findWithoutPrune( castExpr->get_arg() ); for ( Alternative & alt : finder.alternatives ) { alternatives.push_back( Alternative( @@ -1226,5 +1230,5 @@ // don't prune here, since it's guaranteed all alternatives will have the same type // (giving the alternatives different types is half of the point of ConstructorExpr nodes) - finder.findWithAdjustment( ctorExpr->get_callExpr(), false ); + finder.findWithoutPrune( ctorExpr->get_callExpr() ); for ( Alternative & alt : finder.alternatives ) { alternatives.push_back( Alternative( new ConstructorExpr( alt.expr->clone() ), alt.env, alt.cost ) ); Index: src/ResolvExpr/AlternativeFinder.h =================================================================== --- src/ResolvExpr/AlternativeFinder.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/ResolvExpr/AlternativeFinder.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -34,7 +34,11 @@ public: AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env ); - void find( Expression *expr, bool adjust = false, bool prune = true ); + void find( Expression *expr, bool adjust = false, bool prune = true, bool failFast = true ); /// Calls find with the adjust flag set; adjustment turns array and function types into equivalent pointer types - void findWithAdjustment( Expression *expr, bool prune = true ); + void findWithAdjustment( Expression *expr ); + /// Calls find with the adjust flag set and prune flag unset; pruning ensures there is at most one alternative per result type + void findWithoutPrune( Expression *expr ); + /// Calls find with the adjust and prune flags set, failFast flags unset; fail fast ensures that there is at least one resulting alternative + void maybeFind( Expression *expr ); AltList &get_alternatives() { return alternatives; } Index: src/SymTab/Autogen.cc =================================================================== --- src/SymTab/Autogen.cc (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/SymTab/Autogen.cc (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -119,5 +119,4 @@ ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr ); ftype->get_parameters().push_back( dstParam ); - return ftype; } Index: src/SymTab/Autogen.h =================================================================== --- src/SymTab/Autogen.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/SymTab/Autogen.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -44,6 +44,12 @@ extern FunctionDecl * dereferenceOperator; - // temporary + // generate the type of an assignment function for paramType FunctionType * genAssignType( Type * paramType ); + + // generate the type of a default constructor or destructor for paramType + FunctionType * genDefaultType( Type * paramType ); + + // generate the type of a copy constructor for paramType + FunctionType * genCopyType( Type * paramType ); /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. Index: src/SynTree/Attribute.h =================================================================== --- src/SynTree/Attribute.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/SynTree/Attribute.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -20,10 +20,18 @@ #include // for string, operator== +#include "BaseSyntaxNode.h" +#include "Mutator.h" +#include "Visitor.h" + class Expression; // GCC attribute // https://gcc.gnu.org/onlinedocs/gcc-6.1.0/gcc/Attribute-Syntax.html#Attribute-Syntax -class Attribute { +class Attribute : public BaseSyntaxNode { public: + std::string name; + // to keep things nice and tight, use NameExpr for special identifier parameters + std::list< Expression * > parameters; + Attribute( std::string name = "", const std::list< Expression * > & parameters = std::list< Expression * >() ) : name( name ), parameters( parameters ) {} Attribute( const Attribute &other ); @@ -35,10 +43,8 @@ bool empty() const { return name == ""; } - Attribute * clone() const { return new Attribute( *this ); } - void print( std:: ostream &os, int indent = 0 ) const; - private: - std::string name; - // to keep things nice and tight, use NameExpr for special identifier parameters - std::list< Expression * > parameters; + Attribute * clone() const override { return new Attribute( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual Attribute * acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual void print( std::ostream & os, int indent = 0 ) const override; }; Index: src/SynTree/BaseSyntaxNode.h =================================================================== --- src/SynTree/BaseSyntaxNode.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/SynTree/BaseSyntaxNode.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -18,4 +18,5 @@ #include "Common/CodeLocation.h" class Visitor; +class Mutator; class BaseSyntaxNode { @@ -25,6 +26,8 @@ virtual ~BaseSyntaxNode() {} + virtual BaseSyntaxNode * clone() const = 0; virtual void accept( Visitor & v ) = 0; - virtual void print( std::ostream & os, int indent = 0 ) const = 0; + virtual BaseSyntaxNode * acceptMutator( Mutator & m ) = 0; + virtual void print( std::ostream & os, int indent = 0 ) const = 0; }; Index: src/SynTree/Declaration.h =================================================================== --- src/SynTree/Declaration.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/SynTree/Declaration.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -61,7 +61,7 @@ void fixUniqueId( void ); - virtual Declaration *clone() const = 0; + virtual Declaration *clone() const override = 0; virtual void accept( Visitor &v ) override = 0; - virtual Declaration *acceptMutator( Mutator &m ) = 0; + virtual Declaration *acceptMutator( Mutator &m ) override = 0; virtual void print( std::ostream &os, int indent = 0 ) const override = 0; virtual void printShort( std::ostream &os, int indent = 0 ) const = 0; @@ -164,4 +164,6 @@ CompoundStmt *get_statements() const { return statements; } void set_statements( CompoundStmt *newValue ) { statements = newValue; } + + static FunctionDecl * newFunction( const std::string & name, FunctionType * type, CompoundStmt * statements ); virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); } Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/SynTree/Expression.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -55,8 +55,8 @@ Expression * set_extension( bool exten ) { extension = exten; return this; } - virtual Expression * clone() const = 0; - virtual void accept( Visitor & v ) = 0; - virtual Expression * acceptMutator( Mutator & m ) = 0; - virtual void print( std::ostream & os, int indent = 0 ) const; + virtual Expression * clone() const override = 0; + virtual void accept( Visitor & v ) override = 0; + virtual Expression * acceptMutator( Mutator & m ) override = 0; + virtual void print( std::ostream & os, int indent = 0 ) const override; }; Index: src/SynTree/FunctionDecl.cc =================================================================== --- src/SynTree/FunctionDecl.cc (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/SynTree/FunctionDecl.cc (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -26,4 +26,5 @@ #include "Statement.h" // for CompoundStmt #include "Type.h" // for Type, FunctionType, Type::FuncSpecif... +#include "VarExprReplacer.h" extern bool translation_unit_nomain; @@ -39,4 +40,16 @@ FunctionDecl::FunctionDecl( const FunctionDecl &other ) : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) { + + VarExprReplacer::DeclMap declMap; + for ( auto p : group_iterate( other.type->parameters, type->parameters ) ) { + declMap[ std::get<0>(p) ] = std::get<1>(p); + } + for ( auto p : group_iterate( other.type->returnVals, type->returnVals ) ) { + declMap[ std::get<0>(p) ] = std::get<1>(p); + } + if ( ! declMap.empty() ) { + VarExprReplacer replacer( declMap ); + accept( replacer ); + } } @@ -44,4 +57,8 @@ delete type; delete statements; +} + +FunctionDecl * FunctionDecl::newFunction( const std::string & name, FunctionType * type, CompoundStmt * statements ) { + return new FunctionDecl( name, Type::StorageClasses(), LinkageSpec::C, type, statements ); } Index: src/SynTree/Initializer.h =================================================================== --- src/SynTree/Initializer.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/SynTree/Initializer.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -37,7 +37,7 @@ std::list< Expression * > & get_designators() { return designators; } - virtual Designation * clone() const { return new Designation( *this ); }; + virtual Designation * clone() const override { return new Designation( *this ); }; virtual void accept( Visitor &v ) override { v.visit( this ); } - virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); } + virtual Designation * acceptMutator( Mutator &m ) override { return m.mutate( this ); } virtual void print( std::ostream &os, int indent = 0 ) const override; }; @@ -54,7 +54,7 @@ bool get_maybeConstructed() { return maybeConstructed; } - virtual Initializer *clone() const = 0; + virtual Initializer *clone() const override = 0; virtual void accept( Visitor &v ) override = 0; - virtual Initializer *acceptMutator( Mutator &m ) = 0; + virtual Initializer *acceptMutator( Mutator &m ) override = 0; virtual void print( std::ostream &os, int indent = 0 ) const override = 0; private: @@ -117,4 +117,7 @@ Statement * ctor; Statement * dtor; + // C-style initializer made up of SingleInit and ListInit nodes to use as a fallback + // if an appropriate constructor definition is not found by the resolver + Initializer * init; ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init ); @@ -135,7 +138,4 @@ private: - // C-style initializer made up of SingleInit and ListInit nodes to use as a fallback - // if an appropriate constructor definition is not found by the resolver - Initializer * init; }; Index: src/SynTree/Mutator.cc =================================================================== --- src/SynTree/Mutator.cc (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/SynTree/Mutator.cc (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -17,4 +17,5 @@ #include // for list +#include "Attribute.h" // for Attribute #include "Declaration.h" // for ObjectDecl, Declaration, DeclarationWi... #include "Expression.h" // for Expression, ConstantExpr, ConditionalExpr @@ -36,4 +37,5 @@ objectDecl->set_init( maybeMutate( objectDecl->get_init(), *this ) ); objectDecl->set_bitfieldWidth( maybeMutate( objectDecl->get_bitfieldWidth(), *this ) ); + mutateAll( objectDecl->attributes, *this ); return objectDecl; } @@ -42,4 +44,5 @@ functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) ); functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) ); + mutateAll( functionDecl->attributes, *this ); return functionDecl; } @@ -618,4 +621,9 @@ } +Attribute * Mutator::mutate( Attribute * attribute ) { + mutateAll( attribute->parameters, *this ); + return attribute; +} + // Local Variables: // // tab-width: 4 // Index: src/SynTree/Mutator.h =================================================================== --- src/SynTree/Mutator.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/SynTree/Mutator.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -25,98 +25,100 @@ virtual ~Mutator(); public: - virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ); - virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ); - virtual Declaration* mutate( StructDecl *aggregateDecl ); - virtual Declaration* mutate( UnionDecl *aggregateDecl ); - virtual Declaration* mutate( EnumDecl *aggregateDecl ); - virtual Declaration* mutate( TraitDecl *aggregateDecl ); - virtual Declaration* mutate( TypeDecl *typeDecl ); - virtual Declaration* mutate( TypedefDecl *typeDecl ); - virtual AsmDecl* mutate( AsmDecl *asmDecl ); + virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ); + virtual DeclarationWithType * mutate( FunctionDecl * functionDecl ); + virtual Declaration * mutate( StructDecl * aggregateDecl ); + virtual Declaration * mutate( UnionDecl * aggregateDecl ); + virtual Declaration * mutate( EnumDecl * aggregateDecl ); + virtual Declaration * mutate( TraitDecl * aggregateDecl ); + virtual Declaration * mutate( TypeDecl * typeDecl ); + virtual Declaration * mutate( TypedefDecl * typeDecl ); + virtual AsmDecl * mutate( AsmDecl * asmDecl ); - virtual CompoundStmt* mutate( CompoundStmt *compoundStmt ); - virtual Statement* mutate( ExprStmt *exprStmt ); - virtual Statement* mutate( AsmStmt *asmStmt ); - virtual Statement* mutate( IfStmt *ifStmt ); - virtual Statement* mutate( WhileStmt *whileStmt ); - virtual Statement* mutate( ForStmt *forStmt ); - virtual Statement* mutate( SwitchStmt *switchStmt ); - virtual Statement* mutate( CaseStmt *caseStmt ); - virtual Statement* mutate( BranchStmt *branchStmt ); - virtual Statement* mutate( ReturnStmt *returnStmt ); - virtual Statement* mutate( ThrowStmt *throwStmt ); - virtual Statement* mutate( TryStmt *tryStmt ); - virtual Statement* mutate( CatchStmt *catchStmt ); - virtual Statement* mutate( FinallyStmt *catchStmt ); - virtual Statement* mutate( WaitForStmt *waitforStmt ); - virtual NullStmt* mutate( NullStmt *nullStmt ); - virtual Statement* mutate( DeclStmt *declStmt ); - virtual Statement* mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ); + virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ); + virtual Statement * mutate( ExprStmt * exprStmt ); + virtual Statement * mutate( AsmStmt * asmStmt ); + virtual Statement * mutate( IfStmt * ifStmt ); + virtual Statement * mutate( WhileStmt * whileStmt ); + virtual Statement * mutate( ForStmt * forStmt ); + virtual Statement * mutate( SwitchStmt * switchStmt ); + virtual Statement * mutate( CaseStmt * caseStmt ); + virtual Statement * mutate( BranchStmt * branchStmt ); + virtual Statement * mutate( ReturnStmt * returnStmt ); + virtual Statement * mutate( ThrowStmt * throwStmt ); + virtual Statement * mutate( TryStmt * tryStmt ); + virtual Statement * mutate( CatchStmt * catchStmt ); + virtual Statement * mutate( FinallyStmt * catchStmt ); + virtual Statement * mutate( WaitForStmt * waitforStmt ); + virtual NullStmt * mutate( NullStmt * nullStmt ); + virtual Statement * mutate( DeclStmt * declStmt ); + virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ); - virtual Expression* mutate( ApplicationExpr *applicationExpr ); - virtual Expression* mutate( UntypedExpr *untypedExpr ); - virtual Expression* mutate( NameExpr *nameExpr ); - virtual Expression* mutate( AddressExpr *castExpr ); - virtual Expression* mutate( LabelAddressExpr *labAddressExpr ); - virtual Expression* mutate( CastExpr *castExpr ); - virtual Expression* mutate( VirtualCastExpr *castExpr ); - virtual Expression* mutate( UntypedMemberExpr *memberExpr ); - virtual Expression* mutate( MemberExpr *memberExpr ); - virtual Expression* mutate( VariableExpr *variableExpr ); - virtual Expression* mutate( ConstantExpr *constantExpr ); - virtual Expression* mutate( SizeofExpr *sizeofExpr ); - virtual Expression* mutate( AlignofExpr *alignofExpr ); - virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr ); - virtual Expression* mutate( OffsetofExpr *offsetofExpr ); - virtual Expression* mutate( OffsetPackExpr *offsetPackExpr ); - virtual Expression* mutate( AttrExpr *attrExpr ); - virtual Expression* mutate( LogicalExpr *logicalExpr ); - virtual Expression* mutate( ConditionalExpr *conditionalExpr ); - virtual Expression* mutate( CommaExpr *commaExpr ); - virtual Expression* mutate( TypeExpr *typeExpr ); - virtual Expression* mutate( AsmExpr *asmExpr ); - virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr ); - virtual Expression* mutate( ConstructorExpr *ctorExpr ); - virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ); - virtual Expression* mutate( RangeExpr *rangeExpr ); - virtual Expression* mutate( UntypedTupleExpr *tupleExpr ); - virtual Expression* mutate( TupleExpr *tupleExpr ); - virtual Expression* mutate( TupleIndexExpr *tupleExpr ); - virtual Expression* mutate( TupleAssignExpr *assignExpr ); - virtual Expression* mutate( StmtExpr * stmtExpr ); - virtual Expression* mutate( UniqueExpr * uniqueExpr ); - virtual Expression* mutate( UntypedInitExpr * initExpr ); - virtual Expression* mutate( InitExpr * initExpr ); + virtual Expression* mutate( ApplicationExpr * applicationExpr ); + virtual Expression* mutate( UntypedExpr * untypedExpr ); + virtual Expression* mutate( NameExpr * nameExpr ); + virtual Expression* mutate( AddressExpr * castExpr ); + virtual Expression* mutate( LabelAddressExpr * labAddressExpr ); + virtual Expression* mutate( CastExpr * castExpr ); + virtual Expression* mutate( VirtualCastExpr * castExpr ); + virtual Expression* mutate( UntypedMemberExpr * memberExpr ); + virtual Expression* mutate( MemberExpr * memberExpr ); + virtual Expression* mutate( VariableExpr * variableExpr ); + virtual Expression* mutate( ConstantExpr * constantExpr ); + virtual Expression* mutate( SizeofExpr * sizeofExpr ); + virtual Expression* mutate( AlignofExpr * alignofExpr ); + virtual Expression* mutate( UntypedOffsetofExpr * offsetofExpr ); + virtual Expression* mutate( OffsetofExpr * offsetofExpr ); + virtual Expression* mutate( OffsetPackExpr * offsetPackExpr ); + virtual Expression* mutate( AttrExpr * attrExpr ); + virtual Expression* mutate( LogicalExpr * logicalExpr ); + virtual Expression* mutate( ConditionalExpr * conditionalExpr ); + virtual Expression* mutate( CommaExpr * commaExpr ); + virtual Expression* mutate( TypeExpr * typeExpr ); + virtual Expression* mutate( AsmExpr * asmExpr ); + virtual Expression* mutate( ImplicitCopyCtorExpr * impCpCtorExpr ); + virtual Expression* mutate( ConstructorExpr * ctorExpr ); + virtual Expression* mutate( CompoundLiteralExpr * compLitExpr ); + virtual Expression* mutate( RangeExpr * rangeExpr ); + virtual Expression* mutate( UntypedTupleExpr * tupleExpr ); + virtual Expression* mutate( TupleExpr * tupleExpr ); + virtual Expression* mutate( TupleIndexExpr * tupleExpr ); + virtual Expression* mutate( TupleAssignExpr * assignExpr ); + virtual Expression* mutate( StmtExpr * stmtExpr ); + virtual Expression* mutate( UniqueExpr * uniqueExpr ); + virtual Expression* mutate( UntypedInitExpr * initExpr ); + virtual Expression* mutate( InitExpr * initExpr ); - virtual Type* mutate( VoidType *basicType ); - virtual Type* mutate( BasicType *basicType ); - virtual Type* mutate( PointerType *pointerType ); - virtual Type* mutate( ArrayType *arrayType ); - virtual Type* mutate( ReferenceType *refType ); - virtual Type* mutate( FunctionType *functionType ); - virtual Type* mutate( StructInstType *aggregateUseType ); - virtual Type* mutate( UnionInstType *aggregateUseType ); - virtual Type* mutate( EnumInstType *aggregateUseType ); - virtual Type* mutate( TraitInstType *aggregateUseType ); - virtual Type* mutate( TypeInstType *aggregateUseType ); - virtual Type* mutate( TupleType *tupleType ); - virtual Type* mutate( TypeofType *typeofType ); - virtual Type* mutate( AttrType *attrType ); - virtual Type* mutate( VarArgsType *varArgsType ); - virtual Type* mutate( ZeroType *zeroType ); - virtual Type* mutate( OneType *oneType ); + virtual Type * mutate( VoidType * basicType ); + virtual Type * mutate( BasicType * basicType ); + virtual Type * mutate( PointerType * pointerType ); + virtual Type * mutate( ArrayType * arrayType ); + virtual Type * mutate( ReferenceType * refType ); + virtual Type * mutate( FunctionType * functionType ); + virtual Type * mutate( StructInstType * aggregateUseType ); + virtual Type * mutate( UnionInstType * aggregateUseType ); + virtual Type * mutate( EnumInstType * aggregateUseType ); + virtual Type * mutate( TraitInstType * aggregateUseType ); + virtual Type * mutate( TypeInstType * aggregateUseType ); + virtual Type * mutate( TupleType * tupleType ); + virtual Type * mutate( TypeofType * typeofType ); + virtual Type * mutate( AttrType * attrType ); + virtual Type * mutate( VarArgsType * varArgsType ); + virtual Type * mutate( ZeroType * zeroType ); + virtual Type * mutate( OneType * oneType ); - virtual Designation* mutate( Designation *designation ); - virtual Initializer* mutate( SingleInit *singleInit ); - virtual Initializer* mutate( ListInit *listInit ); - virtual Initializer* mutate( ConstructorInit *ctorInit ); + virtual Designation * mutate( Designation * designation ); + virtual Initializer * mutate( SingleInit * singleInit ); + virtual Initializer * mutate( ListInit * listInit ); + virtual Initializer * mutate( ConstructorInit * ctorInit ); - virtual Subrange *mutate( Subrange *subrange ); + virtual Subrange * mutate( Subrange * subrange ); - virtual Constant *mutate( Constant *constant ); + virtual Constant * mutate( Constant * constant ); + + virtual Attribute * mutate( Attribute * attribute ); private: - virtual Declaration* handleAggregateDecl(AggregateDecl *aggregateDecl ); - virtual Declaration* handleNamedTypeDecl(NamedTypeDecl *typeDecl ); - virtual Type* handleReferenceToType(ReferenceToType *aggregateUseType ); + virtual Declaration * handleAggregateDecl(AggregateDecl * aggregateDecl ); + virtual Declaration * handleNamedTypeDecl(NamedTypeDecl * typeDecl ); + virtual Type * handleReferenceToType(ReferenceToType * aggregateUseType ); }; Index: src/SynTree/Statement.h =================================================================== --- src/SynTree/Statement.h (revision a6c5d7c3b627f0180da89e9ae78c01a821292827) +++ src/SynTree/Statement.h (revision 6e49f1866888e0b89c9f25a3f7db862634f9c3fb) @@ -43,7 +43,7 @@ const std::list