Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision b3c36f41fb2d199b6fa2a40962f5aafe79f7ceeb) +++ src/CodeGen/CodeGenerator.cc (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) @@ -267,5 +267,5 @@ } - void CodeGenerator::visit( TraitDecl * traitDecl ) {} + void CodeGenerator::visit( __attribute__((unused)) TraitDecl * traitDecl ) {} void CodeGenerator::visit( TypedefDecl * typeDecl ) { @@ -328,5 +328,5 @@ } - void CodeGenerator::visit( ConstructorInit * init ){ + void CodeGenerator::visit( __attribute__((unused)) ConstructorInit * init ){ assertf( ! genC, "ConstructorInit nodes should not reach code generation." ); // xxx - generate something reasonable for constructor/destructor pairs @@ -962,5 +962,5 @@ } - void CodeGenerator::visit( NullStmt * nullStmt ) { + void CodeGenerator::visit( __attribute__((unused)) NullStmt * nullStmt ) { //output << indent << CodeGenerator::printLabels( nullStmt->get_labels() ); output << "/* null statement */ ;"; Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision b3c36f41fb2d199b6fa2a40962f5aafe79f7ceeb) +++ src/GenPoly/Box.cc (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) @@ -103,5 +103,5 @@ void passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ); /// wraps a function application with a new temporary for the out-parameter return value - Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ); + Expression *addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg ); /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment void replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params ); @@ -136,5 +136,5 @@ public: template< typename DeclClass > - DeclClass *handleDecl( DeclClass *decl, Type *type ); + DeclClass *handleDecl( DeclClass *decl ); template< typename AggDecl > AggDecl * handleAggDecl( AggDecl * aggDecl ); @@ -665,5 +665,5 @@ } - Expression *Pass1::addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ) { + Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg ) { // Create temporary to hold return value of polymorphic function and produce that temporary as a result // using a comma expression. @@ -732,5 +732,5 @@ Type *concrete = replaceWithConcrete( appExpr, dynType ); // add out-parameter for return value - return addRetParam( appExpr, function, concrete, arg ); + return addRetParam( appExpr, concrete, arg ); } @@ -739,5 +739,5 @@ // if ( ! function->get_returnVals().empty() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) { if ( isDynRet( function, tyVars ) ) { - ret = addRetParam( appExpr, function, function->get_returnVals().front()->get_type(), arg ); + ret = addRetParam( appExpr, function->get_returnVals().front()->get_type(), arg ); } // if std::string mangleName = mangleAdapterName( function, tyVars ); @@ -1282,5 +1282,5 @@ template< typename DeclClass > - DeclClass * Pass2::handleDecl( DeclClass *decl, Type *type ) { + DeclClass * Pass2::handleDecl( DeclClass *decl ) { DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) ); @@ -1296,5 +1296,5 @@ DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) { - functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl, functionDecl->get_functionType() ) ); + functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) ); FunctionType * ftype = functionDecl->get_functionType(); if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) { @@ -1321,5 +1321,5 @@ ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) { - return handleDecl( objectDecl, objectDecl->get_type() ); + return handleDecl( objectDecl ); } @@ -1344,5 +1344,5 @@ addToTyVarMap( typeDecl, scopeTyVars ); if ( typeDecl->get_base() ) { - return handleDecl( typeDecl, typeDecl->get_base() ); + return handleDecl( typeDecl ); } else { return Parent::mutate( typeDecl ); @@ -1351,5 +1351,5 @@ TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) { - return handleDecl( typedefDecl, typedefDecl->get_base() ); + return handleDecl( typedefDecl ); } Index: src/InitTweak/FixGlobalInit.cc =================================================================== --- src/InitTweak/FixGlobalInit.cc (revision b3c36f41fb2d199b6fa2a40962f5aafe79f7ceeb) +++ src/InitTweak/FixGlobalInit.cc (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) @@ -129,10 +129,10 @@ // only modify global variables - void GlobalFixer::visit( FunctionDecl *functionDecl ) {} - void GlobalFixer::visit( StructDecl *aggregateDecl ) {} - void GlobalFixer::visit( UnionDecl *aggregateDecl ) {} - void GlobalFixer::visit( EnumDecl *aggregateDecl ) {} - void GlobalFixer::visit( TraitDecl *aggregateDecl ) {} - void GlobalFixer::visit( TypeDecl *typeDecl ) {} + void GlobalFixer::visit( __attribute__((unused)) FunctionDecl *functionDecl ) {} + void GlobalFixer::visit( __attribute__((unused)) StructDecl *aggregateDecl ) {} + void GlobalFixer::visit( __attribute__((unused)) UnionDecl *aggregateDecl ) {} + void GlobalFixer::visit( __attribute__((unused)) EnumDecl *aggregateDecl ) {} + void GlobalFixer::visit( __attribute__((unused)) TraitDecl *aggregateDecl ) {} + void GlobalFixer::visit( __attribute__((unused)) TypeDecl *typeDecl ) {} } // namespace InitTweak Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision b3c36f41fb2d199b6fa2a40962f5aafe79f7ceeb) +++ src/InitTweak/FixInit.cc (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) @@ -110,5 +110,5 @@ // don't go into other functions - virtual void visit( FunctionDecl *decl ) override {} + virtual void visit( __attribute__((unused)) FunctionDecl *decl ) override {} protected: Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision b3c36f41fb2d199b6fa2a40962f5aafe79f7ceeb) +++ src/InitTweak/InitTweak.cc (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) @@ -92,5 +92,5 @@ InitImpl( Initializer * init ) : init( init ) {} - virtual std::list< Expression * > next( std::list< Expression * > & indices ) { + virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) { // this is wrong, but just a placeholder for now // if ( ! flattened ) flatten( indices ); @@ -248,5 +248,5 @@ } - Statement * ExprImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) { + Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) { return NULL; } @@ -475,6 +475,6 @@ ConstExprChecker() : isConstExpr( true ) {} - virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; } - virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) ApplicationExpr *applicationExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) UntypedExpr *untypedExpr ) { isConstExpr = false; } virtual void visit( NameExpr *nameExpr ) { // xxx - temporary hack, because 0 and 1 really should be constexprs, even though they technically aren't in Cforall today @@ -487,8 +487,8 @@ if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) isConstExpr = false; } - virtual void visit( LabelAddressExpr *labAddressExpr ) { isConstExpr = false; } - virtual void visit( UntypedMemberExpr *memberExpr ) { isConstExpr = false; } - virtual void visit( MemberExpr *memberExpr ) { isConstExpr = false; } - virtual void visit( VariableExpr *variableExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) LabelAddressExpr *labAddressExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) UntypedMemberExpr *memberExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) MemberExpr *memberExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) VariableExpr *variableExpr ) { isConstExpr = false; } // these might be okay? // virtual void visit( SizeofExpr *sizeofExpr ); @@ -501,11 +501,11 @@ // virtual void visit( LogicalExpr *logicalExpr ); // virtual void visit( ConditionalExpr *conditionalExpr ); - virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; } - virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; } - virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; } - virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; } - virtual void visit( UntypedTupleExpr *tupleExpr ) { isConstExpr = false; } - virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; } - virtual void visit( TupleAssignExpr *tupleExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) TypeExpr *typeExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) AsmExpr *asmExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) UntypedValofExpr *valofExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) UntypedTupleExpr *tupleExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) TupleExpr *tupleExpr ) { isConstExpr = false; } + virtual void visit( __attribute((unused)) TupleAssignExpr *tupleExpr ) { isConstExpr = false; } bool isConstExpr; Index: src/ResolvExpr/CommonType.cc =================================================================== --- src/ResolvExpr/CommonType.cc (revision b3c36f41fb2d199b6fa2a40962f5aafe79f7ceeb) +++ src/ResolvExpr/CommonType.cc (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) @@ -43,5 +43,4 @@ void getCommonWithVoidPointer( PointerType* voidPointer, PointerType* otherPointer ); - template< typename RefType > void handleRefType( RefType *inst, Type *other ); Type *result; @@ -126,6 +125,5 @@ } - void CommonType::visit( VoidType *voidType ) { - } + void CommonType::visit( __attribute((unused)) VoidType *voidType ) {} void CommonType::visit( BasicType *basicType ) { @@ -189,18 +187,8 @@ } - void CommonType::visit( ArrayType *arrayType ) { - } - - void CommonType::visit( FunctionType *functionType ) { - } - - template< typename RefType > void CommonType::handleRefType( RefType *inst, Type *other ) { - } - - void CommonType::visit( StructInstType *aggregateUseType ) { - } - - void CommonType::visit( UnionInstType *aggregateUseType ) { - } + void CommonType::visit( __attribute((unused)) ArrayType *arrayType ) {} + void CommonType::visit( __attribute((unused)) FunctionType *functionType ) {} + void CommonType::visit( __attribute((unused)) StructInstType *aggregateUseType ) {} + void CommonType::visit( __attribute((unused)) UnionInstType *aggregateUseType ) {} void CommonType::visit( EnumInstType *enumInstType ) { @@ -214,5 +202,5 @@ } - void CommonType::visit( TraitInstType *aggregateUseType ) { + void CommonType::visit( __attribute((unused)) TraitInstType *aggregateUseType ) { } @@ -239,9 +227,6 @@ } - void CommonType::visit( TupleType *tupleType ) { - } - - void CommonType::visit( VarArgsType *varArgsType ) { - } + void CommonType::visit( __attribute((unused)) TupleType *tupleType ) {} + void CommonType::visit( __attribute((unused)) VarArgsType *varArgsType ) {} void CommonType::visit( ZeroType *zeroType ) { Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision b3c36f41fb2d199b6fa2a40962f5aafe79f7ceeb) +++ src/ResolvExpr/ConversionCost.cc (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) @@ -149,5 +149,5 @@ }; - void ConversionCost::visit(VoidType *voidType) { + void ConversionCost::visit( __attribute((unused)) VoidType *voidType ) { cost = Cost::infinity; } @@ -186,9 +186,6 @@ } - void ConversionCost::visit(ArrayType *arrayType) { - } - - void ConversionCost::visit(FunctionType *functionType) { - } + void ConversionCost::visit(__attribute((unused)) ArrayType *arrayType) {} + void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {} void ConversionCost::visit(StructInstType *inst) { @@ -208,5 +205,5 @@ } - void ConversionCost::visit(EnumInstType *inst) { + void ConversionCost::visit( __attribute((unused)) EnumInstType *inst ) { static Type::Qualifiers q; static BasicType integer( q, BasicType::SignedInt ); @@ -217,5 +214,5 @@ } - void ConversionCost::visit(TraitInstType *inst) { + void ConversionCost::visit( __attribute((unused)) TraitInstType *inst) { } @@ -239,5 +236,5 @@ } - void ConversionCost::visit(TupleType *tupleType) { + void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) { Cost c; if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) { @@ -259,5 +256,5 @@ } - void ConversionCost::visit(VarArgsType *varArgsType) { + void ConversionCost::visit( __attribute((unused)) VarArgsType *varArgsType) { if ( dynamic_cast< VarArgsType* >( dest ) ) { cost = Cost::zero; @@ -265,5 +262,5 @@ } - void ConversionCost::visit(ZeroType *zeroType) { + void ConversionCost::visit( __attribute((unused)) ZeroType *zeroType) { if ( dynamic_cast< ZeroType* >( dest ) ) { cost = Cost::zero; @@ -281,5 +278,5 @@ } - void ConversionCost::visit(OneType *oneType) { + void ConversionCost::visit( __attribute((unused)) OneType *oneType) { if ( dynamic_cast< OneType* >( dest ) ) { cost = Cost::zero; Index: src/ResolvExpr/PtrsAssignable.cc =================================================================== --- src/ResolvExpr/PtrsAssignable.cc (revision b3c36f41fb2d199b6fa2a40962f5aafe79f7ceeb) +++ src/ResolvExpr/PtrsAssignable.cc (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) @@ -63,8 +63,7 @@ } - PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) { - } + PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {} - void PtrsAssignable::visit( VoidType *voidType ) { + void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) { if ( dynamic_cast< FunctionType* >( dest ) ) { result = 0; @@ -74,24 +73,13 @@ } - void PtrsAssignable::visit( BasicType *basicType ) { - } - - void PtrsAssignable::visit( PointerType *pointerType ) { - } - - void PtrsAssignable::visit( ArrayType *arrayType ) { - } - - void PtrsAssignable::visit( FunctionType *functionType ) { + void PtrsAssignable::visit( __attribute__((unused)) BasicType *basicType ) {} + void PtrsAssignable::visit( __attribute__((unused)) PointerType *pointerType ) {} + void PtrsAssignable::visit( __attribute__((unused)) ArrayType *arrayType ) {} + void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) { result = -1; } - void PtrsAssignable::visit( StructInstType *inst ) { - // I don't think we should be doing anything here, but I'm willing to admit that I might be wrong - } - - void PtrsAssignable::visit( UnionInstType *inst ) { - // I don't think we should be doing anything here, but I'm willing to admit that I might be wrong - } + void PtrsAssignable::visit( __attribute__((unused)) StructInstType *inst ) {} + void PtrsAssignable::visit( __attribute__((unused)) UnionInstType *inst ) {} void PtrsAssignable::visit( EnumInstType *inst ) { @@ -103,8 +91,5 @@ } - void PtrsAssignable::visit( TraitInstType *inst ) { - // I definitely don't think we should be doing anything here - } - + void PtrsAssignable::visit( __attribute__((unused)) TraitInstType *inst ) {} void PtrsAssignable::visit( TypeInstType *inst ) { EqvClass eqvClass; @@ -116,37 +101,8 @@ } - void PtrsAssignable::visit( TupleType *tupleType ) { -/// // This code doesn't belong here, but it might be useful somewhere else -/// if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) { -/// int ret = 0; -/// std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin(); -/// std::list< Type* >::const_iterator destIt = destAsTuple->get_types().begin(); -/// while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) { -/// int assignResult = ptrsAssignable( *srcIt++, *destIt++ ); -/// if ( assignResult == 0 ) { -/// result = assignResult; -/// return; -/// } else if ( assignResult < 0 ) { -/// ret = -1; -/// } else if ( ret > 0 ) { -/// ret += assignResult; -/// } -/// } -/// if ( srcIt == tupleType->get_types().end() && destIt == destAsTuple->get_types().end() ) { -/// result = ret; -/// } else { -/// result = 0; -/// } -/// } - } - - void PtrsAssignable::visit( VarArgsType *varArgsType ) { - } - - void PtrsAssignable::visit( ZeroType *zeroType ) { - } - - void PtrsAssignable::visit( OneType *oneType ) { - } + void PtrsAssignable::visit( __attribute__((unused)) TupleType *tupleType ) {} + void PtrsAssignable::visit( __attribute__((unused)) VarArgsType *varArgsType ) {} + void PtrsAssignable::visit( __attribute__((unused)) ZeroType *zeroType ) {} + void PtrsAssignable::visit( __attribute__((unused)) OneType *oneType ) {} } // namespace ResolvExpr Index: src/ResolvExpr/PtrsCastable.cc =================================================================== --- src/ResolvExpr/PtrsCastable.cc (revision b3c36f41fb2d199b6fa2a40962f5aafe79f7ceeb) +++ src/ResolvExpr/PtrsCastable.cc (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) @@ -92,34 +92,34 @@ } - void PtrsCastable::visit(VoidType *voidType) { + void PtrsCastable::visit( __attribute__((unused)) VoidType *voidType) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit(BasicType *basicType) { + void PtrsCastable::visit( __attribute__((unused)) BasicType *basicType) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit(PointerType *pointerType) { + void PtrsCastable::visit( __attribute__((unused)) PointerType *pointerType) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit(ArrayType *arrayType) { + void PtrsCastable::visit( __attribute__((unused)) ArrayType *arrayType) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit(FunctionType *functionType) { + void PtrsCastable::visit( __attribute__((unused)) FunctionType *functionType) { // result = -1; result = functionCast( dest, env, indexer ); } - void PtrsCastable::visit(StructInstType *inst) { + void PtrsCastable::visit( __attribute__((unused)) StructInstType *inst) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit(UnionInstType *inst) { + void PtrsCastable::visit( __attribute__((unused)) UnionInstType *inst) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit(EnumInstType *inst) { + void PtrsCastable::visit( __attribute__((unused)) EnumInstType *inst) { if ( dynamic_cast< EnumInstType* >( dest ) ) { result = 1; @@ -144,17 +144,17 @@ } - void PtrsCastable::visit(TupleType *tupleType) { + void PtrsCastable::visit( __attribute__((unused)) TupleType *tupleType) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit(VarArgsType *varArgsType) { + void PtrsCastable::visit( __attribute__((unused)) VarArgsType *varArgsType) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit(ZeroType *zeroType) { + void PtrsCastable::visit( __attribute__((unused)) ZeroType *zeroType) { result = objectCast( dest, env, indexer ); } - void PtrsCastable::visit(OneType *oneType) { + void PtrsCastable::visit( __attribute__((unused)) OneType *oneType) { result = objectCast( dest, env, indexer ); } Index: src/ResolvExpr/TypeMap.h =================================================================== --- src/ResolvExpr/TypeMap.h (revision b3c36f41fb2d199b6fa2a40962f5aafe79f7ceeb) +++ src/ResolvExpr/TypeMap.h (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) @@ -110,5 +110,5 @@ } - virtual void visit( VoidType *voidType ) { + virtual void visit( __attribute__((unused)) VoidType *voidType ) { findAndReplace( typeMap.voidValue ); } @@ -138,5 +138,5 @@ } - virtual void visit( FunctionType *functionType ) { + virtual void visit( __attribute__((unused)) FunctionType *functionType ) { findAndReplace( typeMap.functionPointerValue ); } Index: src/ResolvExpr/typeops.h =================================================================== --- src/ResolvExpr/typeops.h (revision b3c36f41fb2d199b6fa2a40962f5aafe79f7ceeb) +++ src/ResolvExpr/typeops.h (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) @@ -132,16 +132,4 @@ } - template< typename Container1, typename Container2 > - bool typesCompatibleList( Container1 &c1, Container2 &c2, const SymTab::Indexer &indexer, const TypeEnvironment &env ) { - typename Container1::iterator i1 = c1.begin(); - typename Container2::iterator i2 = c2.begin(); - for ( ; i1 != c1.end() && i2 != c2.end(); ++i1, ++i2 ) { - if ( ! typesCompatible( *i1, *i2, indexer ) ) { - return false; - } // if - } - return ( i1 == c1.end() ) && ( i2 == c2.end() ); - } - /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value. Type * extractResultType( FunctionType * functionType ); Index: src/SymTab/ImplementationType.cc =================================================================== --- src/SymTab/ImplementationType.cc (revision b3c36f41fb2d199b6fa2a40962f5aafe79f7ceeb) +++ src/SymTab/ImplementationType.cc (revision 7e003011cac72e307c02d183bca9cbd4a982d69b) @@ -61,9 +61,6 @@ } - void ImplementationType::visit(VoidType *voidType) { - } - - void ImplementationType::visit(BasicType *basicType) { - } + void ImplementationType::visit( __attribute__((unused)) VoidType *voidType ) {} + void ImplementationType::visit( __attribute__((unused)) BasicType *basicType ) {} void ImplementationType::visit(PointerType *pointerType) { @@ -89,15 +86,8 @@ } - void ImplementationType::visit(StructInstType *aggregateUseType) { - } - - void ImplementationType::visit(UnionInstType *aggregateUseType) { - } - - void ImplementationType::visit(EnumInstType *aggregateUseType) { - } - - void ImplementationType::visit(TraitInstType *aggregateUseType) { - } + void ImplementationType::visit( __attribute__((unused)) StructInstType * aggregateUseType ) {} + void ImplementationType::visit( __attribute__((unused)) UnionInstType * aggregateUseType ) {} + void ImplementationType::visit( __attribute__((unused)) EnumInstType * aggregateUseType ) {} + void ImplementationType::visit( __attribute__((unused)) TraitInstType * aggregateUseType ) {} void ImplementationType::visit(TypeInstType *inst) { @@ -120,12 +110,7 @@ } - void ImplementationType::visit(VarArgsType *varArgsType) { - } - - void ImplementationType::visit(ZeroType *zeroType) { - } - - void ImplementationType::visit(OneType *oneType) { - } + void ImplementationType::visit( __attribute__((unused)) VarArgsType *varArgsType ) {} + void ImplementationType::visit( __attribute__((unused)) ZeroType *zeroType ) {} + void ImplementationType::visit( __attribute__((unused)) OneType *oneType ) {} } // namespace SymTab