Changeset 5fda7143

Timestamp:

Sep 7, 2016, 9:30:25 AM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

9f70ab57

Parents:

1f75e2d (diff), f04a8b81 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Conflicts:

src/Common/utility.h

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) (8 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 (deleted)
• tests/.expect/memberCtors-ERR1.txt (added)
• tests/.expect/memberCtors.txt (added)
• tests/Makefile.am (modified) (1 diff)
• tests/Makefile.in (modified) (1 diff)
• tests/ctorWarnings.c (deleted)
• tests/memberCtors.c (added)
• 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 ) {
-        errors.push_back( std::string( "Error: " ) + error );
+  append( error );
 }
 
 void SemanticError::append( SemanticError &other ) {
-        errors.splice( errors.end(), other.errors );
+  errors.splice( errors.end(), other.errors );
+}
+
+void SemanticError::append( const std::string & msg ) {
+  errors.push_back( std::string( "Error: ") + msg );
 }
 

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 );
@@ -42 +43 @@
 template< typename T >
 SemanticError::SemanticError( const std::string &error, const T *obj ) {
-        std::ostringstream os;
-        os << "Error: " << error;
-        obj->print( os );
-        errors.push_back( os.str() );
+        append( toString( error, obj ) );
 }
+
 
 #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 );
@@ -1675 +1678 @@
                 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();
+                        endTypeScope();
+                        return ret;
+                }
+
+                ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) {
+                        return handleDecl( objectDecl, objectDecl->get_type() );
+                }
+
+                DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) {
                         knownLayouts.beginScope();
                         knownOffsets.beginScope();
 
-                        DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
-
+                        DeclarationWithType * decl = handleDecl( functionDecl, functionDecl->get_functionType() );
                         knownOffsets.endScope();
                         knownLayouts.endScope();
-                        endTypeScope();
-                        return ret;
-                }
-
-                ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) {
-                        return handleDecl( objectDecl, objectDecl->get_type() );
-                }
-
-                DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) {
-                        return handleDecl( functionDecl, functionDecl->get_functionType() );
+                        return decl;
                 }
 
@@ -1700 +1709 @@
                 TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
                         scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
-                        return Mutator::mutate( typeDecl );
+                        return Parent::mutate( typeDecl );
                 }
 
@@ -1706 +1715 @@
                         beginTypeScope( pointerType );
 
-                        Type *ret = Mutator::mutate( pointerType );
+                        Type *ret = Parent::mutate( pointerType );
 
                         endTypeScope();
@@ -1724 +1733 @@
                         }
 
-                        Type *ret = Mutator::mutate( funcType );
+                        Type *ret = Parent::mutate( funcType );
 
                         endTypeScope();
@@ -1745 +1754 @@
                                 }
                         }
-                        return Mutator::mutate( declStmt );
+                        return Parent::mutate( declStmt );
                 }
 
@@ -1787 +1796 @@
                 Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
                         // mutate, exiting early if no longer MemberExpr
-                        Expression *expr = Mutator::mutate( memberExpr );
+                        Expression *expr = Parent::mutate( memberExpr );
                         memberExpr = dynamic_cast< MemberExpr* >( expr );
                         if ( ! memberExpr ) return expr;
@@ -1972 +1981 @@
                 Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) {
                         // mutate, exiting early if no longer OffsetofExpr
-                        Expression *expr = Mutator::mutate( offsetofExpr );
+                        Expression *expr = Parent::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
-                        *i = (*i)->acceptMutator( *this );
+                        try {
+                                *i = (*i)->acceptMutator( *this );
+                        } catch ( SemanticError &e ) {
+                                errors.append( e );
+                        } // try
                         if ( ! stmtsToAdd.empty() ) {
                                 statements.splice( i, stmtsToAdd );
@@ -42 +48 @@
                         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();
 
@@ -42 +45 @@
                 virtual Statement* mutate(ExprStmt *catchStmt);
                 virtual Statement* mutate(ReturnStmt *catchStmt);
-  
+
                 virtual Expression* mutate(UntypedExpr *untypedExpr);
 
@@ -54 +57 @@
                 Statement* mutateStatement( Statement *stmt );
                 Expression* mutateExpression( Expression *expr );
-  
+
                 TyVarMap scopeTyVars;
                 TypeSubstitution *env;
@@ -60 +63 @@
                 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"
@@ -176 +177 @@
                 };
 
-                class WarnStructMembers : public Visitor {
+                class GenStructMemberCalls : public SymTab::Indexer {
                   public:
-                        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 );
+                        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 );
 
                         virtual void visit( FunctionDecl * funcDecl );
@@ -188 +190 @@
                         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;
+                        std::set< DeclarationWithType * > unhandled, usedUninit;
                         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
@@ -209 +230 @@
                 FixCopyCtors::fixCopyCtors( translationUnit );
 
-                WarnStructMembers::warnings( translationUnit );
+                GenStructMemberCalls::generate( translationUnit );
         }
 
@@ -254 +275 @@
                 }
 
-                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 );
+                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;
                         }
                 }
@@ -528 +552 @@
                                                         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()->get_kids().push_back( dtorStmt );
+                                                        dtorCaller->get_statements()->push_back( dtorStmt );
 
                                                         // atexit(dtor_atexit);
@@ -543 +567 @@
                                                         // 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_mangleName( objDecl->get_mangleName() + staticNamer.newName() );
+                                                        objDecl->set_name( objDecl->get_name() + staticNamer.newName() );
+                                                        objDecl->set_mangleName( SymTab::Mangler::mangle( objDecl ) );
 
                                                         objDecl->set_init( NULL );
@@ -709 +739 @@
                 }
 
-                void WarnStructMembers::visit( FunctionDecl * funcDecl ) {
-                        WarnStructMembers old = *this;
-                        *this = WarnStructMembers();
+                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();
 
                         function = funcDecl;
-                        if ( checkWarnings( funcDecl ) ) {
-                                FunctionType * type = funcDecl->get_functionType();
+                        isCtor = isConstructor( function->get_name() );
+                        if ( checkWarnings( function ) ) {
+                                FunctionType * type = function->get_functionType();
                                 assert( ! type->get_parameters().empty() );
                                 thisParam = safe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
@@ -721 +760 @@
                                 StructInstType * structType = dynamic_cast< StructInstType * >( ptrType->get_base() );
                                 if ( structType ) {
-                                        StructDecl * structDecl = structType->get_baseStruct();
+                                        structDecl = structType->get_baseStruct();
                                         for ( Declaration * member : structDecl->get_members() ) {
                                                 if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
@@ -731 +770 @@
                                 }
                         }
-                        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" );
+                        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" );
                         }
 
-                        *this = old;
-                }
-
-                void WarnStructMembers::visit( ApplicationExpr * appExpr ) {
+                        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 ) {
                         if ( ! checkWarnings( function ) ) return;
 
@@ -760 +850 @@
                                         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() );
                         }
 
@@ -770 +855 @@
                 }
 
-                void WarnStructMembers::handleFirstParam( Expression * firstParam ) {
+                void GenStructMemberCalls::handleFirstParam( Expression * firstParam ) {
                         using namespace std;
                         if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( firstParam ) ) {
@@ -787 +872 @@
                 }
 
-                void WarnStructMembers::visit( MemberExpr * memberExpr ) {
+                void GenStructMemberCalls::visit( MemberExpr * memberExpr ) {
                         if ( ! checkWarnings( function ) ) return;
-                        if ( ! isConstructor( function->get_name() ) ) return;
+                        if ( ! isCtor ) return;
 
                         if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
@@ -797 +882 @@
                                                         if ( unhandled.count( memberExpr->get_member() ) ) {
                                                                 // emit a warning because a member was used before it was constructed
-                                                                warn( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", member ", memberExpr->get_member()->get_name(), " used before being constructed" );
+                                                                usedUninit.insert( memberExpr->get_member() );
                                                         }
                                                 }
@@ -805 +890 @@
                         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 {
@@ -55 +57 @@
         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
@@ -65 +69 @@
                 // should not traverse into any of these declarations to find objects
                 // that need to be constructed or destructed
-                virtual Declaration* mutate( StructDecl *aggregateDecl ) { return aggregateDecl; }
+                virtual Declaration* mutate( StructDecl *aggregateDecl );
                 virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
                 virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
@@ -74 +78 @@
                 virtual Type * mutate( FunctionType *funcType ) { return funcType; }
 
-          protected:
+                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;
         };
 
@@ -142 +156 @@
 
         DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
-                std::list<DeclarationWithType*> oldReturnVals = returnVals;
-                std::string oldFuncName = funcName;
+                ValueGuard< std::list<DeclarationWithType*> > oldReturnVals( returnVals );
+                ValueGuard< std::string > oldFuncName( funcName );
 
                 FunctionType * type = functionDecl->get_functionType();
@@ -149 +163 @@
                 funcName = functionDecl->get_name();
                 DeclarationWithType * decl = Mutator::mutate( functionDecl );
-                returnVals = oldReturnVals;
-                funcName = oldFuncName;
                 return decl;
         }
@@ -197 +209 @@
 
         DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
-                bool oldInFunc = inFunction;
+                ValueGuard< bool > oldInFunc( inFunction );
                 inFunction = true;
                 DeclarationWithType * decl = Parent::mutate( functionDecl );
-                inFunction = oldInFunc;
                 return decl;
         }
@@ -209 +220 @@
         }
 
+        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 ) {
-                // hands off if designated, if @=, or if extern
-                if ( tryConstruct( 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 );
+
                         // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
                         // for each constructable object
@@ -241 +277 @@
                         }
                 }
-                return Mutator::mutate( objDecl );
+                return Parent::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 {
@@ -22 +23 @@
                 };
 
+                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:
@@ -52 +74 @@
                 maybeAccept( init, finder );
                 return finder.hasDesignations;
+        }
+
+        bool checkInitDepth( ObjectDecl * objDecl ) {
+                InitDepthChecker checker( objDecl->get_type() );
+                maybeAccept( objDecl->get_init(), checker );
+                return checker.depthOkay;
         }
 
@@ -231 +259 @@
                 return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
                         (objDecl->get_init() == NULL ||
-                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) &&
-                        ! isDesignated( objDecl->get_init() )
+                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
                         && objDecl->get_storageClass() != DeclarationNode::Extern;
         }
@@ -390 +417 @@
                 virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; }
                 virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; }
-                virtual void visit( NameExpr *nameExpr ) { isConstExpr = false; }
-                virtual void visit( CastExpr *castExpr ) { 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( 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 );
@@ -439 +473 @@
         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 );
@@ -38 +40 @@
         /// 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 : Sun Aug 28 22:12:44 2016
-// Update Count     : 278
+// Last Modified On : Mon Aug 29 22:30:56 2016
+// Update Count     : 327
 //
 
@@ -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 {
@@ -55 +81 @@
         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 {
@@ -129 +143 @@
 
         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
 
@@ -175 +189 @@
         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
@@ -182 +196 @@
         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
@@ -205 +212 @@
         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
@@ -220 +227 @@
         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
@@ -245 +252 @@
         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
@@ -255 +262 @@
         newnode->name = assign_strptr( name );
         newnode->type = new TypeData( TypeData::Variable );
-        newnode->type->variable->tyClass = tc;
-        newnode->type->variable->name = newnode->name;
+        newnode->variable.tyClass = tc;
+        newnode->variable.name = newnode->name;
         return newnode;
 } // DeclarationNode::newTypeParam
@@ -263 +270 @@
         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
@@ -273 +280 @@
         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
@@ -284 +291 @@
         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
@@ -299 +306 @@
         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 );
@@ -312 +319 @@
         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 );
 }
@@ -327 +334 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Tuple );
-        newnode->type->tuple->members = members;
+        newnode->type->tuple = members;
         return newnode;
 }
@@ -334 +341 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Typeof );
-        newnode->type->typeexpr->expr = expr;
-        return newnode;
-}
+        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
 
 DeclarationNode *DeclarationNode::newAttr( std::string *name, ExpressionNode *expr ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Attr );
-        newnode->type->attr->name = assign_strptr( name );
-        newnode->type->attr->expr = expr;
+        newnode->attr.name = assign_strptr( name );
+        newnode->attr.expr = expr;
         return newnode;
 }
@@ -349 +363 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Attr );
-        newnode->type->attr->name = assign_strptr( name );
-        newnode->type->attr->type = type;
+        newnode->attr.name = assign_strptr( name );
+        newnode->attr.type = type;
         return newnode;
 }
@@ -407 +421 @@
                                 } 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;
@@ -457 +471 @@
                                 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;
@@ -466 +480 @@
                                   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;
@@ -495 +509 @@
                                 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;
@@ -523 +537 @@
 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;
@@ -535 +549 @@
         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 ( type->variable->assertions ) {
-                        type->variable->assertions->appendList( assertions );
+                if ( variable.assertions ) {
+                        variable.assertions->appendList( assertions );
                 } else {
-                        type->variable->assertions = assertions;
+                        variable.assertions = assertions;
                 } // if
                 break;
@@ -574 +588 @@
         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;
 }
@@ -583 +597 @@
         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;
 }
@@ -630 +644 @@
                           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;
@@ -667 +681 @@
                           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;
@@ -687 +701 @@
 DeclarationNode *DeclarationNode::addParamList( DeclarationNode *params ) {
         TypeData *ftype = new TypeData( TypeData::Function );
-        ftype->function->params = params;
+        ftype->function.params = params;
         setBase( type, ftype );
         return this;
@@ -697 +711 @@
                         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
@@ -727 +741 @@
         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
@@ -753 +767 @@
                         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
@@ -896 +910 @@
         if ( ! error.empty() ) throw SemanticError( error, this );
         if ( type ) {
-                return buildDecl( type, name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
+                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
         } // if
         if ( ! isInline && ! isNoreturn ) {
@@ -909 +930 @@
         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() );
+                  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
                   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 : Sun Aug 28 21:14:51 2016
-// Update Count     : 575
+// Last Modified On : Mon Aug 29 21:45:43 2016
+// Update Count     : 583
 //
 
@@ -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;
@@ -409 +431 @@
 }
 
+// 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 : Sun Aug 28 18:28:58 2016
-// Update Count     : 223
+// Last Modified On : Mon Aug 29 22:31:53 2016
+// Update Count     : 277
 //
 
@@ -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->members = 0;
+                // tuple = new Tuple_t;
+                tuple = nullptr;
                 break;
           case Typeof:
-                typeexpr = new Typeof_t;
-                typeexpr->expr = 0;
+                // typeexpr = new Typeof_t;
+                typeexpr = nullptr;
+                break;
+          case Attr:
+                // attr = new Attr_t;
+                // attr.expr = nullptr;
+                // attr.type = nullptr;
                 break;
           case Builtin:
-                builtin = new Builtin_t;
-                break;
-          case Attr:
-                attr = new Attr_t;
-                attr->expr = 0;
-                attr->type = 0;
+                // builtin = new Builtin_t;
                 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 Attr:
+                // delete attr.expr;
+                // delete attr.type;
+                // delete attr;
+                break;
           case Builtin:
-                delete builtin;
-                break;
-          case Attr:
-                delete attr->expr;
-                delete attr->type;
-                delete attr;
+                // delete builtin;
                 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:
-                newtype->variable->assertions = maybeClone( variable->assertions );
-                newtype->variable->name = variable->name;
-                newtype->variable->tyClass = variable->tyClass;
+                assert( false );
+                // newtype->variable.assertions = maybeClone( variable.assertions );
+                // newtype->variable.name = variable.name;
+                // newtype->variable.tyClass = variable.tyClass;
                 break;
           case Tuple:
-                newtype->tuple->members = maybeClone( tuple->members );
+                newtype->tuple = maybeClone( tuple );
                 break;
           case Typeof:
-                newtype->typeexpr->expr = maybeClone( typeexpr->expr );
+                newtype->typeexpr = maybeClone( typeexpr );
+                break;
+          case Attr:
+                assert( false );
+                // newtype->attr.expr = maybeClone( attr.expr );
+                // newtype->attr.type = maybeClone( attr.type );
                 break;
           case Builtin:
-                newtype->builtin->type = builtin->type;
-                break;
-          case Attr:
-                newtype->attr->expr = maybeClone( attr->expr );
-                newtype->attr->type = maybeClone( attr->type );
+                assert( false );
+                // newtype->builtin = builtin;
                 break;
         } // switch
@@ -268 +271 @@
                 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 {
@@ -289 +292 @@
           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 ";
@@ -310 +313 @@
                 } // 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
@@ -382 +385 @@
                 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->members ) {
+                if ( tuple ) {
                         os << "with members " << endl;
-                        tuple->members->printList( os, indent + 2 );
+                        tuple->printList( os, indent + 2 );
                 } // if
                 break;
           case Typeof:
                 os << "type-of expression ";
-                if ( typeexpr->expr ) {
-                        typeexpr->expr->print( os, indent + 2 );
+                if ( typeexpr ) {
+                        typeexpr->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:
@@ -479 +482 @@
                 return new VarArgsType( buildQualifiers( td ) );
           case TypeData::Attr:
+                assert( false );
                 return buildAttr( td );
           case TypeData::Symbolic:
@@ -494 +498 @@
         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;
@@ -535 +539 @@
         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 {
@@ -611 +615 @@
         } // 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:
@@ -746 +750 @@
         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() );
@@ -759 +763 @@
         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:
@@ -776 +780 @@
         } // 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;
@@ -786 +790 @@
 
         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:
@@ -804 +808 @@
                 } // switch
         } // if
-        buildList( td->aggInst->params, ret->get_parameters() );
+        buildList( td->aggInst.params, ret->get_parameters() );
         buildForall( td->forall, ret->get_forall() );
         return ret;
@@ -813 +817 @@
         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( 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( 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;
 } // 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);
@@ -848 +854 @@
 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;
@@ -857 +863 @@
         assert( td->kind == TypeData::Tuple );
         TupleType * ret = new TupleType( buildQualifiers( td ) );
-        buildTypeList( td->tuple->members, ret->get_types() );
+        buildTypeList( td->tuple, ret->get_types() );
         buildForall( td->forall, ret->get_forall() );
         return ret;
@@ -865 +871 @@
         assert( td->kind == TypeData::Typeof );
         assert( td->typeexpr );
-        assert( td->typeexpr->expr );
-        return new TypeofType( buildQualifiers( td ), td->typeexpr->expr->build() );
+        // assert( td->typeexpr->expr );
+        return new TypeofType( buildQualifiers( td ), td->typeexpr->build() );
 } // buildTypeof
 
 AttrType * buildAttr( const TypeData * td ) {
-        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( 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;
 } // buildAttr
 
@@ -885 +893 @@
         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 );
@@ -898 +906 @@
                         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 ) {
@@ -912 +920 @@
                 return buildSymbolic( td, name, sc );
         } else if ( td->kind == TypeData::Variable ) {
+                assert( false );
                 return buildVariable( td );
         } else {
@@ -921 +930 @@
 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->members, ft->get_returnVals() );
+                        buildList( td->base->tuple, 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 : Sun Aug 28 22:39:00 2016
-// Update Count     : 85
+// Last Modified On : Mon Aug 29 22:31:52 2016
+// Update Count     : 110
 //
 
@@ -24 +24 @@
 struct TypeData {
         enum Kind { Unknown, Basic, Pointer, Array, Function, Aggregate, AggregateInst,
-                                Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr } kind;
+                                Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr };
 
         struct Basic_t {
@@ -73 +73 @@
         };
 
-        struct Variable_t {
-                DeclarationNode::TypeClass tyClass;
-                std::string name;
-                DeclarationNode * assertions;
-        };
+        // struct Tuple_t {
+        //      DeclarationNode * members;
+        // };
+  
+        // struct Typeof_t {
+        //      ExpressionNode * expr;
+        // };
 
-        struct Tuple_t {
-                DeclarationNode * members;
-        };
-  
-        struct Typeof_t {
-                ExpressionNode * expr;
-        };
+        // struct Builtin_t {
+        //      DeclarationNode::BuiltinType type;
+        // };
 
-        struct Builtin_t {
-                DeclarationNode::BuiltinType type;
-        };
-
-        struct Attr_t {
-                std::string name;
-                ExpressionNode * expr;
-                DeclarationNode * type;
-        };
-
+        Kind kind;
         TypeData * base;
         typedef std::bitset< DeclarationNode::NoOfQualifier > Qualifiers;
@@ -102 +91 @@
         DeclarationNode * forall;
 
-        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;
-        };
+                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;
 
         TypeData( Kind k = Unknown );

src/ResolvExpr/AlternativeFinder.cc

@@ -42 +42 @@
 #include "Common/utility.h"
 #include "InitTweak/InitTweak.h"
+#include "ResolveTypeof.h"
 
 extern bool resolvep;
@@ -707 +708 @@
         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 );
@@ -795 +797 @@
 
         void AlternativeFinder::visit( VariableExpr *variableExpr ) {
-                alternatives.push_back( Alternative( variableExpr->clone(), env, Cost::zero ) );
+                // 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 ) );
         }
 
@@ -804 +808 @@
         void AlternativeFinder::visit( SizeofExpr *sizeofExpr ) {
                 if ( sizeofExpr->get_isType() ) {
+                        // xxx - resolveTypeof?
                         alternatives.push_back( Alternative( sizeofExpr->clone(), env, Cost::zero ) );
                 } else {
@@ -823 +828 @@
         void AlternativeFinder::visit( AlignofExpr *alignofExpr ) {
                 if ( alignofExpr->get_isType() ) {
+                        // xxx - resolveTypeof?
                         alternatives.push_back( Alternative( alignofExpr->clone(), env, Cost::zero ) );
                 } else {
@@ -856 +862 @@
         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 ) {
-                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;
-                }
+                // 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 );
 
                 // 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 ), 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*>() ) );
+                ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
 
                 UntypedExpr *cond = new UntypedExpr( cmp );

src/SymTab/Indexer.cc

@@ -21 +21 @@
 #include <unordered_set>
 #include <utility>
+#include <algorithm>
 
 #include "Mangler.h"
@@ -33 +34 @@
 #include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
+
+#include "InitTweak/InitTweak.h"
 
 #define debugPrint(x) if ( doDebug ) { std::cout << x; }
@@ -99 +102 @@
 
                 if ( --toFree->refCount == 0 ) delete toFree;
+        }
+
+        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 );
+                                }
+                        }
+                }
         }
 
@@ -461 +526 @@
                         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, Declaration * decl ) {
+std::ostream & operator<<( std::ostream & out, const Declaration * decl ) {
         decl->print( out );
         return out;

src/SynTree/Declaration.h

@@ -279 +279 @@
 };
 
-std::ostream & operator<<( std::ostream & out, Declaration * decl );
+std::ostream & operator<<( std::ostream & out, const 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;
@@ -541 +540 @@
 }
 
-std::ostream & operator<<( std::ostream & out, Expression * expr ) {
+std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
         expr->print( out );
         return out;

src/SynTree/Expression.h

@@ -653 +653 @@
 };
 
-std::ostream & operator<<( std::ostream & out, Expression * expr );
+std::ostream & operator<<( std::ostream & out, const 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, Statement * statement ) {
+std::ostream & operator<<( std::ostream & out, const 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 ); }
@@ -395 +397 @@
 
 
-std::ostream & operator<<( std::ostream & out, Statement * statement );
+std::ostream & operator<<( std::ostream & out, const Statement * statement );
 
 #endif // STATEMENT_H

src/SynTree/Type.cc

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

src/SynTree/Type.h

@@ -481 +481 @@
 }
 
-std::ostream & operator<<( std::ostream & out, Type * type );
+std::ostream & operator<<( std::ostream & out, const 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 : Sat Aug 20 12:52:22 2016
-// Update Count     : 403
+// Last Modified On : Mon Aug 29 17:34:39 2016
+// Update Count     : 426
 //
 
@@ -75 +75 @@
 static void dump( list< Declaration * > & translationUnit, ostream & out = cout );
 
-void sigSegvBusHandler( int sig_num ) {
+void backtrace( int start ) {                                                   // skip first N stack frames
         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 first stack frame (points here)
-        for ( int i = 2; i < size - 2 && messages != nullptr; i += 1 ) {
+        // skip last 2 stack frames after main
+        for ( int i = start; 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
@@ -101 +96 @@
 
                 // 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';
@@ -106 +102 @@
                         *offset_end++ = '\0';
 
-                        int status;
+                        int status, frameNo = i - start;
                         char * real_name = __cxxabiv1::__cxa_demangle( mangled_name, 0, 0, &status );
                         if ( status == 0 ) {                                            // demangling successful ?
-                                cerr << "(" << i - 2 << ") " << messages[i] << " : "
+                                cerr << "(" << frameNo << ") " << messages[i] << " : "
                                          << real_name << "+" << offset_begin << offset_end << endl;
 
                         } else {                                                                        // otherwise, output mangled name
-                                cerr << "(" << i - 2 << ") " << messages[i] << " : "
+                                cerr << "(" << frameNo << ") " << messages[i] << " : "
                                          << mangled_name << "+" << offset_begin << offset_end << endl;
                         } // if
                         free( real_name );
                 } else {                                                                                // otherwise, print the whole line
-                        cerr << "(" << i - 2 << ") " << messages[i] << endl;
+                        cerr << "(" << frameNo << ") " << 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[] ) {
@@ -133 +144 @@
         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;
-    ((void)((*((int *)(&__i__i_2)))=(__extension__ __a__i_1+__extension__ 3)) /* ?{} */);
+    int __i__i_2 = ((int )(__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;
-    ((void)((*((int *)(&__i__i_2)))=__extension__ 3) /* ?{} */);
+    int __i__i_2 = ((int )__extension__ 3);
     __extension__ int __a__i_2;
     __extension__ int __b__i_2;
@@ -133 +132 @@
     }
     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;
@@ -141 +138 @@
     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);
     }
@@ -158 +153 @@
     }
     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)];
@@ -166 +159 @@
     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;
-    ((void)((*((int *)(&__i__i_2)))=(__extension__ __a__i_1+__extension__ 3)) /* ?{} */);
+    int __i__i_2 = ((int )(__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;
-    ((void)((*((int *)(&__i__i_2)))=__extension__ 3) /* ?{} */);
+    int __i__i_2 = ((int )__extension__ 3);
     __extension__ int __a__i_2;
     __extension__ int __b__i_2;
@@ -133 +132 @@
     }
     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;
@@ -141 +138 @@
     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);
     }
@@ -158 +153 @@
     }
     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)];
@@ -166 +159 @@
     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 ${@}
 
-ctorWarnings: ctorWarnings.c
-        ${CC} ${CFALGS} -CFA -XCFA -p ${<} -o /dev/null 2> ${@}
+memberCtors-ERR1: memberCtors.c
+        ${CC} ${CFALGS} -DERR1 ${<} -o ${@}
 

src/tests/Makefile.in

@@ -670 +670 @@
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 
-ctorWarnings: ctorWarnings.c
-        ${CC} ${CFALGS} -CFA -XCFA -p ${<} -o /dev/null 2> ${@}
+memberCtors-ERR1: memberCtors.c
+        ${CC} ${CFALGS} -DERR1 ${<} -o ${@}
 
 # 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
 }