Changes in / [5fda7143:1f75e2d]

Location:

src

Files:

• Common/SemanticError.cc (modified) (2 diffs)
• Common/SemanticError.h (modified) (3 diffs)
• Common/utility.h (modified) (1 diff)
• GenPoly/Box.cc (modified) (9 diffs)
• GenPoly/PolyMutator.cc (modified) (2 diffs)
• GenPoly/PolyMutator.h (modified) (5 diffs)
• InitTweak/FixInit.cc (modified) (15 diffs)
• InitTweak/GenInit.cc (modified) (9 diffs)
• InitTweak/InitTweak.cc (modified) (6 diffs)
• InitTweak/InitTweak.h (modified) (2 diffs)
• Parser/DeclarationNode.cc (modified) (34 diffs)
• Parser/ParseNode.cc (modified) (3 diffs)
• Parser/ParseNode.h (modified) (3 diffs)
• Parser/TypeData.cc (modified) (25 diffs)
• Parser/TypeData.h (modified) (4 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (6 diffs)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• SymTab/Autogen.h (modified) (1 diff)
• SymTab/Indexer.cc (modified) (4 diffs)
• SymTab/Indexer.h (modified) (1 diff)
• SynTree/Declaration.cc (modified) (1 diff)
• SynTree/Declaration.h (modified) (1 diff)
• SynTree/Expression.cc (modified) (2 diffs)
• SynTree/Expression.h (modified) (1 diff)
• SynTree/FunctionDecl.cc (modified) (1 diff)
• SynTree/Statement.cc (modified) (1 diff)
• SynTree/Statement.h (modified) (2 diffs)
• SynTree/Type.cc (modified) (1 diff)
• SynTree/Type.h (modified) (1 diff)
• main.cc (modified) (5 diffs)
• tests/.expect/32/declarationSpecifier.txt (modified) (1 diff)
• tests/.expect/32/extension.txt (modified) (1 diff)
• tests/.expect/32/gccExtensions.txt (modified) (5 diffs)
• tests/.expect/64/declarationSpecifier.txt (modified) (1 diff)
• tests/.expect/64/extension.txt (modified) (1 diff)
• tests/.expect/64/gccExtensions.txt (modified) (5 diffs)
• tests/.expect/ctorWarnings.txt (added)
• tests/.expect/memberCtors-ERR1.txt (deleted)
• tests/.expect/memberCtors.txt (deleted)
• tests/Makefile.am (modified) (1 diff)
• tests/Makefile.in (modified) (1 diff)
• tests/ctorWarnings.c (added)
• tests/memberCtors.c (deleted)
• tests/typeof.c (modified) (1 diff)

src/Common/SemanticError.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// SemanticError.cc --
+// SemanticError.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -26 +26 @@
 
 SemanticError::SemanticError( std::string error ) {
-  append( error );
+        errors.push_back( std::string( "Error: " ) + error );
 }
 
 void SemanticError::append( SemanticError &other ) {
-  errors.splice( errors.end(), other.errors );
-}
-
-void SemanticError::append( const std::string & msg ) {
-  errors.push_back( std::string( "Error: ") + msg );
+        errors.splice( errors.end(), other.errors );
 }
 

src/Common/SemanticError.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// SemanticError.h --
+// SemanticError.h -- 
 //
 // Author           : Richard C. Bilson
@@ -31 +31 @@
 
         void append( SemanticError &other );
-        void append( const std::string & );
         bool isEmpty() const;
         void print( std::ostream &os );
@@ -43 +42 @@
 template< typename T >
 SemanticError::SemanticError( const std::string &error, const T *obj ) {
-        append( toString( error, obj ) );
+        std::ostringstream os;
+        os << "Error: " << error;
+        obj->print( os );
+        errors.push_back( os.str() );
 }
-
 
 #endif // SEMANTICERROR_H

src/Common/utility.h

@@ -265 +265 @@
 std::weak_ptr<ThisType> RefCountSingleton<ThisType>::global_instance;
 
-// RAII object to regulate "save and restore" behaviour, e.g.
-// void Foo::bar() {
-//   ValueGuard<int> guard(var); // var is a member of type Foo
-//   var = ...;
-// } // var's original value is restored
-template< typename T >
-struct ValueGuard {
-        T old;
-        T& ref;
-
-        ValueGuard(T& inRef) : old(inRef), ref(inRef) {}
-        ~ValueGuard() { ref = old; }
-};
-
-template< typename T >
-struct reverseIterate_t {
-        T& ref;
-
-        reverseIterate_t( T & ref ) : ref(ref) {}
-
-        typedef typename T::reverse_iterator iterator;
-        iterator begin() { return ref.rbegin(); }
-        iterator end() { return ref.rend(); }
-};
-
-template< typename T >
-reverseIterate_t< T > reverseIterate( T & ref ) {
-        return reverseIterate_t< T >( ref );
-}
-
 #endif // _UTILITY_H
 

src/GenPoly/Box.cc

@@ -158 +158 @@
                 class PolyGenericCalculator : public PolyMutator {
                 public:
-                        typedef PolyMutator Parent;
-                        using Parent::mutate;
-
                         template< typename DeclClass >
                         DeclClass *handleDecl( DeclClass *decl, Type *type );
@@ -1678 +1675 @@
                 DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) {
                         beginTypeScope( type );
-                        // knownLayouts.beginScope();
-                        // knownOffsets.beginScope();
-
-                        DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
-
-                        // knownOffsets.endScope();
-                        // knownLayouts.endScope();
+                        knownLayouts.beginScope();
+                        knownOffsets.beginScope();
+
+                        DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
+
+                        knownOffsets.endScope();
+                        knownLayouts.endScope();
                         endTypeScope();
                         return ret;
@@ -1694 +1691 @@
 
                 DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) {
-                        knownLayouts.beginScope();
-                        knownOffsets.beginScope();
-
-                        DeclarationWithType * decl = handleDecl( functionDecl, functionDecl->get_functionType() );
-                        knownOffsets.endScope();
-                        knownLayouts.endScope();
-                        return decl;
+                        return handleDecl( functionDecl, functionDecl->get_functionType() );
                 }
 
@@ -1709 +1700 @@
                 TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
                         scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
-                        return Parent::mutate( typeDecl );
+                        return Mutator::mutate( typeDecl );
                 }
 
@@ -1715 +1706 @@
                         beginTypeScope( pointerType );
 
-                        Type *ret = Parent::mutate( pointerType );
+                        Type *ret = Mutator::mutate( pointerType );
 
                         endTypeScope();
@@ -1733 +1724 @@
                         }
 
-                        Type *ret = Parent::mutate( funcType );
+                        Type *ret = Mutator::mutate( funcType );
 
                         endTypeScope();
@@ -1754 +1745 @@
                                 }
                         }
-                        return Parent::mutate( declStmt );
+                        return Mutator::mutate( declStmt );
                 }
 
@@ -1796 +1787 @@
                 Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
                         // mutate, exiting early if no longer MemberExpr
-                        Expression *expr = Parent::mutate( memberExpr );
+                        Expression *expr = Mutator::mutate( memberExpr );
                         memberExpr = dynamic_cast< MemberExpr* >( expr );
                         if ( ! memberExpr ) return expr;
@@ -1981 +1972 @@
                 Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) {
                         // mutate, exiting early if no longer OffsetofExpr
-                        Expression *expr = Parent::mutate( offsetofExpr );
+                        Expression *expr = Mutator::mutate( offsetofExpr );
                         offsetofExpr = dynamic_cast< OffsetofExpr* >( expr );
                         if ( ! offsetofExpr ) return expr;

src/GenPoly/PolyMutator.cc

@@ -30 +30 @@
 
         void PolyMutator::mutateStatementList( std::list< Statement* > &statements ) {
-                SemanticError errors;
-
                 for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
                         if ( ! stmtsToAddAfter.empty() ) {
                                 statements.splice( i, stmtsToAddAfter );
                         } // if
-                        try {
-                                *i = (*i)->acceptMutator( *this );
-                        } catch ( SemanticError &e ) {
-                                errors.append( e );
-                        } // try
+                        *i = (*i)->acceptMutator( *this );
                         if ( ! stmtsToAdd.empty() ) {
                                 statements.splice( i, stmtsToAdd );
@@ -48 +42 @@
                         statements.splice( statements.end(), stmtsToAddAfter );
                 } // if
-                if ( ! errors.isEmpty() ) {
-                        throw errors;
-                }
         }
 

src/GenPoly/PolyMutator.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// PolyMutator.h --
+// PolyMutator.h -- 
 //
 // Author           : Richard C. Bilson
@@ -30 +30 @@
         class PolyMutator : public Mutator {
           public:
-                typedef Mutator Parent;
-                using Parent::mutate;
-
                 PolyMutator();
 
@@ -45 +42 @@
                 virtual Statement* mutate(ExprStmt *catchStmt);
                 virtual Statement* mutate(ReturnStmt *catchStmt);
-
+  
                 virtual Expression* mutate(UntypedExpr *untypedExpr);
 
@@ -57 +54 @@
                 Statement* mutateStatement( Statement *stmt );
                 Expression* mutateExpression( Expression *expr );
-
+  
                 TyVarMap scopeTyVars;
                 TypeSubstitution *env;
@@ -63 +60 @@
                 std::list< Statement* > stmtsToAddAfter;
         };
-} // namespace
+} // namespace 
 
 #endif // _POLYMUTATOR_H

src/InitTweak/FixInit.cc

@@ -31 +31 @@
 #include "SynTree/Mutator.h"
 #include "SymTab/Indexer.h"
-#include "SymTab/Autogen.h"
 #include "GenPoly/PolyMutator.h"
 #include "SynTree/AddStmtVisitor.h"
@@ -177 +176 @@
                 };
 
-                class GenStructMemberCalls : public SymTab::Indexer {
+                class WarnStructMembers : public Visitor {
                   public:
-                        typedef Indexer Parent;
-                        /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors
-                        /// for any member that is missing a corresponding ctor/dtor call.
-                        /// error if a member is used before constructed
-                        static void generate( std::list< Declaration * > & translationUnit );
+                        typedef Visitor Parent;
+                        /// warn if a user-defined constructor or destructor is missing calls for
+                        /// a struct member or if a member is used before constructed
+                        static void warnings( std::list< Declaration * > & translationUnit );
 
                         virtual void visit( FunctionDecl * funcDecl );
@@ -190 +188 @@
                         virtual void visit( ApplicationExpr * appExpr );
 
-                        SemanticError errors;
                   private:
                         void handleFirstParam( Expression * firstParam );
-                        template< typename... Params >
-                        void emit( const Params &... params );
 
                         FunctionDecl * function = 0;
-                        std::set< DeclarationWithType * > unhandled, usedUninit;
+                        std::set< DeclarationWithType * > unhandled;
                         ObjectDecl * thisParam = 0;
-                        bool isCtor = false; // true if current function is a constructor
-                        StructDecl * structDecl = 0;
-                };
-
-                // very simple resolver-like mutator class - used to
-                // resolve UntypedExprs that are found within newly
-                // generated constructor/destructor calls
-                class MutatingResolver : public Mutator {
-                  public:
-                        MutatingResolver( SymTab::Indexer & indexer ) : indexer( indexer ) {}
-
-                        virtual DeclarationWithType* mutate( ObjectDecl *objectDecl );
-
-                        virtual Expression* mutate( UntypedExpr *untypedExpr );
-                        private:
-                        SymTab::Indexer & indexer;
                 };
         } // namespace
@@ -230 +209 @@
                 FixCopyCtors::fixCopyCtors( translationUnit );
 
-                GenStructMemberCalls::generate( translationUnit );
+                WarnStructMembers::warnings( translationUnit );
         }
 
@@ -275 +254 @@
                 }
 
-                void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
-                        GenStructMemberCalls warner;
-                        acceptAll( translationUnit, warner );
-
-                        // visitor doesn't throw so that it can collect all errors
-                        if ( ! warner.errors.isEmpty() ) {
-                                throw warner.errors;
+                void WarnStructMembers::warnings( std::list< Declaration * > & translationUnit ) {
+                        if ( true ) { // fix this condition to skip this pass if warnings aren't enabled
+                                WarnStructMembers warner;
+                                acceptAll( translationUnit, warner );
                         }
                 }
@@ -552 +528 @@
                                                         FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
                                                         dtorCaller->fixUniqueId();
-                                                        dtorCaller->get_statements()->push_back( dtorStmt );
+                                                        dtorCaller->get_statements()->get_kids().push_back( dtorStmt );
 
                                                         // atexit(dtor_atexit);
@@ -567 +543 @@
                                                         // at global scope and there could be multiple function-scoped
                                                         // static variables with the same name in different functions.
-                                                        // Note: it isn't sufficient to modify only the mangleName, because
-                                                        // then subsequent Indexer passes can choke on seeing the object's name
-                                                        // if another object has the same name and type. An unfortunate side-effect
-                                                        // of renaming the object is that subsequent NameExprs may fail to resolve,
-                                                        // but there shouldn't be any remaining past this point.
                                                         static UniqueName staticNamer( "_static_var" );
-                                                        objDecl->set_name( objDecl->get_name() + staticNamer.newName() );
-                                                        objDecl->set_mangleName( SymTab::Mangler::mangle( objDecl ) );
+                                                        objDecl->set_mangleName( objDecl->get_mangleName() + staticNamer.newName() );
 
                                                         objDecl->set_init( NULL );
@@ -739 +709 @@
                 }
 
-                void GenStructMemberCalls::visit( FunctionDecl * funcDecl ) {
-                        ValueGuard< FunctionDecl * > oldFunction( funcDecl );
-                        ValueGuard< std::set< DeclarationWithType * > > oldUnhandled( unhandled );
-                        ValueGuard< std::set< DeclarationWithType * > > oldUsedUninit( usedUninit );
-                        ValueGuard< ObjectDecl * > oldThisParam( thisParam );
-                        ValueGuard< bool > oldIsCtor( isCtor );
-                        ValueGuard< StructDecl * > oldStructDecl( structDecl );
-
-                        // need to start with fresh sets
-                        unhandled.clear();
-                        usedUninit.clear();
+                void WarnStructMembers::visit( FunctionDecl * funcDecl ) {
+                        WarnStructMembers old = *this;
+                        *this = WarnStructMembers();
 
                         function = funcDecl;
-                        isCtor = isConstructor( function->get_name() );
-                        if ( checkWarnings( function ) ) {
-                                FunctionType * type = function->get_functionType();
+                        if ( checkWarnings( funcDecl ) ) {
+                                FunctionType * type = funcDecl->get_functionType();
                                 assert( ! type->get_parameters().empty() );
                                 thisParam = safe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
@@ -760 +721 @@
                                 StructInstType * structType = dynamic_cast< StructInstType * >( ptrType->get_base() );
                                 if ( structType ) {
-                                        structDecl = structType->get_baseStruct();
+                                        StructDecl * structDecl = structType->get_baseStruct();
                                         for ( Declaration * member : structDecl->get_members() ) {
                                                 if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
@@ -770 +731 @@
                                 }
                         }
-                        Parent::visit( function );
-
-                        // remove the unhandled objects from usedUninit, because a call is inserted
-                        // to handle them - only objects that are later constructed are used uninitialized.
-                        std::set< DeclarationWithType * > diff;
-                        std::set_difference( usedUninit.begin(), usedUninit.end(), unhandled.begin(), unhandled.end(), std::inserter( diff, diff.begin() ) );
-                        for ( DeclarationWithType * member : diff ) {
-                                emit( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", field ", member->get_name(), " used before being constructed" );
+                        Parent::visit( funcDecl );
+
+                        for ( DeclarationWithType * member : unhandled ) {
+                                // emit a warning for each unhandled member
+                                warn( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", member ", member->get_name(), " may not have been ", isConstructor( funcDecl->get_name() ) ? "constructed" : "destructed" );
                         }
 
-                        if ( ! unhandled.empty() ) {
-                                // need to explicitly re-add function parameters in order to resolve copy constructors
-                                enterScope();
-                                maybeAccept( function->get_functionType(), *this );
-
-                                // need to iterate through members in reverse in order for
-                                // ctor/dtor statements to come out in the right order
-                                for ( Declaration * member : reverseIterate( structDecl->get_members() ) ) {
-                                        DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member );
-                                        // skip non-DWT members
-                                        if ( ! field ) continue;
-                                        // skip handled members
-                                        if ( ! unhandled.count( field ) ) continue;
-
-                                        // insert and resolve default/copy constructor call for each field that's unhandled
-                                        std::list< Statement * > stmt;
-                                        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                        deref->get_args().push_back( new VariableExpr( thisParam ) );
-
-                                        Expression * arg2 = 0;
-                                        if ( isCopyConstructor( function ) ) {
-                                                // if copy ctor, need to pass second-param-of-this-function.field
-                                                std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
-                                                assert( params.size() == 2 );
-                                                arg2 = new MemberExpr( field, new VariableExpr( params.back() ) );
-                                        }
-                                        InitExpander srcParam( arg2 );
-                                        SymTab::genImplicitCall( srcParam, new MemberExpr( field, deref ), function->get_name(), back_inserter( stmt ), field, isCtor );
-
-                                        assert( stmt.size() <= 1 );
-                                        if ( stmt.size() == 1 ) {
-                                                Statement * callStmt = stmt.front();
-
-                                                MutatingResolver resolver( *this );
-                                                try {
-                                                        callStmt->acceptMutator( resolver );
-                                                        if ( isCtor ) {
-                                                                function->get_statements()->push_front( callStmt );
-                                                        } else {
-                                                                // destructor statements should be added at the end
-                                                                function->get_statements()->push_back( callStmt );
-                                                        }
-                                                } catch ( SemanticError & error ) {
-                                                        emit( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", field ", field->get_name(), " not explicitly ", isCtor ? "constructed" : "destructed",  " and no ", isCtor ? "default constructor" : "destructor", " found" );
-                                                }
-                                        }
-                                }
-                                leaveScope();
-                        }
-                }
-
-                void GenStructMemberCalls::visit( ApplicationExpr * appExpr ) {
+                        *this = old;
+                }
+
+                void WarnStructMembers::visit( ApplicationExpr * appExpr ) {
                         if ( ! checkWarnings( function ) ) return;
 
@@ -850 +760 @@
                                         handleFirstParam( firstParam );
                                 }
+                        } else if ( fname == "?=?" && isIntrinsicCallExpr( appExpr ) ) {
+                                // forgive use of intrinsic assignment to construct, since instrinsic constructors
+                                // codegen as assignment anyway.
+                                assert( appExpr->get_args().size() == 2 );
+                                handleFirstParam( appExpr->get_args().front() );
                         }
 
@@ -855 +770 @@
                 }
 
-                void GenStructMemberCalls::handleFirstParam( Expression * firstParam ) {
+                void WarnStructMembers::handleFirstParam( Expression * firstParam ) {
                         using namespace std;
                         if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( firstParam ) ) {
@@ -872 +787 @@
                 }
 
-                void GenStructMemberCalls::visit( MemberExpr * memberExpr ) {
+                void WarnStructMembers::visit( MemberExpr * memberExpr ) {
                         if ( ! checkWarnings( function ) ) return;
-                        if ( ! isCtor ) return;
+                        if ( ! isConstructor( function->get_name() ) ) return;
 
                         if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
@@ -882 +797 @@
                                                         if ( unhandled.count( memberExpr->get_member() ) ) {
                                                                 // emit a warning because a member was used before it was constructed
-                                                                usedUninit.insert( memberExpr->get_member() );
+                                                                warn( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", member ", memberExpr->get_member()->get_name(), " used before being constructed" );
                                                         }
                                                 }
@@ -890 +805 @@
                         Parent::visit( memberExpr );
                 }
-
-                template< typename Visitor, typename... Params >
-                void error( Visitor & v, const Params &... params ) {
-                        v.errors.append( toString( params... ) );
-                }
-
-                template< typename... Params >
-                void GenStructMemberCalls::emit( const Params &... params ) {
-                        // toggle warnings vs. errors here.
-                        // warn( params... );
-                        error( *this, params... );
-                }
-
-                DeclarationWithType * MutatingResolver::mutate( ObjectDecl *objectDecl ) {
-                        // add object to the indexer assumes that there will be no name collisions
-                        // in generated code. If this changes, add mutate methods for entities with
-                        // scope and call {enter,leave}Scope explicitly.
-                        objectDecl->accept( indexer );
-                        return objectDecl;
-                }
-
-                Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) {
-                        return safe_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
-                }
         } // namespace
 } // namespace InitTweak

src/InitTweak/GenInit.cc

@@ -25 +25 @@
 #include "SynTree/Mutator.h"
 #include "SymTab/Autogen.h"
-#include "SymTab/Mangler.h"
 #include "GenPoly/PolyMutator.h"
 #include "GenPoly/DeclMutator.h"
-#include "GenPoly/ScopedSet.h"
 
 namespace InitTweak {
@@ -57 +55 @@
         class CtorDtor : public GenPoly::PolyMutator {
           public:
-                typedef GenPoly::PolyMutator Parent;
-                using Parent::mutate;
                 /// create constructor and destructor statements for object declarations.
                 /// the actual call statements will be added in after the resolver has run
@@ -69 +65 @@
                 // should not traverse into any of these declarations to find objects
                 // that need to be constructed or destructed
-                virtual Declaration* mutate( StructDecl *aggregateDecl );
+                virtual Declaration* mutate( StructDecl *aggregateDecl ) { return aggregateDecl; }
                 virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
                 virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
@@ -78 +74 @@
                 virtual Type * mutate( FunctionType *funcType ) { return funcType; }
 
-                virtual CompoundStmt * mutate( CompoundStmt * compoundStmt );
-
-          private:
-                // set of mangled type names for which a constructor or destructor exists in the current scope.
-                // these types require a ConstructorInit node to be generated, anything else is a POD type and thus
-                // should not have a ConstructorInit generated.
-
-                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
-                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
-                GenPoly::ScopedSet< std::string > managedTypes;
-                bool inFunction = false;
+          protected:
         };
 
@@ -156 +142 @@
 
         DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
-                ValueGuard< std::list<DeclarationWithType*> > oldReturnVals( returnVals );
-                ValueGuard< std::string > oldFuncName( funcName );
+                std::list<DeclarationWithType*> oldReturnVals = returnVals;
+                std::string oldFuncName = funcName;
 
                 FunctionType * type = functionDecl->get_functionType();
@@ -163 +149 @@
                 funcName = functionDecl->get_name();
                 DeclarationWithType * decl = Mutator::mutate( functionDecl );
+                returnVals = oldReturnVals;
+                funcName = oldFuncName;
                 return decl;
         }
@@ -209 +197 @@
 
         DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
-                ValueGuard< bool > oldInFunc( inFunction );
+                bool oldInFunc = inFunction;
                 inFunction = true;
                 DeclarationWithType * decl = Parent::mutate( functionDecl );
+                inFunction = oldInFunc;
                 return decl;
         }
@@ -220 +209 @@
         }
 
-        bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
-                Type * type = objDecl->get_type();
-                while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
-                        type = at->get_base();
-                }
-                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
-        }
-
-        void CtorDtor::handleDWT( DeclarationWithType * dwt ) {
-                // if this function is a user-defined constructor or destructor, mark down the type as "managed"
-                if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && isCtorDtor( dwt->get_name() ) ) {
-                        std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters();
-                        assert( ! params.empty() );
-                        PointerType * type = safe_dynamic_cast< PointerType * >( params.front()->get_type() );
-                        managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
-                }
-        }
-
         DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) {
-                handleDWT( objDecl );
-                // hands off if @=, extern, builtin, etc.
-                // if global but initializer is not constexpr, always try to construct, since this is not legal C
-                if ( ( tryConstruct( objDecl ) && isManaged( objDecl ) ) || (! inFunction && ! isConstExpr( objDecl->get_init() ) ) ) {
-                        // constructed objects cannot be designated
-                        if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.", objDecl );
-                        // constructed objects should not have initializers nested too deeply
-                        if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", objDecl );
-
+                // hands off if designated, if @=, or if extern
+                if ( tryConstruct( objDecl ) ) {
                         // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
                         // for each constructable object
@@ -277 +241 @@
                         }
                 }
-                return Parent::mutate( objDecl );
+                return Mutator::mutate( objDecl );
         }
 
         DeclarationWithType * CtorDtor::mutate( FunctionDecl *functionDecl ) {
-                ValueGuard< bool > oldInFunc = inFunction;
-                inFunction = true;
-
-                handleDWT( functionDecl );
-
-                managedTypes.beginScope();
-                // go through assertions and recursively add seen ctor/dtors
-                for ( TypeDecl * tyDecl : functionDecl->get_functionType()->get_forall() ) {
-                        for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
-                                assertion = assertion->acceptMutator( *this );
-                        }
-                }
                 // parameters should not be constructed and destructed, so don't mutate FunctionType
                 mutateAll( functionDecl->get_oldDecls(), *this );
                 functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
-
-                managedTypes.endScope();
                 return functionDecl;
         }
-
-        Declaration* CtorDtor::mutate( StructDecl *aggregateDecl ) {
-                // don't construct members, but need to take note if there is a managed member,
-                // because that means that this type is also managed
-                for ( Declaration * member : aggregateDecl->get_members() ) {
-                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
-                                if ( isManaged( field ) ) {
-                                        managedTypes.insert( SymTab::Mangler::mangle( aggregateDecl ) );
-                                        break;
-                                }
-                        }
-                }
-                return aggregateDecl;
-        }
-
-        CompoundStmt * CtorDtor::mutate( CompoundStmt * compoundStmt ) {
-                managedTypes.beginScope();
-                CompoundStmt * stmt = Parent::mutate( compoundStmt );
-                managedTypes.endScope();
-                return stmt;
-        }
-
 } // namespace InitTweak
 

src/InitTweak/InitTweak.cc

@@ -7 +7 @@
 #include "SynTree/Attribute.h"
 #include "GenPoly/GenPoly.h"
-#include "ResolvExpr/typeops.h"
 
 namespace InitTweak {
@@ -23 +22 @@
                 };
 
-                class InitDepthChecker : public Visitor {
-                public:
-                        bool depthOkay = true;
-                        Type * type;
-                        int curDepth = 0, maxDepth = 0;
-                        InitDepthChecker( Type * type ) : type( type ) {
-                                Type * t = type;
-                                while ( ArrayType * at = dynamic_cast< ArrayType * >( t ) ) {
-                                        maxDepth++;
-                                        t = at->get_base();
-                                }
-                                maxDepth++;
-                        }
-                        virtual void visit( ListInit * listInit ) {
-                                curDepth++;
-                                if ( curDepth > maxDepth ) depthOkay = false;
-                                Visitor::visit( listInit );
-                                curDepth--;
-                        }
-                };
-
                 class InitFlattener : public Visitor {
                         public:
@@ -74 +52 @@
                 maybeAccept( init, finder );
                 return finder.hasDesignations;
-        }
-
-        bool checkInitDepth( ObjectDecl * objDecl ) {
-                InitDepthChecker checker( objDecl->get_type() );
-                maybeAccept( objDecl->get_init(), checker );
-                return checker.depthOkay;
         }
 
@@ -259 +231 @@
                 return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
                         (objDecl->get_init() == NULL ||
-                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
+                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) &&
+                        ! isDesignated( objDecl->get_init() )
                         && objDecl->get_storageClass() != DeclarationNode::Extern;
         }
@@ -417 +390 @@
                 virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; }
                 virtual void visit( 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
-                        if ( nameExpr->get_name() != "0" && nameExpr->get_name() != "1" ) isConstExpr = false;
-                }
-                // virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
-                virtual void visit( AddressExpr *addressExpr ) {
-                        // address of a variable or member expression is constexpr
-                        Expression * arg = addressExpr->get_arg();
-                        if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) isConstExpr = false;
-                }
+                virtual void visit( NameExpr *nameExpr ) { isConstExpr = false; }
+                virtual void visit( CastExpr *castExpr ) { 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( ConstantExpr *constantExpr ) { /* bottom out */ }
                 // these might be okay?
                 // virtual void visit( SizeofExpr *sizeofExpr );
@@ -473 +439 @@
         bool isDestructor( const std::string & str ) { return str == "^?{}"; }
         bool isCtorDtor( const std::string & str ) { return isConstructor( str ) || isDestructor( str ); }
-
-        FunctionDecl * isCopyConstructor( Declaration * decl ) {
-                FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl );
-                if ( ! function ) return 0;
-                if ( ! isConstructor( function->get_name() ) ) return 0;
-                FunctionType * ftype = function->get_functionType();
-                if ( ftype->get_parameters().size() != 2 ) return 0;
-
-                Type * t1 = ftype->get_parameters().front()->get_type();
-                Type * t2 = ftype->get_parameters().back()->get_type();
-                PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
-                assert( ptrType );
-
-                if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
-                        return function;
-                } else {
-                        return 0;
-                }
-        }
 }

src/InitTweak/InitTweak.h

@@ -30 +30 @@
         bool isCtorDtor( const std::string & );
 
-        FunctionDecl * isCopyConstructor( Declaration * decl );
-
         /// transform Initializer into an argument list that can be passed to a call expression
         std::list< Expression * > makeInitList( Initializer * init );
@@ -40 +38 @@
         /// True if the Initializer contains designations
         bool isDesignated( Initializer * init );
-
-        /// True if the ObjectDecl's Initializer nesting level is not deeper than the depth of its
-        /// type, where the depth of its type is the number of nested ArrayTypes + 1
-        bool checkInitDepth( ObjectDecl * objDecl );
 
   /// Non-Null if expr is a call expression whose target function is intrinsic

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 29 22:30:56 2016
-// Update Count     : 327
+// Last Modified On : Sun Aug 28 22:12:44 2016
+// Update Count     : 278
 //
 
@@ -42 +42 @@
 
 extern LinkageSpec::Spec linkage;                                               // defined in parser.yy
-
-DeclarationNode::DeclarationNode()
-                : type( 0 )
-                , storageClass( NoStorageClass )
-                , isInline( false )
-                , isNoreturn( false )
-                , bitfieldWidth( 0 )
-                , initializer( 0 )
-                , hasEllipsis( false )
-                , linkage( ::linkage )
-                , extension( false )
-                , error() {
-        attr.expr = nullptr;
-        attr.type = nullptr;
-
-        variable.tyClass = DeclarationNode::Type;
-        variable.assertions = nullptr;
-}
-
-DeclarationNode::~DeclarationNode() {
-        delete attr.expr;
-        delete attr.type;
-        delete type;
-        delete bitfieldWidth;
-        delete initializer;
-}
 
 DeclarationNode *DeclarationNode::clone() const {
@@ -81 +55 @@
         newnode->set_next( maybeClone( get_next() ) );
         newnode->linkage = linkage;
-
-        newnode->variable.assertions = maybeClone( variable.assertions );
-        newnode->variable.name = variable.name;
-        newnode->variable.tyClass = variable.tyClass;
-
-        newnode->attr.expr = maybeClone( attr.expr );
-        newnode->attr.type = maybeClone( attr.type );
         return newnode;
 } // DeclarationNode::clone
+
+DeclarationNode::DeclarationNode()
+        : type( 0 )
+        , storageClass( NoStorageClass )
+        , isInline( false )
+        , isNoreturn( false )
+        , bitfieldWidth( 0 )
+        , initializer( 0 )
+        , hasEllipsis( false )
+        , linkage( ::linkage )
+        , extension( false )
+        , error() {
+}
+
+DeclarationNode::~DeclarationNode() {
+        delete type;
+        delete bitfieldWidth;
+        delete initializer;
+}
 
 bool DeclarationNode::get_hasEllipsis() const {
@@ -143 +129 @@
 
         newnode->type = new TypeData( TypeData::Function );
-        newnode->type->function.params = param;
-        newnode->type->function.newStyle = newStyle;
-        newnode->type->function.body = body;
+        newnode->type->function->params = param;
+        newnode->type->function->newStyle = newStyle;
+        newnode->type->function->body = body;
         typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
 
         if ( body ) {
-                newnode->type->function.hasBody = true;
+                newnode->type->function->hasBody = true;
         } // if
 
@@ -189 +175 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->basic.typeSpec.push_back( bt );
+        newnode->type->basic->typeSpec.push_back( bt );
         return newnode;
 } // DeclarationNode::newBasicType
@@ -196 +182 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->basic.modifiers.push_back( mod );
+        newnode->type->basic->modifiers.push_back( mod );
         return newnode;
 } // DeclarationNode::newModifier
 
+DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) {
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Builtin );
+        newnode->type->builtin->type = bt;
+        return newnode;
+} // DeclarationNode::newBuiltinType
+
 DeclarationNode * DeclarationNode::newFromTypedef( std::string *name ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::SymbolicInst );
-        newnode->type->symbolic.name = assign_strptr( name );
-        newnode->type->symbolic.isTypedef = true;
-        newnode->type->symbolic.params = 0;
+        newnode->type->symbolic->name = assign_strptr( name );
+        newnode->type->symbolic->isTypedef = true;
+        newnode->type->symbolic->params = 0;
         return newnode;
 } // DeclarationNode::newFromTypedef
@@ -212 +205 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
-        newnode->type->aggregate.kind = kind;
-        newnode->type->aggregate.name = assign_strptr( name );
-        if ( newnode->type->aggregate.name == "" ) {            // anonymous aggregate ?
-                newnode->type->aggregate.name = anonymous.newName();
-        } // if
-        newnode->type->aggregate.actuals = actuals;
-        newnode->type->aggregate.fields = fields;
-        newnode->type->aggregate.body = body;
+        newnode->type->aggregate->kind = kind;
+        newnode->type->aggregate->name = assign_strptr( name );
+        if ( newnode->type->aggregate->name == "" ) {           // anonymous aggregate ?
+                newnode->type->aggregate->name = anonymous.newName();
+        } // if
+        newnode->type->aggregate->actuals = actuals;
+        newnode->type->aggregate->fields = fields;
+        newnode->type->aggregate->body = body;
         return newnode;
 } // DeclarationNode::newAggregate
@@ -227 +220 @@
         newnode->name = assign_strptr( name );
         newnode->type = new TypeData( TypeData::Enum );
-        newnode->type->enumeration.name = newnode->name;
-        if ( newnode->type->enumeration.name == "" ) {          // anonymous enumeration ?
-                newnode->type->enumeration.name = DeclarationNode::anonymous.newName();
-        } // if
-        newnode->type->enumeration.constants = constants;
+        newnode->type->enumeration->name = newnode->name;
+        if ( newnode->type->enumeration->name == "" ) {         // anonymous enumeration ?
+                newnode->type->enumeration->name = DeclarationNode::anonymous.newName();
+        } // if
+        newnode->type->enumeration->constants = constants;
         return newnode;
 } // DeclarationNode::newEnum
@@ -252 +245 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::SymbolicInst );
-        newnode->type->symbolic.name = assign_strptr( name );
-        newnode->type->symbolic.isTypedef = false;
-        newnode->type->symbolic.actuals = params;
+        newnode->type->symbolic->name = assign_strptr( name );
+        newnode->type->symbolic->isTypedef = false;
+        newnode->type->symbolic->actuals = params;
         return newnode;
 } // DeclarationNode::newFromTypeGen
@@ -262 +255 @@
         newnode->name = assign_strptr( name );
         newnode->type = new TypeData( TypeData::Variable );
-        newnode->variable.tyClass = tc;
-        newnode->variable.name = newnode->name;
+        newnode->type->variable->tyClass = tc;
+        newnode->type->variable->name = newnode->name;
         return newnode;
 } // DeclarationNode::newTypeParam
@@ -270 +263 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
-        newnode->type->aggregate.kind = Trait;
-        newnode->type->aggregate.params = params;
-        newnode->type->aggregate.fields = asserts;
-        newnode->type->aggregate.name = assign_strptr( name );
+        newnode->type->aggregate->kind = Trait;
+        newnode->type->aggregate->params = params;
+        newnode->type->aggregate->fields = asserts;
+        newnode->type->aggregate->name = assign_strptr( name );
         return newnode;
 } // DeclarationNode::newTrait
@@ -280 +273 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::AggregateInst );
-        newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate );
-        newnode->type->aggInst.aggregate->aggregate.kind = Trait;
-        newnode->type->aggInst.aggregate->aggregate.name = assign_strptr( name );
-        newnode->type->aggInst.params = params;
+        newnode->type->aggInst->aggregate = new TypeData( TypeData::Aggregate );
+        newnode->type->aggInst->aggregate->aggregate->kind = Trait;
+        newnode->type->aggInst->aggregate->aggregate->name = assign_strptr( name );
+        newnode->type->aggInst->params = params;
         return newnode;
 } // DeclarationNode::newTraitUse
@@ -291 +284 @@
         newnode->name = assign_strptr( name );
         newnode->type = new TypeData( TypeData::Symbolic );
-        newnode->type->symbolic.isTypedef = false;
-        newnode->type->symbolic.params = typeParams;
-        newnode->type->symbolic.name = newnode->name;
+        newnode->type->symbolic->isTypedef = false;
+        newnode->type->symbolic->params = typeParams;
+        newnode->type->symbolic->name = newnode->name;
         return newnode;
 } // DeclarationNode::newTypeDecl
@@ -306 +299 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Array );
-        newnode->type->array.dimension = size;
-        newnode->type->array.isStatic = isStatic;
-        if ( newnode->type->array.dimension == 0 || newnode->type->array.dimension->isExpressionType<ConstantExpr *>() ) {
-                newnode->type->array.isVarLen = false;
+        newnode->type->array->dimension = size;
+        newnode->type->array->isStatic = isStatic;
+        if ( newnode->type->array->dimension == 0 || newnode->type->array->dimension->isExpressionType<ConstantExpr *>() ) {
+                newnode->type->array->isVarLen = false;
         } else {
-                newnode->type->array.isVarLen = true;
+                newnode->type->array->isVarLen = true;
         } // if
         return newnode->addQualifiers( qualifiers );
@@ -319 +312 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Array );
-        newnode->type->array.dimension = 0;
-        newnode->type->array.isStatic = false;
-        newnode->type->array.isVarLen = true;
+        newnode->type->array->dimension = 0;
+        newnode->type->array->isStatic = false;
+        newnode->type->array->isVarLen = true;
         return newnode->addQualifiers( qualifiers );
 }
@@ -334 +327 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Tuple );
-        newnode->type->tuple = members;
+        newnode->type->tuple->members = members;
         return newnode;
 }
@@ -341 +334 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Typeof );
-        newnode->type->typeexpr = expr;
-        return newnode;
-}
-
-DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Builtin );
-        newnode->builtin = bt;
-        return newnode;
-} // DeclarationNode::newBuiltinType
+        newnode->type->typeexpr->expr = expr;
+        return newnode;
+}
 
 DeclarationNode *DeclarationNode::newAttr( std::string *name, ExpressionNode *expr ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Attr );
-        newnode->attr.name = assign_strptr( name );
-        newnode->attr.expr = expr;
+        newnode->type->attr->name = assign_strptr( name );
+        newnode->type->attr->expr = expr;
         return newnode;
 }
@@ -363 +349 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Attr );
-        newnode->attr.name = assign_strptr( name );
-        newnode->attr.type = type;
+        newnode->type->attr->name = assign_strptr( name );
+        newnode->type->attr->type = type;
         return newnode;
 }
@@ -421 +407 @@
                                 } else {
                                         if ( type->kind == TypeData::Aggregate ) {
-                                                type->aggregate.params = q->type->forall;
+                                                type->aggregate->params = q->type->forall;
                                                 // change implicit typedef from TYPEDEFname to TYPEGENname
-                                                typedefTable.changeKind( type->aggregate.name, TypedefTable::TG );
+                                                typedefTable.changeKind( type->aggregate->name, TypedefTable::TG );
                                         } else {
                                                 type->forall = q->type->forall;
@@ -471 +457 @@
                                 if ( src->kind != TypeData::Unknown ) {
                                         assert( src->kind == TypeData::Basic );
-                                        dst->basic.modifiers.splice( dst->basic.modifiers.end(), src->basic.modifiers );
-                                        dst->basic.typeSpec.splice( dst->basic.typeSpec.end(), src->basic.typeSpec );
+                                        dst->basic->modifiers.splice( dst->basic->modifiers.end(), src->basic->modifiers );
+                                        dst->basic->typeSpec.splice( dst->basic->typeSpec.end(), src->basic->typeSpec );
                                 } // if
                                 break;
@@ -480 +466 @@
                                   case TypeData::Enum:
                                         dst->base = new TypeData( TypeData::AggregateInst );
-                                        dst->base->aggInst.aggregate = src;
+                                        dst->base->aggInst->aggregate = src;
                                         if ( src->kind == TypeData::Aggregate ) {
-                                                dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
+                                                dst->base->aggInst->params = maybeClone( src->aggregate->actuals );
                                         } // if
                                         dst->base->qualifiers |= src->qualifiers;
@@ -509 +495 @@
                                 if ( o->type->kind == TypeData::Aggregate || o->type->kind == TypeData::Enum ) {
                                         type = new TypeData( TypeData::AggregateInst );
-                                        type->aggInst.aggregate = o->type;
+                                        type->aggInst->aggregate = o->type;
                                         if ( o->type->kind == TypeData::Aggregate ) {
-                                                type->aggInst.params = maybeClone( o->type->aggregate.actuals );
+                                                type->aggInst->params = maybeClone( o->type->aggregate->actuals );
                                         } // if
                                         type->qualifiers |= o->type->qualifiers;
@@ -537 +523 @@
 DeclarationNode *DeclarationNode::addTypedef() {
         TypeData *newtype = new TypeData( TypeData::Symbolic );
-        newtype->symbolic.params = 0;
-        newtype->symbolic.isTypedef = true;
-        newtype->symbolic.name = name;
+        newtype->symbolic->params = 0;
+        newtype->symbolic->isTypedef = true;
+        newtype->symbolic->name = name;
         newtype->base = type;
         type = newtype;
@@ -549 +535 @@
         switch ( type->kind ) {
           case TypeData::Symbolic:
-                if ( type->symbolic.assertions ) {
-                        type->symbolic.assertions->appendList( assertions );
+                if ( type->symbolic->assertions ) {
+                        type->symbolic->assertions->appendList( assertions );
                 } else {
-                        type->symbolic.assertions = assertions;
+                        type->symbolic->assertions = assertions;
                 } // if
                 break;
           case TypeData::Variable:
-                if ( variable.assertions ) {
-                        variable.assertions->appendList( assertions );
+                if ( type->variable->assertions ) {
+                        type->variable->assertions->appendList( assertions );
                 } else {
-                        variable.assertions = assertions;
+                        type->variable->assertions = assertions;
                 } // if
                 break;
@@ -588 +574 @@
         assert( type );
         assert( type->kind == TypeData::Function );
-        assert( type->function.body == 0 );
-        type->function.body = body;
-        type->function.hasBody = true;
+        assert( type->function->body == 0 );
+        type->function->body = body;
+        type->function->hasBody = true;
         return this;
 }
@@ -597 +583 @@
         assert( type );
         assert( type->kind == TypeData::Function );
-        assert( type->function.oldDeclList == 0 );
-        type->function.oldDeclList = list;
+        assert( type->function->oldDeclList == 0 );
+        type->function->oldDeclList = list;
         return this;
 }
@@ -644 +630 @@
                           case TypeData::Enum:
                                 p->type->base = new TypeData( TypeData::AggregateInst );
-                                p->type->base->aggInst.aggregate = type;
+                                p->type->base->aggInst->aggregate = type;
                                 if ( type->kind == TypeData::Aggregate ) {
-                                        p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
+                                        p->type->base->aggInst->params = maybeClone( type->aggregate->actuals );
                                 } // if
                                 p->type->base->qualifiers |= type->qualifiers;
@@ -681 +667 @@
                           case TypeData::Enum:
                                 lastArray->base = new TypeData( TypeData::AggregateInst );
-                                lastArray->base->aggInst.aggregate = type;
+                                lastArray->base->aggInst->aggregate = type;
                                 if ( type->kind == TypeData::Aggregate ) {
-                                        lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
+                                        lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals );
                                 } // if
                                 lastArray->base->qualifiers |= type->qualifiers;
@@ -701 +687 @@
 DeclarationNode *DeclarationNode::addParamList( DeclarationNode *params ) {
         TypeData *ftype = new TypeData( TypeData::Function );
-        ftype->function.params = params;
+        ftype->function->params = params;
         setBase( type, ftype );
         return this;
@@ -711 +697 @@
                         type->base = addIdListToType( type->base, ids );
                 } else {
-                        type->function.idList = ids;
+                        type->function->idList = ids;
                 } // if
                 return type;
         } else {
                 TypeData *newtype = new TypeData( TypeData::Function );
-                newtype->function.idList = ids;
+                newtype->function->idList = ids;
                 return newtype;
         } // if
@@ -741 +727 @@
         if ( newnode->type->kind == TypeData::AggregateInst ) {
                 // don't duplicate members
-                if ( newnode->type->aggInst.aggregate->kind == TypeData::Enum ) {
-                        delete newnode->type->aggInst.aggregate->enumeration.constants;
-                        newnode->type->aggInst.aggregate->enumeration.constants = 0;
+                if ( newnode->type->aggInst->aggregate->kind == TypeData::Enum ) {
+                        delete newnode->type->aggInst->aggregate->enumeration->constants;
+                        newnode->type->aggInst->aggregate->enumeration->constants = 0;
                 } else {
-                        assert( newnode->type->aggInst.aggregate->kind == TypeData::Aggregate );
-                        delete newnode->type->aggInst.aggregate->aggregate.fields;
-                        newnode->type->aggInst.aggregate->aggregate.fields = 0;
+                        assert( newnode->type->aggInst->aggregate->kind == TypeData::Aggregate );
+                        delete newnode->type->aggInst->aggregate->aggregate->fields;
+                        newnode->type->aggInst->aggregate->aggregate->fields = 0;
                 } // if
         } // if
@@ -767 +753 @@
                         if ( newType->kind == TypeData::AggregateInst ) {
                                 // don't duplicate members
-                                if ( newType->aggInst.aggregate->kind == TypeData::Enum ) {
-                                        delete newType->aggInst.aggregate->enumeration.constants;
-                                        newType->aggInst.aggregate->enumeration.constants = 0;
+                                if ( newType->aggInst->aggregate->kind == TypeData::Enum ) {
+                                        delete newType->aggInst->aggregate->enumeration->constants;
+                                        newType->aggInst->aggregate->enumeration->constants = 0;
                                 } else {
-                                        assert( newType->aggInst.aggregate->kind == TypeData::Aggregate );
-                                        delete newType->aggInst.aggregate->aggregate.fields;
-                                        newType->aggInst.aggregate->aggregate.fields = 0;
+                                        assert( newType->aggInst->aggregate->kind == TypeData::Aggregate );
+                                        delete newType->aggInst->aggregate->aggregate->fields;
+                                        newType->aggInst->aggregate->aggregate->fields = 0;
                                 } // if
                         } // if
@@ -910 +896 @@
         if ( ! error.empty() ) throw SemanticError( error, this );
         if ( type ) {
-                if ( type->kind == TypeData::Variable ) {
-                        static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
-                        TypeDecl * ret = new TypeDecl( variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ variable.tyClass ] );
-                        buildList( variable.assertions, ret->get_assertions() );
-                        return ret;
-                } else {
-                        return buildDecl( type, name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
-                } // if
+                return buildDecl( type, name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
         } // if
         if ( ! isInline && ! isNoreturn ) {
@@ -930 +909 @@
         switch ( type->kind ) {
           case TypeData::Enum:
-                return new EnumInstType( buildQualifiers( type ), type->enumeration.name );
+                return new EnumInstType( buildQualifiers( type ), type->enumeration->name );
           case TypeData::Aggregate: {
                   ReferenceToType *ret;
-                  switch ( type->aggregate.kind ) {
+                  switch ( type->aggregate->kind ) {
                         case DeclarationNode::Struct:
-                          ret = new StructInstType( buildQualifiers( type ), type->aggregate.name );
+                          ret = new StructInstType( buildQualifiers( type ), type->aggregate->name );
                           break;
                         case DeclarationNode::Union:
-                          ret = new UnionInstType( buildQualifiers( type ), type->aggregate.name );
+                          ret = new UnionInstType( buildQualifiers( type ), type->aggregate->name );
                           break;
                         case DeclarationNode::Trait:
-                          ret = new TraitInstType( buildQualifiers( type ), type->aggregate.name );
+                          ret = new TraitInstType( buildQualifiers( type ), type->aggregate->name );
                           break;
                         default:
                           assert( false );
                   } // switch
-                  buildList( type->aggregate.actuals, ret->get_parameters() );
+                  buildList( type->aggregate->actuals, ret->get_parameters() );
                   return ret;
           }
           case TypeData::Symbolic: {
-                  TypeInstType *ret = new TypeInstType( buildQualifiers( type ), type->symbolic.name, false );
-                  buildList( type->symbolic.actuals, ret->get_parameters() );
-                  return ret;
-          }
-          case TypeData::Attr: {
-                  assert( type->kind == TypeData::Attr );
-                  // assert( type->attr );
-                  AttrType * ret;
-                  if ( attr.expr ) {
-                          ret = new AttrType( buildQualifiers( type ), attr.name, attr.expr->build() );
-                  } else {
-                          assert( attr.type );
-                          ret = new AttrType( buildQualifiers( type ), attr.name, attr.type->buildType() );
-                  } // if
+                  TypeInstType *ret = new TypeInstType( buildQualifiers( type ), type->symbolic->name, false );
+                  buildList( type->symbolic->actuals, ret->get_parameters() );
                   return ret;
           }

src/Parser/ParseNode.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ParseNode.cc --
+// ParseNode.cc -- 
 //
 // Author           : Rodolfo G. Esteves
@@ -12 +12 @@
 // Last Modified On : Wed Aug 17 23:14:16 2016
 // Update Count     : 126
-//
+// 
 
 #include "ParseNode.h"
@@ -19 +19 @@
 int ParseNode::indent_by = 4;
 
-std::ostream & operator<<( std::ostream & out, const ParseNode * node ) {
-  node->print( out );
-  return out;
-}
-
 // Local Variables: //
 // tab-width: 4 //

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 29 21:45:43 2016
-// Update Count     : 583
+// Last Modified On : Sun Aug 28 21:14:51 2016
+// Update Count     : 575
 //
 
@@ -290 +290 @@
         // bool buildFuncSpecifier( StorageClass key ) const;
 
-        struct Enumeration_t {
-                std::string name;
-                DeclarationNode * constants;
-        };
-        Enumeration_t enumeration;
-
-        struct Variable_t {
-                DeclarationNode::TypeClass tyClass;
-                std::string name;
-                DeclarationNode * assertions;
-        };
-        Variable_t variable;
-
-        struct Attr_t {
-                std::string name;
-                ExpressionNode * expr;
-                DeclarationNode * type;
-        };
-        Attr_t attr;
-
-        BuiltinType builtin;
-
         TypeData *type;
         std::string name;
@@ -431 +409 @@
 }
 
-// in ParseNode.cc
-std::ostream & operator<<( std::ostream & out, const ParseNode * node );
 
 #endif // PARSENODE_H

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 29 22:31:53 2016
-// Update Count     : 277
+// Last Modified On : Sun Aug 28 18:28:58 2016
+// Update Count     : 223
 //
 
@@ -33 +33 @@
                 break;
           case Basic:
-                // basic = new Basic_t;
+                basic = new Basic_t;
                 break;
           case Array:
-                // array = new Array_t;
-                array.dimension = 0;
-                array.isVarLen = false;
-                array.isStatic = false;
+                array = new Array_t;
+                array->dimension = 0;
+                array->isVarLen = false;
+                array->isStatic = false;
                 break;
           case Function:
-                // function = new Function_t;
-                function.params = 0;
-                function.idList = 0;
-                function.oldDeclList = 0;
-                function.body = 0;
-                function.hasBody = false;
-                function.newStyle = false;
+                function = new Function_t;
+                function->params = 0;
+                function->idList = 0;
+                function->oldDeclList = 0;
+                function->body = 0;
+                function->hasBody = false;
+                function->newStyle = false;
                 break;
           case Aggregate:
-                // aggregate = new Aggregate_t;
-                aggregate.params = 0;
-                aggregate.actuals = 0;
-                aggregate.fields = 0;
+                aggregate = new Aggregate_t;
+                aggregate->params = 0;
+                aggregate->actuals = 0;
+                aggregate->fields = 0;
                 break;
           case AggregateInst:
-                // aggInst = new AggInst_t;
-                aggInst.aggregate = 0;
-                aggInst.params = 0;
+                aggInst = new AggInst_t;
+                aggInst->aggregate = 0;
+                aggInst->params = 0;
                 break;
           case Enum:
-                // enumeration = new Enumeration_t;
-                enumeration.constants = 0;
+                enumeration = new Enumeration_t;
+                enumeration->constants = 0;
                 break;
           case Symbolic:
           case SymbolicInst:
-                // symbolic = new Symbolic_t;
-                symbolic.params = 0;
-                symbolic.actuals = 0;
-                symbolic.assertions = 0;
+                symbolic = new Symbolic_t;
+                symbolic->params = 0;
+                symbolic->actuals = 0;
+                symbolic->assertions = 0;
                 break;
           case Variable:
-                // variable = new Variable_t;
-                // variable.tyClass = DeclarationNode::Type;
-                // variable.assertions = 0;
+                variable = new Variable_t;
+                variable->tyClass = DeclarationNode::Type;
+                variable->assertions = 0;
                 break;
           case Tuple:
-                // tuple = new Tuple_t;
-                tuple = nullptr;
+                tuple = new Tuple_t;
+                tuple->members = 0;
                 break;
           case Typeof:
-                // typeexpr = new Typeof_t;
-                typeexpr = nullptr;
+                typeexpr = new Typeof_t;
+                typeexpr->expr = 0;
+                break;
+          case Builtin:
+                builtin = new Builtin_t;
                 break;
           case Attr:
-                // attr = new Attr_t;
-                // attr.expr = nullptr;
-                // attr.type = nullptr;
-                break;
-          case Builtin:
-                // builtin = new Builtin_t;
+                attr = new Attr_t;
+                attr->expr = 0;
+                attr->type = 0;
                 break;
         } // switch
@@ -107 +107 @@
                 break;
           case Basic:
-                // delete basic;
+                delete basic;
                 break;
           case Array:
-                delete array.dimension;
-                // delete array;
+                delete array->dimension;
+                delete array;
                 break;
           case Function:
-                delete function.params;
-                delete function.idList;
-                delete function.oldDeclList;
-                delete function.body;
-                // delete function;
+                delete function->params;
+                delete function->idList;
+                delete function->oldDeclList;
+                delete function->body;
+                delete function;
                 break;
           case Aggregate:
-                delete aggregate.params;
-                delete aggregate.actuals;
-                delete aggregate.fields;
-                // delete aggregate;
+                delete aggregate->params;
+                delete aggregate->actuals;
+                delete aggregate->fields;
+                delete aggregate;
                 break;
           case AggregateInst:
-                delete aggInst.aggregate;
-                delete aggInst.params;
-                // delete aggInst;
+                delete aggInst->aggregate;
+                delete aggInst->params;
+                delete aggInst;
                 break;
           case Enum:
-                delete enumeration.constants;
-                // delete enumeration;
+                delete enumeration->constants;
+                delete enumeration;
                 break;
           case Symbolic:
           case SymbolicInst:
-                delete symbolic.params;
-                delete symbolic.actuals;
-                delete symbolic.assertions;
-                // delete symbolic;
+                delete symbolic->params;
+                delete symbolic->actuals;
+                delete symbolic->assertions;
+                delete symbolic;
                 break;
           case Variable:
-                // delete variable.assertions;
-                // delete variable;
+                delete variable->assertions;
+                delete variable;
                 break;
           case Tuple:
-                // delete tuple->members;
+                delete tuple->members;
                 delete tuple;
                 break;
           case Typeof:
-                // delete typeexpr->expr;
+                delete typeexpr->expr;
                 delete typeexpr;
                 break;
+          case Builtin:
+                delete builtin;
+                break;
           case Attr:
-                // delete attr.expr;
-                // delete attr.type;
-                // delete attr;
-                break;
-          case Builtin:
-                // delete builtin;
+                delete attr->expr;
+                delete attr->type;
+                delete attr;
                 break;
         } // switch
@@ -178 +178 @@
                 break;
           case Basic:
-                newtype->basic.typeSpec = basic.typeSpec;
-                newtype->basic.modifiers = basic.modifiers;
+                newtype->basic->typeSpec = basic->typeSpec;
+                newtype->basic->modifiers = basic->modifiers;
                 break;
           case Array:
-                newtype->array.dimension = maybeClone( array.dimension );
-                newtype->array.isVarLen = array.isVarLen;
-                newtype->array.isStatic = array.isStatic;
+                newtype->array->dimension = maybeClone( array->dimension );
+                newtype->array->isVarLen = array->isVarLen;
+                newtype->array->isStatic = array->isStatic;
                 break;
           case Function:
-                newtype->function.params = maybeClone( function.params );
-                newtype->function.idList = maybeClone( function.idList );
-                newtype->function.oldDeclList = maybeClone( function.oldDeclList );
-                newtype->function.body = maybeClone( function.body );
-                newtype->function.hasBody = function.hasBody;
-                newtype->function.newStyle = function.newStyle;
+                newtype->function->params = maybeClone( function->params );
+                newtype->function->idList = maybeClone( function->idList );
+                newtype->function->oldDeclList = maybeClone( function->oldDeclList );
+                newtype->function->body = maybeClone( function->body );
+                newtype->function->hasBody = function->hasBody;
+                newtype->function->newStyle = function->newStyle;
                 break;
           case Aggregate:
-                newtype->aggregate.params = maybeClone( aggregate.params );
-                newtype->aggregate.actuals = maybeClone( aggregate.actuals );
-                newtype->aggregate.fields = maybeClone( aggregate.fields );
-                newtype->aggregate.name = aggregate.name;
-                newtype->aggregate.kind = aggregate.kind;
-                newtype->aggregate.body = aggregate.body;
+                newtype->aggregate->params = maybeClone( aggregate->params );
+                newtype->aggregate->actuals = maybeClone( aggregate->actuals );
+                newtype->aggregate->fields = maybeClone( aggregate->fields );
+                newtype->aggregate->name = aggregate->name;
+                newtype->aggregate->kind = aggregate->kind;
+                newtype->aggregate->body = aggregate->body;
                 break;
           case AggregateInst:
-                newtype->aggInst.aggregate = maybeClone( aggInst.aggregate );
-                newtype->aggInst.params = maybeClone( aggInst.params );
+                newtype->aggInst->aggregate = maybeClone( aggInst->aggregate );
+                newtype->aggInst->params = maybeClone( aggInst->params );
                 break;
           case Enum:
-                newtype->enumeration.name = enumeration.name;
-                newtype->enumeration.constants = maybeClone( enumeration.constants );
+                newtype->enumeration->name = enumeration->name;
+                newtype->enumeration->constants = maybeClone( enumeration->constants );
                 break;
           case Symbolic:
           case SymbolicInst:
-                newtype->symbolic.params = maybeClone( symbolic.params );
-                newtype->symbolic.actuals = maybeClone( symbolic.actuals );
-                newtype->symbolic.assertions = maybeClone( symbolic.assertions );
-                newtype->symbolic.isTypedef = symbolic.isTypedef;
-                newtype->symbolic.name = symbolic.name;
+                newtype->symbolic->params = maybeClone( symbolic->params );
+                newtype->symbolic->actuals = maybeClone( symbolic->actuals );
+                newtype->symbolic->assertions = maybeClone( symbolic->assertions );
+                newtype->symbolic->isTypedef = symbolic->isTypedef;
+                newtype->symbolic->name = symbolic->name;
                 break;
           case Variable:
-                assert( false );
-                // newtype->variable.assertions = maybeClone( variable.assertions );
-                // newtype->variable.name = variable.name;
-                // newtype->variable.tyClass = variable.tyClass;
+                newtype->variable->assertions = maybeClone( variable->assertions );
+                newtype->variable->name = variable->name;
+                newtype->variable->tyClass = variable->tyClass;
                 break;
           case Tuple:
-                newtype->tuple = maybeClone( tuple );
+                newtype->tuple->members = maybeClone( tuple->members );
                 break;
           case Typeof:
-                newtype->typeexpr = maybeClone( typeexpr );
+                newtype->typeexpr->expr = maybeClone( typeexpr->expr );
+                break;
+          case Builtin:
+                newtype->builtin->type = builtin->type;
                 break;
           case Attr:
-                assert( false );
-                // newtype->attr.expr = maybeClone( attr.expr );
-                // newtype->attr.type = maybeClone( attr.type );
-                break;
-          case Builtin:
-                assert( false );
-                // newtype->builtin = builtin;
+                newtype->attr->expr = maybeClone( attr->expr );
+                newtype->attr->type = maybeClone( attr->type );
                 break;
         } // switch
@@ -271 +268 @@
                 break;
           case Basic:
-                printEnums( basic.modifiers.begin(), basic.modifiers.end(), DeclarationNode::modifierName, os );
-                printEnums( basic.typeSpec.begin(), basic.typeSpec.end(), DeclarationNode::basicTypeName, os );
+                printEnums( basic->modifiers.begin(), basic->modifiers.end(), DeclarationNode::modifierName, os );
+                printEnums( basic->typeSpec.begin(), basic->typeSpec.end(), DeclarationNode::basicTypeName, os );
                 break;
           case Array:
-                if ( array.isStatic ) {
+                if ( array->isStatic ) {
                         os << "static ";
                 } // if
-                if ( array.dimension ) {
+                if ( array->dimension ) {
                         os << "array of ";
-                        array.dimension->printOneLine( os, indent );
-                } else if ( array.isVarLen ) {
+                        array->dimension->printOneLine( os, indent );
+                } else if ( array->isVarLen ) {
                         os << "variable-length array of ";
                 } else {
@@ -292 +289 @@
           case Function:
                 os << "function" << endl;
-                if ( function.params ) {
+                if ( function->params ) {
                         os << string( indent + 2, ' ' ) << "with parameters " << endl;
-                        function.params->printList( os, indent + 4 );
+                        function->params->printList( os, indent + 4 );
                 } else {
                         os << string( indent + 2, ' ' ) << "with no parameters " << endl;
                 } // if
-                if ( function.idList ) {
+                if ( function->idList ) {
                         os << string( indent + 2, ' ' ) << "with old-style identifier list " << endl;
-                        function.idList->printList( os, indent + 4 );
-                } // if
-                if ( function.oldDeclList ) {
+                        function->idList->printList( os, indent + 4 );
+                } // if
+                if ( function->oldDeclList ) {
                         os << string( indent + 2, ' ' ) << "with old-style declaration list " << endl;
-                        function.oldDeclList->printList( os, indent + 4 );
+                        function->oldDeclList->printList( os, indent + 4 );
                 } // if
                 os << string( indent + 2, ' ' ) << "returning ";
@@ -313 +310 @@
                 } // if
                 os << endl;
-                if ( function.hasBody ) {
+                if ( function->hasBody ) {
                         os << string( indent + 2, ' ' ) << "with body " << endl;
                 } // if
-                if ( function.body ) {
-                        function.body->printList( os, indent + 2 );
+                if ( function->body ) {
+                        function->body->printList( os, indent + 2 );
                 } // if
                 break;
           case Aggregate:
-                os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << aggregate.name << endl;
-                if ( aggregate.params ) {
+                os << DeclarationNode::aggregateName[ aggregate->kind ] << ' ' << aggregate->name << endl;
+                if ( aggregate->params ) {
                         os << string( indent + 2, ' ' ) << "with type parameters " << endl;
-                        aggregate.params->printList( os, indent + 4 );
-                } // if
-                if ( aggregate.actuals ) {
+                        aggregate->params->printList( os, indent + 4 );
+                } // if
+                if ( aggregate->actuals ) {
                         os << string( indent + 2, ' ' ) << "instantiated with actual parameters " << endl;
-                        aggregate.actuals->printList( os, indent + 4 );
-                } // if
-                if ( aggregate.fields ) {
+                        aggregate->actuals->printList( os, indent + 4 );
+                } // if
+                if ( aggregate->fields ) {
                         os << string( indent + 2, ' ' ) << "with members " << endl;
-                        aggregate.fields->printList( os, indent + 4 );
-                } // if
-                if ( aggregate.body ) {
+                        aggregate->fields->printList( os, indent + 4 );
+                } // if
+                if ( aggregate->body ) {
                         os << string( indent + 2, ' ' ) << " with body " << endl;
                 } // if
                 break;
           case AggregateInst:
-                if ( aggInst.aggregate ) {
+                if ( aggInst->aggregate ) {
                         os << "instance of " ;
-                        aggInst.aggregate->print( os, indent );
+                        aggInst->aggregate->print( os, indent );
                 } else {
                         os << "instance of an unspecified aggregate ";
                 } // if
-                if ( aggInst.params ) {
+                if ( aggInst->params ) {
                         os << string( indent + 2, ' ' ) << "with parameters " << endl;
-                        aggInst.params->printList( os, indent + 2 );
+                        aggInst->params->printList( os, indent + 2 );
                 } // if
                 break;
           case Enum:
                 os << "enumeration ";
-                if ( enumeration.constants ) {
+                if ( enumeration->constants ) {
                         os << "with constants" << endl;
-                        enumeration.constants->printList( os, indent + 2 );
+                        enumeration->constants->printList( os, indent + 2 );
                 } // if
                 break;
           case SymbolicInst:
-                os << "instance of type " << symbolic.name;
-                if ( symbolic.actuals ) {
+                os << "instance of type " << symbolic->name;
+                if ( symbolic->actuals ) {
                         os << " with parameters" << endl;
-                        symbolic.actuals->printList( os, indent + 2 );
+                        symbolic->actuals->printList( os, indent + 2 );
                 } // if
                 break;
           case Symbolic:
-                if ( symbolic.isTypedef ) {
+                if ( symbolic->isTypedef ) {
                         os << "typedef definition ";
                 } else {
                         os << "type definition ";
                 } // if
-                if ( symbolic.params ) {
+                if ( symbolic->params ) {
                         os << endl << string( indent + 2, ' ' ) << "with parameters" << endl;
-                        symbolic.params->printList( os, indent + 2 );
-                } // if
-                if ( symbolic.assertions ) {
+                        symbolic->params->printList( os, indent + 2 );
+                } // if
+                if ( symbolic->assertions ) {
                         os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;
-                        symbolic.assertions->printList( os, indent + 4 );
+                        symbolic->assertions->printList( os, indent + 4 );
                         os << string( indent + 2, ' ' );
                 } // if
@@ -385 +382 @@
                 break;
           case Variable:
-                // os << DeclarationNode::typeClassName[ variable.tyClass ] << " variable ";
-                // if ( variable.assertions ) {
-                //      os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;
-                //      variable.assertions->printList( os, indent + 4 );
-                //      os << string( indent + 2, ' ' );
-                // } // if
+                os << DeclarationNode::typeClassName[ variable->tyClass ] << " variable ";
+                if ( variable->assertions ) {
+                        os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;
+                        variable->assertions->printList( os, indent + 4 );
+                        os << string( indent + 2, ' ' );
+                } // if
                 break;
           case Tuple:
                 os << "tuple ";
-                if ( tuple ) {
+                if ( tuple->members ) {
                         os << "with members " << endl;
-                        tuple->printList( os, indent + 2 );
+                        tuple->members->printList( os, indent + 2 );
                 } // if
                 break;
           case Typeof:
                 os << "type-of expression ";
-                if ( typeexpr ) {
-                        typeexpr->print( os, indent + 2 );
+                if ( typeexpr->expr ) {
+                        typeexpr->expr->print( os, indent + 2 );
                 } // if
                 break;
           case Attr:
-                // os << "attribute type decl " << attr.name << " applied to ";
-                // if ( attr.expr ) {
-                //      attr.expr->print( os, indent + 2 );
-                // } // if
-                // if ( attr.type ) {
-                //      attr.type->print( os, indent + 2 );
-                // } // if
+                os << "attribute type decl " << attr->name << " applied to ";
+                if ( attr->expr ) {
+                        attr->expr->print( os, indent + 2 );
+                } // if
+                if ( attr->type ) {
+                        attr->type->print( os, indent + 2 );
+                } // if
                 break;
           case Builtin:
@@ -482 +479 @@
                 return new VarArgsType( buildQualifiers( td ) );
           case TypeData::Attr:
-                assert( false );
                 return buildAttr( td );
           case TypeData::Symbolic:
@@ -498 +494 @@
         switch ( td->kind ) {
           case TypeData::Aggregate:
-                if ( ! toplevel && td->aggregate.fields ) {
+                if ( ! toplevel && td->aggregate->fields ) {
                         ret = td->clone();
                 } // if
                 break;
           case TypeData::Enum:
-                if ( ! toplevel && td->enumeration.constants ) {
+                if ( ! toplevel && td->enumeration->constants ) {
                         ret = td->clone();
                 } // if
                 break;
           case TypeData::AggregateInst:
-                if ( td->aggInst.aggregate ) {
-                        ret = typeextractAggregate( td->aggInst.aggregate, false );
+                if ( td->aggInst->aggregate ) {
+                        ret = typeextractAggregate( td->aggInst->aggregate, false );
                 } // if
                 break;
@@ -539 +535 @@
         BasicType::Kind ret;
 
-        for ( std::list< DeclarationNode::BasicType >::const_iterator i = td->basic.typeSpec.begin(); i != td->basic.typeSpec.end(); ++i ) {
+        for ( std::list< DeclarationNode::BasicType >::const_iterator i = td->basic->typeSpec.begin(); i != td->basic->typeSpec.end(); ++i ) {
                 if ( ! init ) {
                         init = true;
                         if ( *i == DeclarationNode::Void ) {
-                                if ( td->basic.typeSpec.size() != 1 || ! td->basic.modifiers.empty() ) {
+                                if ( td->basic->typeSpec.size() != 1 || ! td->basic->modifiers.empty() ) {
                                         throw SemanticError( "invalid type specifier \"void\" in type: ", td );
                                 } else {
@@ -615 +611 @@
         } // for
 
-        for ( std::list< DeclarationNode::Modifier >::const_iterator i = td->basic.modifiers.begin(); i != td->basic.modifiers.end(); ++i ) {
+        for ( std::list< DeclarationNode::Modifier >::const_iterator i = td->basic->modifiers.begin(); i != td->basic->modifiers.end(); ++i ) {
                 switch ( *i ) {
                   case DeclarationNode::Long:
@@ -750 +746 @@
         ArrayType * at;
         if ( td->base ) {
-                at = new ArrayType( buildQualifiers( td ), typebuild( td->base ), maybeBuild< Expression >( td->array.dimension ),
-                                                        td->array.isVarLen, td->array.isStatic );
+                at = new ArrayType( buildQualifiers( td ), typebuild( td->base ), maybeBuild< Expression >( td->array->dimension ),
+                                                        td->array->isVarLen, td->array->isStatic );
         } else {
                 at = new ArrayType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ),
-                                                        maybeBuild< Expression >( td->array.dimension ), td->array.isVarLen, td->array.isStatic );
+                                                        maybeBuild< Expression >( td->array->dimension ), td->array->isVarLen, td->array->isStatic );
         } // if
         buildForall( td->forall, at->get_forall() );
@@ -763 +759 @@
         assert( td->kind == TypeData::Aggregate );
         AggregateDecl * at;
-        switch ( td->aggregate.kind ) {
+        switch ( td->aggregate->kind ) {
           case DeclarationNode::Struct:
-                at = new StructDecl( td->aggregate.name );
-                buildForall( td->aggregate.params, at->get_parameters() );
+                at = new StructDecl( td->aggregate->name );
+                buildForall( td->aggregate->params, at->get_parameters() );
                 break;
           case DeclarationNode::Union:
-                at = new UnionDecl( td->aggregate.name );
-                buildForall( td->aggregate.params, at->get_parameters() );
+                at = new UnionDecl( td->aggregate->name );
+                buildForall( td->aggregate->params, at->get_parameters() );
                 break;
           case DeclarationNode::Trait:
-                at = new TraitDecl( td->aggregate.name );
-                buildList( td->aggregate.params, at->get_parameters() );
+                at = new TraitDecl( td->aggregate->name );
+                buildList( td->aggregate->params, at->get_parameters() );
                 break;
           default:
@@ -780 +776 @@
         } // switch
 
-        buildList( td->aggregate.fields, at->get_members() );
-        at->set_body( td->aggregate.body );
+        buildList( td->aggregate->fields, at->get_members() );
+        at->set_body( td->aggregate->body );
 
         return at;
@@ -790 +786 @@
 
         ReferenceToType * ret;
-        if ( td->aggInst.aggregate->kind == TypeData::Enum ) {
-                ret = new EnumInstType( buildQualifiers( td ), td->aggInst.aggregate->enumeration.name );
+        if ( td->aggInst->aggregate->kind == TypeData::Enum ) {
+                ret = new EnumInstType( buildQualifiers( td ), td->aggInst->aggregate->enumeration->name );
         } else {
-                assert( td->aggInst.aggregate->kind == TypeData::Aggregate );
-                switch ( td->aggInst.aggregate->aggregate.kind ) {
+                assert( td->aggInst->aggregate->kind == TypeData::Aggregate );
+                switch ( td->aggInst->aggregate->aggregate->kind ) {
                   case DeclarationNode::Struct:
-                        ret = new StructInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
+                        ret = new StructInstType( buildQualifiers( td ), td->aggInst->aggregate->aggregate->name );
                         break;
                   case DeclarationNode::Union:
-                        ret = new UnionInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
+                        ret = new UnionInstType( buildQualifiers( td ), td->aggInst->aggregate->aggregate->name );
                         break;
                   case DeclarationNode::Trait:
-                        ret = new TraitInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
+                        ret = new TraitInstType( buildQualifiers( td ), td->aggInst->aggregate->aggregate->name );
                         break;
                   default:
@@ -808 +804 @@
                 } // switch
         } // if
-        buildList( td->aggInst.params, ret->get_parameters() );
+        buildList( td->aggInst->params, ret->get_parameters() );
         buildForall( td->forall, ret->get_forall() );
         return ret;
@@ -817 +813 @@
         NamedTypeDecl * ret;
         assert( td->base );
-        if ( td->symbolic.isTypedef ) {
+        if ( td->symbolic->isTypedef ) {
                 ret = new TypedefDecl( name, sc, typebuild( td->base ) );
         } else {
                 ret = new TypeDecl( name, sc, typebuild( td->base ), TypeDecl::Any );
         } // if
-        buildList( td->symbolic.params, ret->get_parameters() );
-        buildList( td->symbolic.assertions, ret->get_assertions() );
+        buildList( td->symbolic->params, ret->get_parameters() );
+        buildList( td->symbolic->assertions, ret->get_assertions() );
         return ret;
 } // buildSymbolic
 
 TypeDecl * buildVariable( const TypeData * td ) {
-        assert( false );
-        return nullptr;
-        // assert( td->kind == TypeData::Variable );
-        // static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
-
-        // TypeDecl * ret = new TypeDecl( td->variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ td->variable.tyClass ] );
-        // buildList( td->variable.assertions, ret->get_assertions() );
-        // return ret;
+        assert( td->kind == TypeData::Variable );
+        static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
+
+        TypeDecl * ret = new TypeDecl( td->variable->name, DeclarationNode::NoStorageClass, 0, kindMap[ td->variable->tyClass ] );
+        buildList( td->variable->assertions, ret->get_assertions() );
+        return ret;
 } // buildSymbolic
 
 EnumDecl * buildEnum( const TypeData * td ) {
         assert( td->kind == TypeData::Enum );
-        EnumDecl * ret = new EnumDecl( td->enumeration.name );
-        buildList( td->enumeration.constants, ret->get_members() );
+        EnumDecl * ret = new EnumDecl( td->enumeration->name );
+        buildList( td->enumeration->constants, ret->get_members() );
         std::list< Declaration * >::iterator members = ret->get_members().begin();
-        for ( const DeclarationNode * cur = td->enumeration. constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
+        for ( const DeclarationNode * cur = td->enumeration-> constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
                 if ( cur->has_enumeratorValue() ) {
                         ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
@@ -854 +848 @@
 TypeInstType * buildSymbolicInst( const TypeData * td ) {
         assert( td->kind == TypeData::SymbolicInst );
-        TypeInstType * ret = new TypeInstType( buildQualifiers( td ), td->symbolic.name, false );
-        buildList( td->symbolic.actuals, ret->get_parameters() );
+        TypeInstType * ret = new TypeInstType( buildQualifiers( td ), td->symbolic->name, false );
+        buildList( td->symbolic->actuals, ret->get_parameters() );
         buildForall( td->forall, ret->get_forall() );
         return ret;
@@ -863 +857 @@
         assert( td->kind == TypeData::Tuple );
         TupleType * ret = new TupleType( buildQualifiers( td ) );
-        buildTypeList( td->tuple, ret->get_types() );
+        buildTypeList( td->tuple->members, ret->get_types() );
         buildForall( td->forall, ret->get_forall() );
         return ret;
@@ -871 +865 @@
         assert( td->kind == TypeData::Typeof );
         assert( td->typeexpr );
-        // assert( td->typeexpr->expr );
-        return new TypeofType( buildQualifiers( td ), td->typeexpr->build() );
+        assert( td->typeexpr->expr );
+        return new TypeofType( buildQualifiers( td ), td->typeexpr->expr->build() );
 } // buildTypeof
 
 AttrType * buildAttr( const TypeData * td ) {
-        assert( false );
-        return nullptr;
-        // assert( td->kind == TypeData::Attr );
-        // // assert( td->attr );
-        // AttrType * ret;
-        // if ( td->attr.expr ) {
-        //      ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.expr->build() );
-        // } else {
-        //      assert( td->attr.type );
-        //      ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.type->buildType() );
-        // } // if
-        // return ret;
+        assert( td->kind == TypeData::Attr );
+        assert( td->attr );
+        AttrType * ret;
+        if ( td->attr->expr ) {
+                ret = new AttrType( buildQualifiers( td ), td->attr->name, td->attr->expr->build() );
+        } else {
+                assert( td->attr->type );
+                ret = new AttrType( buildQualifiers( td ), td->attr->name, td->attr->type->buildType() );
+        } // if
+        return ret;
 } // buildAttr
 
@@ -893 +885 @@
         if ( td->kind == TypeData::Function ) {
                 FunctionDecl * decl;
-                if ( td->function.hasBody ) {
-                        if ( td->function.body ) {
-                                Statement * stmt = td->function.body->build();
+                if ( td->function->hasBody ) {
+                        if ( td->function->body ) {
+                                Statement * stmt = td->function->body->build();
                                 CompoundStmt * body = dynamic_cast< CompoundStmt* >( stmt );
                                 assert( body );
@@ -906 +898 @@
                         decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), 0, isInline, isNoreturn );
                 } // if
-                for ( DeclarationNode * cur = td->function.idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {
+                for ( DeclarationNode * cur = td->function->idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {
                         if ( cur->get_name() != "" ) {
                                 decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() );
                         } // if
                 } // for
-                buildList( td->function.oldDeclList, decl->get_oldDecls() );
+                buildList( td->function->oldDeclList, decl->get_oldDecls() );
                 return decl;
         } else if ( td->kind == TypeData::Aggregate ) {
@@ -920 +912 @@
                 return buildSymbolic( td, name, sc );
         } else if ( td->kind == TypeData::Variable ) {
-                assert( false );
                 return buildVariable( td );
         } else {
@@ -930 +921 @@
 FunctionType * buildFunction( const TypeData * td ) {
         assert( td->kind == TypeData::Function );
-        bool hasEllipsis = td->function.params ? td->function.params->get_hasEllipsis() : true;
-        if ( ! td->function.params ) hasEllipsis = ! td->function.newStyle;
+        bool hasEllipsis = td->function->params ? td->function->params->get_hasEllipsis() : true;
+        if ( ! td->function->params ) hasEllipsis = ! td->function->newStyle;
         FunctionType * ft = new FunctionType( buildQualifiers( td ), hasEllipsis );
-        buildList( td->function.params, ft->get_parameters() );
+        buildList( td->function->params, ft->get_parameters() );
         buildForall( td->forall, ft->get_forall() );
         if ( td->base ) {
                 switch ( td->base->kind ) {
                   case TypeData::Tuple:
-                        buildList( td->base->tuple, ft->get_returnVals() );
+                        buildList( td->base->tuple->members, ft->get_returnVals() );
                         break;
                   default:

src/Parser/TypeData.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 29 22:31:52 2016
-// Update Count     : 110
+// Last Modified On : Sun Aug 28 22:39:00 2016
+// Update Count     : 85
 //
 
@@ -24 +24 @@
 struct TypeData {
         enum Kind { Unknown, Basic, Pointer, Array, Function, Aggregate, AggregateInst,
-                                Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr };
+                                Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr } kind;
 
         struct Basic_t {
@@ -73 +73 @@
         };
 
-        // struct Tuple_t {
-        //      DeclarationNode * members;
-        // };
+        struct Variable_t {
+                DeclarationNode::TypeClass tyClass;
+                std::string name;
+                DeclarationNode * assertions;
+        };
+
+        struct Tuple_t {
+                DeclarationNode * members;
+        };
   
-        // struct Typeof_t {
-        //      ExpressionNode * expr;
-        // };
+        struct Typeof_t {
+                ExpressionNode * expr;
+        };
 
-        // struct Builtin_t {
-        //      DeclarationNode::BuiltinType type;
-        // };
+        struct Builtin_t {
+                DeclarationNode::BuiltinType type;
+        };
 
-        Kind kind;
+        struct Attr_t {
+                std::string name;
+                ExpressionNode * expr;
+                DeclarationNode * type;
+        };
+
         TypeData * base;
         typedef std::bitset< DeclarationNode::NoOfQualifier > Qualifiers;
@@ -91 +102 @@
         DeclarationNode * forall;
 
-                Basic_t basic;
-                Aggregate_t aggregate;
-                AggInst_t aggInst;
-                Array_t array;
-                Enumeration_t enumeration;
-                Function_t function;
-                Symbolic_t symbolic;
-                DeclarationNode * tuple;
-                ExpressionNode * typeexpr;
-                //Attr_t attr;
-                // DeclarationNode::BuiltinType builtin;
+        union {
+                Basic_t * basic;
+                Aggregate_t * aggregate;
+                AggInst_t * aggInst;
+                Array_t * array;
+                Enumeration_t * enumeration;
+                Function_t * function;
+                Symbolic_t * symbolic;
+                Variable_t * variable;
+                Tuple_t * tuple;
+                Typeof_t * typeexpr;
+                Attr_t * attr;
+                Builtin_t * builtin;
+        };
 
         TypeData( Kind k = Unknown );

src/ResolvExpr/AlternativeFinder.cc

@@ -42 +42 @@
 #include "Common/utility.h"
 #include "InitTweak/InitTweak.h"
-#include "ResolveTypeof.h"
 
 extern bool resolvep;
@@ -708 +707 @@
         void AlternativeFinder::visit( CastExpr *castExpr ) {
                 for ( std::list< Type* >::iterator i = castExpr->get_results().begin(); i != castExpr->get_results().end(); ++i ) {
-                        *i = resolveTypeof( *i, indexer );
                         SymTab::validateType( *i, &indexer );
                         adjustExprType( *i, env, indexer );
@@ -797 +795 @@
 
         void AlternativeFinder::visit( VariableExpr *variableExpr ) {
-                // not sufficient to clone here, because variable's type may have changed
-                // since the VariableExpr was originally created.
-                alternatives.push_back( Alternative( new VariableExpr( variableExpr->get_var() ), env, Cost::zero ) );
+                alternatives.push_back( Alternative( variableExpr->clone(), env, Cost::zero ) );
         }
 
@@ -808 +804 @@
         void AlternativeFinder::visit( SizeofExpr *sizeofExpr ) {
                 if ( sizeofExpr->get_isType() ) {
-                        // xxx - resolveTypeof?
                         alternatives.push_back( Alternative( sizeofExpr->clone(), env, Cost::zero ) );
                 } else {
@@ -828 +823 @@
         void AlternativeFinder::visit( AlignofExpr *alignofExpr ) {
                 if ( alignofExpr->get_isType() ) {
-                        // xxx - resolveTypeof?
                         alternatives.push_back( Alternative( alignofExpr->clone(), env, Cost::zero ) );
                 } else {
@@ -862 +856 @@
         void AlternativeFinder::visit( UntypedOffsetofExpr *offsetofExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
-                // xxx - resolveTypeof?
                 if ( StructInstType *structInst = dynamic_cast< StructInstType* >( offsetofExpr->get_type() ) ) {
                         addOffsetof( structInst, offsetofExpr->get_member() );

src/ResolvExpr/Resolver.cc

@@ -528 +528 @@
 
         void Resolver::visit( ConstructorInit *ctorInit ) {
-                // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
-                maybeAccept( ctorInit->get_ctor(), *this );
-                maybeAccept( ctorInit->get_dtor(), *this );
+                try {
+                        maybeAccept( ctorInit->get_ctor(), *this );
+                        maybeAccept( ctorInit->get_dtor(), *this );
+                } catch ( SemanticError ) {
+                        // no alternatives for the constructor initializer - fallback on C-style initializer
+                        // xxx - not sure if this makes a ton of sense - should maybe never be able to have this situation?
+                        fallbackInit( ctorInit );
+                        return;
+                }
 
                 // found a constructor - can get rid of C-style initializer

src/SymTab/Autogen.h

@@ -102 +102 @@
                 }
 
-                ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
+                ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), NULL );
+
+                UntypedExpr *init = new UntypedExpr( new NameExpr( "?=?" ) );
+                init->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+                init->get_args().push_back( begin );
+                index->set_init( new SingleInit( init, std::list<Expression*>() ) );
 
                 UntypedExpr *cond = new UntypedExpr( cmp );

src/SymTab/Indexer.cc

@@ -21 +21 @@
 #include <unordered_set>
 #include <utility>
-#include <algorithm>
 
 #include "Mangler.h"
@@ -34 +33 @@
 #include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
-
-#include "InitTweak/InitTweak.h"
 
 #define debugPrint(x) if ( doDebug ) { std::cout << x; }
@@ -104 +101 @@
         }
 
-        void Indexer::removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const {
-                // only need to perform this step for constructors and destructors
-                if ( ! InitTweak::isCtorDtor( id ) ) return;
-
-                // helpful data structure
-                struct ValueType {
-                        struct DeclBall {
-                                FunctionDecl * decl;
-                                bool isUserDefinedFunc; // properties for this particular decl
-                                bool isDefaultFunc;
-                                bool isCopyFunc;
-                        };
-                        // properties for this type
-                        bool userDefinedFunc = false; // any user defined function found
-                        bool userDefinedDefaultFunc = false; // user defined default ctor found
-                        bool userDefinedCopyFunc = false; // user defined copy ctor found
-                        std::list< DeclBall > decls;
-
-                        // another FunctionDecl for the current type was found - determine
-                        // if it has special properties and update data structure accordingly
-                        ValueType & operator+=( FunctionDecl * function ) {
-                                bool isUserDefinedFunc = ! LinkageSpec::isOverridable( function->get_linkage() );
-                                bool isDefaultFunc = function->get_functionType()->get_parameters().size() == 1;
-                                bool isCopyFunc = InitTweak::isCopyConstructor( function );
-                                decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultFunc, isCopyFunc } );
-                                userDefinedFunc = userDefinedFunc || isUserDefinedFunc;
-                                userDefinedDefaultFunc = userDefinedDefaultFunc || (isUserDefinedFunc && isDefaultFunc);
-                                userDefinedCopyFunc = userDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
-                                return *this;
-                        }
-                }; // ValueType
-
-                std::list< DeclarationWithType * > copy;
-                copy.splice( copy.end(), out );
-
-                // organize discovered declarations by type
-                std::unordered_map< std::string, ValueType > funcMap;
-                for ( DeclarationWithType * decl : copy ) {
-                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl ) ) {
-                                std::list< DeclarationWithType * > params = function->get_functionType()->get_parameters();
-                                assert( ! params.empty() );
-                                funcMap[ Mangler::mangle( params.front()->get_type() ) ] += function;
-                        } else {
-                                out.push_back( decl );
-                        }
-                }
-
-                // if a type contains user defined ctor/dtors, then special rules trigger, which determine
-                // the set of ctor/dtors that are seen by the requester. In particular, if the user defines
-                // a default ctor, then the generated default ctor should never be seen, likewise for copy ctor
-                // and dtor. If the user defines any ctor/dtor, then no generated field ctors should be seen.
-                for ( std::pair< const std::string, ValueType > & pair : funcMap ) {
-                        ValueType & val = pair.second;
-                        for ( ValueType::DeclBall ball : val.decls ) {
-                                if ( ! val.userDefinedFunc || ball.isUserDefinedFunc || (! val.userDefinedDefaultFunc && ball.isDefaultFunc) || (! val.userDefinedCopyFunc && ball.isCopyFunc) ) {
-                                        // decl conforms to the rules described above, so it should be seen by the requester
-                                        out.push_back( ball.decl );
-                                }
-                        }
-                }
-        }
-
         void Indexer::makeWritable() {
                 if ( ! tables ) {
@@ -526 +461 @@
                         searchTables = searchTables->base.tables;
                 }
-
-                // some special functions, e.g. constructors and destructors
-                // remove autogenerated functions when they are defined so that
-                // they can never be matched
-                removeSpecialOverrides( id, out );
         }
 

src/SymTab/Indexer.h

@@ -128 +128 @@
                 static void deleteRef( Impl *toFree );
 
-                // Removes matching autogenerated constructors and destructors
-                // so that they will not be selected
-                // void removeSpecialOverrides( FunctionDecl *decl );
-                void removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const;
-
                 /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope)
                 void makeWritable();

src/SynTree/Declaration.cc

@@ -56 +56 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Declaration * decl ) {
+std::ostream & operator<<( std::ostream & out, Declaration * decl ) {
         decl->print( out );
         return out;

src/SynTree/Declaration.h

@@ -279 +279 @@
 };
 
-std::ostream & operator<<( std::ostream & out, const Declaration * decl );
+std::ostream & operator<<( std::ostream & out, Declaration * decl );
 
 #endif // DECLARATION_H

src/SynTree/Expression.cc

@@ -358 +358 @@
         assert( member );
         os << std::string( indent + 2, ' ' );
+        os << (void*)member << " ";
         member->print( os, indent + 2 );
         os << std::endl;
@@ -540 +541 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
+std::ostream & operator<<( std::ostream & out, Expression * expr ) {
         expr->print( out );
         return out;

src/SynTree/Expression.h

@@ -653 +653 @@
 };
 
-std::ostream & operator<<( std::ostream & out, const Expression * expr );
+std::ostream & operator<<( std::ostream & out, Expression * expr );
 
 #endif // EXPRESSION_H

src/SynTree/FunctionDecl.cc

@@ -21 +21 @@
 #include "Attribute.h"
 #include "Common/utility.h"
-#include "InitTweak/InitTweak.h"
 
 FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, std::list< Attribute * > attributes )

src/SynTree/Statement.cc

@@ -387 +387 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Statement * statement ) {
+std::ostream & operator<<( std::ostream & out, Statement * statement ) {
         statement->print( out );
         return out;

src/SynTree/Statement.h

@@ -47 +47 @@
 
         std::list<Statement*>& get_kids() { return kids; }
-        void push_back( Statement * stmt ) { kids.push_back( stmt ); }
-        void push_front( Statement * stmt ) { kids.push_front( stmt ); }
 
         virtual CompoundStmt *clone() const { return new CompoundStmt( *this ); }
@@ -397 +395 @@
 
 
-std::ostream & operator<<( std::ostream & out, const Statement * statement );
+std::ostream & operator<<( std::ostream & out, Statement * statement );
 
 #endif // STATEMENT_H

src/SynTree/Type.cc

@@ -84 +84 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Type * type ) {
+std::ostream & operator<<( std::ostream & out, Type * type ) {
         type->print( out );
         return out;

src/SynTree/Type.h

@@ -481 +481 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Type * type );
+std::ostream & operator<<( std::ostream & out, Type * type );
 
 #endif // TYPE_H

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 29 17:34:39 2016
-// Update Count     : 426
+// Last Modified On : Sat Aug 20 12:52:22 2016
+// Update Count     : 403
 //
 
@@ -75 +75 @@
 static void dump( list< Declaration * > & translationUnit, ostream & out = cout );
 
-void backtrace( int start ) {                                                   // skip first N stack frames
+void sigSegvBusHandler( int sig_num ) {
         enum { Frames = 50 };
         void * array[Frames];
         int size = backtrace( array, Frames );
+
+        cerr << "*CFA runtime error* program cfa-cpp terminated with "
+                 <<     (sig_num == SIGSEGV ? "segment fault" : "bus error")
+                 << " backtrace:" << endl;
+
         char ** messages = backtrace_symbols( array, size );
 
-        // skip last 2 stack frames after main
-        for ( int i = start; i < size - 2 && messages != nullptr; i += 1 ) {
+        // skip first stack frame (points here)
+        for ( int i = 2; i < size - 2 && messages != nullptr; i += 1 ) {
                 char * mangled_name = nullptr, * offset_begin = nullptr, * offset_end = nullptr;
                 for ( char *p = messages[i]; *p; ++p ) {        // find parantheses and +offset
@@ -96 +101 @@
 
                 // if line contains symbol, attempt to demangle
-                int frameNo = i - start;
                 if ( mangled_name && offset_begin && offset_end && mangled_name < offset_begin ) {
                         *mangled_name++ = '\0';
@@ -102 +106 @@
                         *offset_end++ = '\0';
 
-                        int status, frameNo = i - start;
+                        int status;
                         char * real_name = __cxxabiv1::__cxa_demangle( mangled_name, 0, 0, &status );
                         if ( status == 0 ) {                                            // demangling successful ?
-                                cerr << "(" << frameNo << ") " << messages[i] << " : "
+                                cerr << "(" << i - 2 << ") " << messages[i] << " : "
                                          << real_name << "+" << offset_begin << offset_end << endl;
 
                         } else {                                                                        // otherwise, output mangled name
-                                cerr << "(" << frameNo << ") " << messages[i] << " : "
+                                cerr << "(" << i - 2 << ") " << messages[i] << " : "
                                          << mangled_name << "+" << offset_begin << offset_end << endl;
                         } // if
                         free( real_name );
                 } else {                                                                                // otherwise, print the whole line
-                        cerr << "(" << frameNo << ") " << messages[i] << endl;
+                        cerr << "(" << i - 2 << ") " << messages[i] << endl;
                 } // if
         } // for
-
         free( messages );
-} // backtrace
-
-void sigSegvBusHandler( int sig_num ) {
-        cerr << "*CFA runtime error* program cfa-cpp terminated with "
-                 <<     (sig_num == SIGSEGV ? "segment fault" : "bus error")
-                 << " backtrace:" << endl;
-        backtrace( 2 );                                                                         // skip first 2 stack frames
         exit( EXIT_FAILURE );
 } // sigSegvBusHandler
-
-void sigAbortHandler( int sig_num ) {
-        backtrace( 6 );                                                                         // skip first 6 stack frames
-        signal( SIGABRT, SIG_DFL);                                                      // reset default signal handler
-    raise( SIGABRT );                                                                   // reraise SIGABRT
-} // sigAbortHandler
-
 
 int main( int argc, char * argv[] ) {
@@ -144 +133 @@
         signal( SIGSEGV, sigSegvBusHandler );
         signal( SIGBUS, sigSegvBusHandler );
-        signal( SIGABRT, sigAbortHandler );
 
         parse_cmdline( argc, argv, filename );                          // process command-line arguments

src/tests/.expect/32/declarationSpecifier.txt

@@ -530 +530 @@
     return ((int )_retVal0);
 }
+__attribute__ ((constructor(),)) static void _init_declarationSpecifier(void){
+    ((void)___constructor__F_P13s__anonymous0_autogen___1(((struct __anonymous0 *)(&__x10__CV13s__anonymous0_1))));
+    ((void)___constructor__F_P13s__anonymous1_autogen___1(((struct __anonymous1 *)(&__x11__CV13s__anonymous1_1))));
+    ((void)___constructor__F_P13s__anonymous2_autogen___1(((struct __anonymous2 *)(&__x12__CV13s__anonymous2_1))));
+    ((void)___constructor__F_P13s__anonymous3_autogen___1(((struct __anonymous3 *)(&__x13__CV13s__anonymous3_1))));
+    ((void)___constructor__F_P13s__anonymous4_autogen___1(((struct __anonymous4 *)(&__x14__CV13s__anonymous4_1))));
+    ((void)___constructor__F_P13s__anonymous5_autogen___1(((struct __anonymous5 *)(&__x15__CV13s__anonymous5_1))));
+    ((void)___constructor__F_P13s__anonymous6_autogen___1(((struct __anonymous6 *)(&__x16__CV13s__anonymous6_1))));
+    ((void)___constructor__F_P13s__anonymous7_autogen___1(((struct __anonymous7 *)(&__x17__CV13s__anonymous7_1))));
+    ((void)___constructor__F_P13s__anonymous8_autogen___1(((struct __anonymous8 *)(&__x29__CV13s__anonymous8_1))));
+    ((void)___constructor__F_P13s__anonymous9_autogen___1(((struct __anonymous9 *)(&__x30__CV13s__anonymous9_1))));
+    ((void)___constructor__F_P14s__anonymous10_autogen___1(((struct __anonymous10 *)(&__x31__CV14s__anonymous10_1))));
+    ((void)___constructor__F_P14s__anonymous11_autogen___1(((struct __anonymous11 *)(&__x32__CV14s__anonymous11_1))));
+    ((void)___constructor__F_P14s__anonymous12_autogen___1(((struct __anonymous12 *)(&__x33__CV14s__anonymous12_1))));
+    ((void)___constructor__F_P14s__anonymous13_autogen___1(((struct __anonymous13 *)(&__x34__CV14s__anonymous13_1))));
+    ((void)___constructor__F_P14s__anonymous14_autogen___1(((struct __anonymous14 *)(&__x35__CV14s__anonymous14_1))));
+    ((void)___constructor__F_P14s__anonymous15_autogen___1(((struct __anonymous15 *)(&__x36__CV14s__anonymous15_1))));
+}
+__attribute__ ((destructor(),)) static void _destroy_declarationSpecifier(void){
+    ((void)___destructor__F_P14s__anonymous15_autogen___1(((struct __anonymous15 *)(&__x36__CV14s__anonymous15_1))));
+    ((void)___destructor__F_P14s__anonymous14_autogen___1(((struct __anonymous14 *)(&__x35__CV14s__anonymous14_1))));
+    ((void)___destructor__F_P14s__anonymous13_autogen___1(((struct __anonymous13 *)(&__x34__CV14s__anonymous13_1))));
+    ((void)___destructor__F_P14s__anonymous12_autogen___1(((struct __anonymous12 *)(&__x33__CV14s__anonymous12_1))));
+    ((void)___destructor__F_P14s__anonymous11_autogen___1(((struct __anonymous11 *)(&__x32__CV14s__anonymous11_1))));
+    ((void)___destructor__F_P14s__anonymous10_autogen___1(((struct __anonymous10 *)(&__x31__CV14s__anonymous10_1))));
+    ((void)___destructor__F_P13s__anonymous9_autogen___1(((struct __anonymous9 *)(&__x30__CV13s__anonymous9_1))));
+    ((void)___destructor__F_P13s__anonymous8_autogen___1(((struct __anonymous8 *)(&__x29__CV13s__anonymous8_1))));
+    ((void)___destructor__F_P13s__anonymous7_autogen___1(((struct __anonymous7 *)(&__x17__CV13s__anonymous7_1))));
+    ((void)___destructor__F_P13s__anonymous6_autogen___1(((struct __anonymous6 *)(&__x16__CV13s__anonymous6_1))));
+    ((void)___destructor__F_P13s__anonymous5_autogen___1(((struct __anonymous5 *)(&__x15__CV13s__anonymous5_1))));
+    ((void)___destructor__F_P13s__anonymous4_autogen___1(((struct __anonymous4 *)(&__x14__CV13s__anonymous4_1))));
+    ((void)___destructor__F_P13s__anonymous3_autogen___1(((struct __anonymous3 *)(&__x13__CV13s__anonymous3_1))));
+    ((void)___destructor__F_P13s__anonymous2_autogen___1(((struct __anonymous2 *)(&__x12__CV13s__anonymous2_1))));
+    ((void)___destructor__F_P13s__anonymous1_autogen___1(((struct __anonymous1 *)(&__x11__CV13s__anonymous1_1))));
+    ((void)___destructor__F_P13s__anonymous0_autogen___1(((struct __anonymous0 *)(&__x10__CV13s__anonymous0_1))));
+}

src/tests/.expect/32/extension.txt

@@ -86 +86 @@
         __extension__ int __c__i_2;
     };
-    int __i__i_2 = ((int )(__extension__ __a__i_1+__extension__ 3));
+    int __i__i_2;
+    ((void)((*((int *)(&__i__i_2)))=(__extension__ __a__i_1+__extension__ 3)) /* ?{} */);
     ((void)__extension__ 3);
     ((void)__extension__ __a__i_1);

src/tests/.expect/32/gccExtensions.txt

@@ -76 +76 @@
         ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))=__c__i_2) /* ?{} */);
     }
-    int __i__i_2 = ((int )__extension__ 3);
+    int __i__i_2;
+    ((void)((*((int *)(&__i__i_2)))=__extension__ 3) /* ?{} */);
     __extension__ int __a__i_2;
     __extension__ int __b__i_2;
@@ -132 +133 @@
     }
     struct s3 __x1__3ss3_2;
+    ((void)___constructor__F_P3ss3_autogen___2(((struct s3 *)(&__x1__3ss3_2))));
     struct s3 __y1__3ss3_2;
+    ((void)___constructor__F_P3ss3_autogen___2(((struct s3 *)(&__y1__3ss3_2))));
     struct s4 {
         int __i__i_2;
@@ -138 +141 @@
     inline struct s4 ___operator_assign__F3ss4_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){
         ((void)((*___dst__P3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
+        ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__y1__3ss3_2))));
+        ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__x1__3ss3_2))));
         return ((struct s4 )___src__3ss4_2);
     }
@@ -153 +158 @@
     }
     struct s4 __x2__3ss4_2;
+    ((void)___constructor__F_P3ss4_autogen___2(((struct s4 *)(&__x2__3ss4_2))));
     struct s4 __y2__3ss4_2;
+    ((void)___constructor__F_P3ss4_autogen___2(((struct s4 *)(&__y2__3ss4_2))));
     int __m1__A0i_2[((unsigned int )10)];
     int __m2__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
@@ -159 +166 @@
     int _retVal0 = { 0 };
     ((void)(_retVal0=0) /* ?{} */);
+    ((void)___destructor__F_P3ss4_autogen___2(((struct s4 *)(&__y2__3ss4_2))));
+    ((void)___destructor__F_P3ss4_autogen___2(((struct s4 *)(&__x2__3ss4_2))));
+    ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__y1__3ss3_2))));
+    ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__x1__3ss3_2))));
     return ((int )_retVal0);
+    ((void)___destructor__F_P3ss4_autogen___2(((struct s4 *)(&__y2__3ss4_2))));
+    ((void)___destructor__F_P3ss4_autogen___2(((struct s4 *)(&__x2__3ss4_2))));
+    ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__y1__3ss3_2))));
+    ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__x1__3ss3_2))));
 }

src/tests/.expect/64/declarationSpecifier.txt

@@ -530 +530 @@
     return ((int )_retVal0);
 }
+__attribute__ ((constructor(),)) static void _init_declarationSpecifier(void){
+    ((void)___constructor__F_P13s__anonymous0_autogen___1(((struct __anonymous0 *)(&__x10__CV13s__anonymous0_1))));
+    ((void)___constructor__F_P13s__anonymous1_autogen___1(((struct __anonymous1 *)(&__x11__CV13s__anonymous1_1))));
+    ((void)___constructor__F_P13s__anonymous2_autogen___1(((struct __anonymous2 *)(&__x12__CV13s__anonymous2_1))));
+    ((void)___constructor__F_P13s__anonymous3_autogen___1(((struct __anonymous3 *)(&__x13__CV13s__anonymous3_1))));
+    ((void)___constructor__F_P13s__anonymous4_autogen___1(((struct __anonymous4 *)(&__x14__CV13s__anonymous4_1))));
+    ((void)___constructor__F_P13s__anonymous5_autogen___1(((struct __anonymous5 *)(&__x15__CV13s__anonymous5_1))));
+    ((void)___constructor__F_P13s__anonymous6_autogen___1(((struct __anonymous6 *)(&__x16__CV13s__anonymous6_1))));
+    ((void)___constructor__F_P13s__anonymous7_autogen___1(((struct __anonymous7 *)(&__x17__CV13s__anonymous7_1))));
+    ((void)___constructor__F_P13s__anonymous8_autogen___1(((struct __anonymous8 *)(&__x29__CV13s__anonymous8_1))));
+    ((void)___constructor__F_P13s__anonymous9_autogen___1(((struct __anonymous9 *)(&__x30__CV13s__anonymous9_1))));
+    ((void)___constructor__F_P14s__anonymous10_autogen___1(((struct __anonymous10 *)(&__x31__CV14s__anonymous10_1))));
+    ((void)___constructor__F_P14s__anonymous11_autogen___1(((struct __anonymous11 *)(&__x32__CV14s__anonymous11_1))));
+    ((void)___constructor__F_P14s__anonymous12_autogen___1(((struct __anonymous12 *)(&__x33__CV14s__anonymous12_1))));
+    ((void)___constructor__F_P14s__anonymous13_autogen___1(((struct __anonymous13 *)(&__x34__CV14s__anonymous13_1))));
+    ((void)___constructor__F_P14s__anonymous14_autogen___1(((struct __anonymous14 *)(&__x35__CV14s__anonymous14_1))));
+    ((void)___constructor__F_P14s__anonymous15_autogen___1(((struct __anonymous15 *)(&__x36__CV14s__anonymous15_1))));
+}
+__attribute__ ((destructor(),)) static void _destroy_declarationSpecifier(void){
+    ((void)___destructor__F_P14s__anonymous15_autogen___1(((struct __anonymous15 *)(&__x36__CV14s__anonymous15_1))));
+    ((void)___destructor__F_P14s__anonymous14_autogen___1(((struct __anonymous14 *)(&__x35__CV14s__anonymous14_1))));
+    ((void)___destructor__F_P14s__anonymous13_autogen___1(((struct __anonymous13 *)(&__x34__CV14s__anonymous13_1))));
+    ((void)___destructor__F_P14s__anonymous12_autogen___1(((struct __anonymous12 *)(&__x33__CV14s__anonymous12_1))));
+    ((void)___destructor__F_P14s__anonymous11_autogen___1(((struct __anonymous11 *)(&__x32__CV14s__anonymous11_1))));
+    ((void)___destructor__F_P14s__anonymous10_autogen___1(((struct __anonymous10 *)(&__x31__CV14s__anonymous10_1))));
+    ((void)___destructor__F_P13s__anonymous9_autogen___1(((struct __anonymous9 *)(&__x30__CV13s__anonymous9_1))));
+    ((void)___destructor__F_P13s__anonymous8_autogen___1(((struct __anonymous8 *)(&__x29__CV13s__anonymous8_1))));
+    ((void)___destructor__F_P13s__anonymous7_autogen___1(((struct __anonymous7 *)(&__x17__CV13s__anonymous7_1))));
+    ((void)___destructor__F_P13s__anonymous6_autogen___1(((struct __anonymous6 *)(&__x16__CV13s__anonymous6_1))));
+    ((void)___destructor__F_P13s__anonymous5_autogen___1(((struct __anonymous5 *)(&__x15__CV13s__anonymous5_1))));
+    ((void)___destructor__F_P13s__anonymous4_autogen___1(((struct __anonymous4 *)(&__x14__CV13s__anonymous4_1))));
+    ((void)___destructor__F_P13s__anonymous3_autogen___1(((struct __anonymous3 *)(&__x13__CV13s__anonymous3_1))));
+    ((void)___destructor__F_P13s__anonymous2_autogen___1(((struct __anonymous2 *)(&__x12__CV13s__anonymous2_1))));
+    ((void)___destructor__F_P13s__anonymous1_autogen___1(((struct __anonymous1 *)(&__x11__CV13s__anonymous1_1))));
+    ((void)___destructor__F_P13s__anonymous0_autogen___1(((struct __anonymous0 *)(&__x10__CV13s__anonymous0_1))));
+}

src/tests/.expect/64/extension.txt

@@ -86 +86 @@
         __extension__ int __c__i_2;
     };
-    int __i__i_2 = ((int )(__extension__ __a__i_1+__extension__ 3));
+    int __i__i_2;
+    ((void)((*((int *)(&__i__i_2)))=(__extension__ __a__i_1+__extension__ 3)) /* ?{} */);
     ((void)__extension__ 3);
     ((void)__extension__ __a__i_1);

src/tests/.expect/64/gccExtensions.txt

@@ -76 +76 @@
         ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))=__c__i_2) /* ?{} */);
     }
-    int __i__i_2 = ((int )__extension__ 3);
+    int __i__i_2;
+    ((void)((*((int *)(&__i__i_2)))=__extension__ 3) /* ?{} */);
     __extension__ int __a__i_2;
     __extension__ int __b__i_2;
@@ -132 +133 @@
     }
     struct s3 __x1__3ss3_2;
+    ((void)___constructor__F_P3ss3_autogen___2(((struct s3 *)(&__x1__3ss3_2))));
     struct s3 __y1__3ss3_2;
+    ((void)___constructor__F_P3ss3_autogen___2(((struct s3 *)(&__y1__3ss3_2))));
     struct s4 {
         int __i__i_2;
@@ -138 +141 @@
     inline struct s4 ___operator_assign__F3ss4_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){
         ((void)((*___dst__P3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
+        ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__y1__3ss3_2))));
+        ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__x1__3ss3_2))));
         return ((struct s4 )___src__3ss4_2);
     }
@@ -153 +158 @@
     }
     struct s4 __x2__3ss4_2;
+    ((void)___constructor__F_P3ss4_autogen___2(((struct s4 *)(&__x2__3ss4_2))));
     struct s4 __y2__3ss4_2;
+    ((void)___constructor__F_P3ss4_autogen___2(((struct s4 *)(&__y2__3ss4_2))));
     int __m1__A0i_2[((long unsigned int )10)];
     int __m2__A0A0i_2[((long unsigned int )10)][((long unsigned int )10)];
@@ -159 +166 @@
     int _retVal0 = { 0 };
     ((void)(_retVal0=0) /* ?{} */);
+    ((void)___destructor__F_P3ss4_autogen___2(((struct s4 *)(&__y2__3ss4_2))));
+    ((void)___destructor__F_P3ss4_autogen___2(((struct s4 *)(&__x2__3ss4_2))));
+    ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__y1__3ss3_2))));
+    ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__x1__3ss3_2))));
     return ((int )_retVal0);
+    ((void)___destructor__F_P3ss4_autogen___2(((struct s4 *)(&__y2__3ss4_2))));
+    ((void)___destructor__F_P3ss4_autogen___2(((struct s4 *)(&__x2__3ss4_2))));
+    ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__y1__3ss3_2))));
+    ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__x1__3ss3_2))));
 }

src/tests/Makefile.am

@@ -62 +62 @@
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 
-memberCtors-ERR1: memberCtors.c
-        ${CC} ${CFALGS} -DERR1 ${<} -o ${@}
+ctorWarnings: ctorWarnings.c
+        ${CC} ${CFALGS} -CFA -XCFA -p ${<} -o /dev/null 2> ${@}
 

src/tests/Makefile.in

@@ -670 +670 @@
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 
-memberCtors-ERR1: memberCtors.c
-        ${CC} ${CFALGS} -DERR1 ${<} -o ${@}
+ctorWarnings: ctorWarnings.c
+        ${CC} ${CFALGS} -CFA -XCFA -p ${<} -o /dev/null 2> ${@}
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

src/tests/typeof.c

@@ -8 +8 @@
     typeof( int ( int, int p ) ) *v7;
     typeof( [int] ( int, int p ) ) *v8;
-    (typeof(v1)) v2; // cast with typeof
 }