Index: src/CodeGen/FixNames.cc
===================================================================
--- src/CodeGen/FixNames.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/CodeGen/FixNames.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar  6 23:32:08 2017
-// Update Count     : 15
+// Last Modified On : Thu Mar 16 07:50:30 2017
+// Update Count     : 16
 //
 
@@ -39,9 +39,9 @@
 	std::string mangle_main() {
 		FunctionType* main_type;
-		std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", DeclarationNode::StorageClasses(), LinkageSpec::Cforall,
+		std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", Type::StorageClasses(), LinkageSpec::Cforall,
 																   main_type = new FunctionType( Type::Qualifiers(), true ), nullptr )
 				};
 		main_type->get_returnVals().push_back( 
-			new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
+			new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
 		);
 
@@ -52,17 +52,17 @@
 	std::string mangle_main_args() {
 		FunctionType* main_type;
-		std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 
+		std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", Type::StorageClasses(), LinkageSpec::Cforall, 
 																   main_type = new FunctionType( Type::Qualifiers(), false ), nullptr )
 				};
 		main_type->get_returnVals().push_back( 
-			new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
+			new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
 		);
 
 		mainDecl->get_functionType()->get_parameters().push_back( 
-			new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
+			new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
 		);
 
 		mainDecl->get_functionType()->get_parameters().push_back( 
-			new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, 
+			new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, 
 			new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Char ) ) ), 
 			nullptr )
Index: src/Concurrency/Keywords.cc
===================================================================
--- src/Concurrency/Keywords.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/Concurrency/Keywords.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -12,5 +12,5 @@
 // Last Modified By :
 // Last Modified On :
-// Update Count     : 0
+// Update Count     : 1
 //
 
@@ -29,5 +29,5 @@
 	namespace {
 		const std::list<Label> noLabels;
-		DeclarationNode::StorageClasses noStorage;
+		Type::StorageClasses noStorage;
 		Type::Qualifiers noQualifiers;
 	}
Index: src/GenPoly/Box.cc
===================================================================
--- src/GenPoly/Box.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/GenPoly/Box.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 14 07:45:29 2017
-// Update Count     : 334
+// Last Modified On : Thu Mar 16 08:06:05 2017
+// Update Count     : 337
 //
 
@@ -289,6 +289,6 @@
 			TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
 			std::string paramName = mangleType( &paramType );
-			layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
-			layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
+			layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
+			layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
 		}
 	}
@@ -299,5 +299,5 @@
 		// because each unit generates copies of the default routines for each aggregate.
 		FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ),
-													 functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::Static ),
+													 functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
 													 LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ),
 													 std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) );
@@ -368,9 +368,9 @@
 		PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
 
-		ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
+		ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
 		layoutFnType->get_parameters().push_back( sizeParam );
-		ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
+		ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
 		layoutFnType->get_parameters().push_back( alignParam );
-		ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
+		ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
 		layoutFnType->get_parameters().push_back( offsetParam );
 		addOtypeParams( layoutFnType, otypeParams );
@@ -429,7 +429,7 @@
 		PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
 
-		ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
+		ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
 		layoutFnType->get_parameters().push_back( sizeParam );
-		ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
+		ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
 		layoutFnType->get_parameters().push_back( alignParam );
 		addOtypeParams( layoutFnType, otypeParams );
@@ -537,5 +537,5 @@
 					if ( adapters.find( mangleName ) == adapters.end() ) {
 						std::string adapterName = makeAdapterName( mangleName );
-						adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) );
+						adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) );
 					} // if
 				} // for
@@ -656,5 +656,5 @@
 
 		ObjectDecl *Pass1::makeTemporary( Type *type ) {
-			ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, type, 0 );
+			ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 );
 			stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
 			return newObj;
@@ -765,5 +765,5 @@
 					Type * newType = param->clone();
 					if ( env ) env->apply( newType );
-					ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
+					ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
 					newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
 					stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
@@ -831,5 +831,5 @@
 				makeRetParm( adapter );
 			} // if
-			adapter->get_parameters().push_front( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
+			adapter->get_parameters().push_front( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
 			return adapter;
 		}
@@ -912,5 +912,5 @@
 			adapterBody->get_kids().push_back( bodyStmt );
 			std::string adapterName = makeAdapterName( mangleName );
-			return new FunctionDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, adapterType, adapterBody );
+			return new FunctionDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, adapterType, adapterBody );
 		}
 
@@ -1273,5 +1273,5 @@
 				if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
 					std::string adapterName = makeAdapterName( mangleName );
-					paramList.push_front( new ObjectDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
+					paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
 					adaptersDone.insert( adaptersDone.begin(), mangleName );
 				}
@@ -1379,6 +1379,6 @@
 			std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
 			std::list< DeclarationWithType *> inferredParams;
-			ObjectDecl newObj( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
-			ObjectDecl newPtr( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0,
+			ObjectDecl newObj( "", Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
+			ObjectDecl newPtr( "", Type::StorageClasses(), LinkageSpec::C, 0,
 			                   new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
 			for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
@@ -1634,5 +1634,5 @@
 
 		ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
-			ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::StorageClasses(), LinkageSpec::C, 0, type, init );
+			ObjectDecl *newObj = new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init );
 			stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
 			return newObj;
@@ -1818,5 +1818,5 @@
 							memberDecl = origMember->clone();
 						} else {
-							memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
+							memberDecl = new ObjectDecl( (*member)->get_name(), Type::StorageClasses(), LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
 						}
 						inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
Index: src/GenPoly/Specialize.cc
===================================================================
--- src/GenPoly/Specialize.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/GenPoly/Specialize.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar  6 23:13:00 2017
-// Update Count     : 30
+// Last Modified On : Thu Mar 16 07:53:59 2017
+// Update Count     : 31
 //
 
@@ -155,5 +155,5 @@
 		} // if
 		// create new thunk with same signature as formal type (C linkage, empty body)
-		FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, newType, new CompoundStmt( noLabels ) );
+		FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), Type::StorageClasses(), LinkageSpec::C, newType, new CompoundStmt( noLabels ) );
 		thunkFunc->fixUniqueId();
 
Index: src/InitTweak/FixGlobalInit.cc
===================================================================
--- src/InitTweak/FixGlobalInit.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/InitTweak/FixGlobalInit.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 04 15:14:56 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar 13 23:58:27 2017
-// Update Count     : 16
+// Last Modified On : Thu Mar 16 07:53:11 2017
+// Update Count     : 18
 //
 
@@ -87,7 +87,7 @@
 			dtorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) );
 		}
-		initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
+		initFunction = new FunctionDecl( "_init_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
 		initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) );
-		destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
+		destroyFunction = new FunctionDecl( "_destroy_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
 		destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) );
 	}
Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/InitTweak/FixInit.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 14 08:05:28 2017
-// Update Count     : 63
+// Last Modified On : Thu Mar 16 08:08:04 2017
+// Update Count     : 67
 //
 
@@ -437,5 +437,5 @@
 			result = result->clone();
 			env->apply( result );
-			ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+			ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
 			tmp->get_type()->set_isConst( false );
 
@@ -483,5 +483,5 @@
 				result = result->clone();
 				env->apply( result );
-				ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+				ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
 				ret->get_type()->set_isConst( false );
 				impCpCtorExpr->get_returnDecls().push_back( ret );
@@ -506,5 +506,5 @@
 				result = result->clone();
 				env->apply( result );
-				ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+				ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
 				ret->get_type()->set_isConst( false );
 				stmtExpr->get_returnDecls().push_front( ret );
@@ -538,5 +538,5 @@
 			} else {
 				// expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
-				unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
+				unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
 				unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
 			}
@@ -704,5 +704,5 @@
 						BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
 						SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
-						ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
+						ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
 						isUninitializedVar->fixUniqueId();
 
@@ -731,5 +731,5 @@
 
 							// void __objName_dtor_atexitN(...) {...}
-							FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
+							FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
 							dtorCaller->fixUniqueId();
 							dtorCaller->get_statements()->push_back( dtorStmt );
@@ -764,5 +764,5 @@
 							// create a new object which is never used
 							static UniqueName dummyNamer( "_dummy" );
-							ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
+							ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
 							return dummy;
 						}
@@ -1118,5 +1118,5 @@
 
 			// xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
-			ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
+			ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
 			addDeclaration( tmp );
 
Index: src/InitTweak/GenInit.cc
===================================================================
--- src/InitTweak/GenInit.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/InitTweak/GenInit.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar 13 23:59:09 2017
-// Update Count     : 180
+// Last Modified On : Thu Mar 16 08:01:25 2017
+// Update Count     : 181
 //
 
@@ -120,5 +120,5 @@
 		void hoist( Type * type );
 
-		DeclarationNode::StorageClasses storageClasses;
+		Type::StorageClasses storageClasses;
 		bool inFunction = false;
 	};
Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/Parser/DeclarationNode.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 23:36:49 2017
-// Update Count     : 997
+// Last Modified On : Thu Mar 16 07:59:40 2017
+// Update Count     : 1003
 //
 
@@ -33,5 +33,4 @@
 
 // These must remain in the same order as the corresponding DeclarationNode enumerations.
-const char * DeclarationNode::StorageClasses::Names[] = { "extern", "static", "auto", "register", "_Thread_local", "NoStorageClassNames" };
 const char * DeclarationNode::FuncSpecifiers::Names[] = { "inline", "fortran", "_Noreturn", "NoFunctionSpecifierNames" };
 const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" };
@@ -181,5 +180,5 @@
 
 
-DeclarationNode * DeclarationNode::newStorageClass( StorageClasses sc ) {
+DeclarationNode * DeclarationNode::newStorageClass( Type::StorageClasses sc ) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->storageClasses = sc;
@@ -458,13 +457,13 @@
 	if ( storageClasses.any() && src->storageClasses.any() ) { // any reason to check ?
 		if ( (storageClasses.val & src->storageClasses.val ) != 0 ) { // duplicates ?
-			for ( unsigned int i = 0; i < NumStorageClass; i += 1 ) { // find duplicates
+			for ( unsigned int i = 0; i < Type::NumStorageClass; i += 1 ) { // find duplicates
 				if ( storageClasses[i] && src->storageClasses[i] ) {
-					appendError( error, string( "duplicate " ) + StorageClasses::Names[i] );
+					appendError( error, string( "duplicate " ) + Type::StorageClasses::Names[i] );
 				} // if
 			} // for
 			// src is the new item being added and has a single bit
 		} else if ( ! src->storageClasses.is_threadlocal ) { // conflict ?
-			appendError( error, string( "conflicting " ) + StorageClasses::Names[ffs( storageClasses.val ) - 1] +
-						 " & " + StorageClasses::Names[ffs( src->storageClasses.val ) - 1] );
+			appendError( error, string( "conflicting " ) + Type::StorageClasses::Names[ffs( storageClasses.val ) - 1] +
+						 " & " + Type::StorageClasses::Names[ffs( src->storageClasses.val ) - 1] );
 			src->storageClasses.val = 0;				// FIX to preserve invariant of one basic storage specifier
 		} // if
@@ -970,5 +969,5 @@
 				} else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
 					StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
-					auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
+					auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
 					obj->location = cur->location;
 					* out++ = obj;
@@ -976,5 +975,5 @@
 				} else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
 					UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
-					auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
+					auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
 					obj->location = cur->location;
 					* out++ = obj;
@@ -1023,5 +1022,5 @@
 		assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." );
 		assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
-		TypeDecl * ret = new TypeDecl( *name, DeclarationNode::StorageClasses(), nullptr, kindMap[ variable.tyClass ] );
+		TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ] );
 		buildList( variable.assertions, ret->get_assertions() );
 		return ret;
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/Parser/ParseNode.h	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 23:31:02 2017
-// Update Count     : 770
+// Last Modified On : Thu Mar 16 07:46:33 2017
+// Update Count     : 772
 //
 
@@ -201,33 +201,4 @@
 class DeclarationNode : public ParseNode {
   public:
-	// These must remain in the same order as the corresponding DeclarationNode names.
-
-	enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
-	union StorageClasses {
-		static const char * Names[];
-		unsigned int val;
-		struct {
-			bool is_extern : 1;
-			bool is_static : 1;
-			bool is_auto : 1;
-			bool is_register : 1;
-			bool is_threadlocal : 1;
-		};
-
-		StorageClasses() : val( 0 ) {}
-		StorageClasses( unsigned int val ) : val( val ) {}
-		bool operator[]( unsigned int i ) const { return val & (1 << i); }
-		bool any() const { return val != 0; }
-		void print( std::ostream & os ) const {
-			if ( (*this).any() ) {						// any storage classes ?
-				for ( unsigned int i = 0; i < NumStorageClass; i += 1 ) {
-					if ( (*this)[i] ) {
-						os << StorageClasses::Names[i] << ' ';
-					} // if
-				} // for
-			} // if
-		}
-	}; // StorageClasses
-
 	enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
 	union FuncSpecifiers {
@@ -270,5 +241,5 @@
 	static const char * builtinTypeNames[];
 
-	static DeclarationNode * newStorageClass( StorageClasses );
+	static DeclarationNode * newStorageClass( Type::StorageClasses );
 	static DeclarationNode * newFuncSpecifier( FuncSpecifiers );
 	static DeclarationNode * newTypeQualifier( Type::Qualifiers );
@@ -368,5 +339,5 @@
 	TypeData * type;
 
-	StorageClasses storageClasses;
+	Type::StorageClasses storageClasses;
 	FuncSpecifiers funcSpecs;
 
Index: src/Parser/TypeData.cc
===================================================================
--- src/Parser/TypeData.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/Parser/TypeData.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 22:53:04 2017
-// Update Count     : 557
+// Last Modified On : Thu Mar 16 07:54:50 2017
+// Update Count     : 558
 //
 
@@ -398,24 +398,24 @@
 			// add dtor:  void ^?{}(T *)
 			FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
-			dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
-			td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) );
+			dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+			td->get_assertions().push_front( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) );
 
 			// add copy ctor:  void ?{}(T *, T)
 			FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
-			copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
-			copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-			td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) );
+			copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+			copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+			td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) );
 
 			// add default ctor:  void ?{}(T *)
 			FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
-			ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
-			td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) );
+			ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+			td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) );
 
 			// add assignment operator:  T * ?=?(T *, T)
 			FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
-			assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
-			assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-			assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-			td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) );
+			assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+			assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+			assignType->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+			td->get_assertions().push_front( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) );
 		} // if
 	} // for
@@ -726,5 +726,5 @@
 } // buildAggInst
 
-NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClasses scs ) {
+NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs ) {
 	assert( td->kind == TypeData::Symbolic );
 	NamedTypeDecl * ret;
@@ -778,5 +778,5 @@
 } // buildTypeof
 
-Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClasses scs, Expression * bitfieldWidth, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
+Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
 	if ( td->kind == TypeData::Function ) {
 		if ( td->function.idList ) {					// KR function ?
@@ -814,8 +814,8 @@
 			break;
 		  default:
-			ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", DeclarationNode::StorageClasses(), nullptr, DeclarationNode::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
+			ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", Type::StorageClasses(), nullptr, DeclarationNode::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
 		} // switch
 	} else {
-		ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
+		ft->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
 	} // if
 	return ft;
Index: src/Parser/TypeData.h
===================================================================
--- src/Parser/TypeData.h	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/Parser/TypeData.h	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 22:10:23 2017
-// Update Count     : 183
+// Last Modified On : Thu Mar 16 07:53:41 2017
+// Update Count     : 184
 //
 
@@ -109,5 +109,5 @@
 TupleType * buildTuple( const TypeData * );
 TypeofType * buildTypeof( const TypeData * );
-Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClasses, Expression *, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
+Declaration * buildDecl( const TypeData *, const std::string &, Type::StorageClasses, Expression *, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
 FunctionType * buildFunction( const TypeData * );
 void buildKRFunction( const TypeData::Function_t & function );
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/Parser/parser.yy	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 22:06:22 2017
-// Update Count     : 2308
+// Last Modified On : Thu Mar 16 08:00:59 2017
+// Update Count     : 2309
 //
 
@@ -1449,13 +1449,13 @@
 storage_class:
 	EXTERN
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
+		{ $$ = DeclarationNode::newStorageClass( Type::Extern ); }
 	| STATIC
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
+		{ $$ = DeclarationNode::newStorageClass( Type::Static ); }
 	| AUTO
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
+		{ $$ = DeclarationNode::newStorageClass( Type::Auto ); }
 	| REGISTER
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
+		{ $$ = DeclarationNode::newStorageClass( Type::Register ); }
 	| THREADLOCAL										// C11
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
+		{ $$ = DeclarationNode::newStorageClass( Type::Threadlocal ); }
 		// Put function specifiers here to simplify parsing rules, but separate them semantically.
 	| INLINE											// C99
Index: src/ResolvExpr/Unify.cc
===================================================================
--- src/ResolvExpr/Unify.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/ResolvExpr/Unify.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 12:27:10 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar  6 23:37:38 2017
-// Update Count     : 39
+// Last Modified On : Thu Mar 16 07:59:59 2017
+// Update Count     : 40
 //
 
@@ -541,5 +541,5 @@
 			flatten( dcl->get_type(), back_inserter( types ) );
 			for ( Type * t : types ) {
-				dst.push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, t, nullptr ) );
+				dst.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::C, nullptr, t, nullptr ) );
 			}
 			delete dcl;
Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SymTab/Autogen.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Thu Mar 03 15:45:56 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 14 07:45:00 2017
-// Update Count     : 54
+// Last Modified On : Thu Mar 16 08:03:35 2017
+// Update Count     : 56
 //
 
@@ -125,5 +125,5 @@
 	FunctionType * genDefaultType( Type * paramType ) {
 		FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
-		ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr );
+		ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr );
 		ftype->get_parameters().push_back( dstParam );
 
@@ -134,5 +134,5 @@
 	FunctionType * genCopyType( Type * paramType ) {
 		FunctionType *ftype = genDefaultType( paramType );
-		ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
+		ObjectDecl *srcParam = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
 		ftype->get_parameters().push_back( srcParam );
 		return ftype;
@@ -142,5 +142,5 @@
 	FunctionType * genAssignType( Type * paramType ) {
 		FunctionType *ftype = genCopyType( paramType );
-		ObjectDecl *returnVal = new ObjectDecl( "_ret", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
+		ObjectDecl *returnVal = new ObjectDecl( "_ret", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
 		ftype->get_returnVals().push_back( returnVal );
 		return ftype;
@@ -162,5 +162,5 @@
 		// because each unit generates copies of the default routines for each aggregate.
 //		DeclarationNode::StorageClass sc = functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static;
-		DeclarationNode::StorageClasses scs = functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::Static );
+		Type::StorageClasses scs = functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static );
 		LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen;
 		FunctionDecl * decl = new FunctionDecl( fname, scs, spec, ftype, new CompoundStmt( noLabels ),
@@ -460,5 +460,5 @@
 					continue;
 				}
-				memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) );
+				memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), Type::StorageClasses(), LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) );
 				FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting );
 				makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor, isDynamicLayout );
@@ -540,5 +540,5 @@
 		for ( Declaration * member : aggregateDecl->get_members() ) {
 			if ( DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member ) ) {
-				ObjectDecl * srcParam = new ObjectDecl( "src", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 );
+				ObjectDecl * srcParam = new ObjectDecl( "src", Type::StorageClasses(), LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 );
 
 				FunctionType * memCtorType = ctorType->clone();
@@ -605,6 +605,6 @@
 		TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
 		typeInst->set_baseType( typeDecl );
-		ObjectDecl *src = new ObjectDecl( "_src", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, typeInst->clone(), nullptr );
-		ObjectDecl *dst = new ObjectDecl( "_dst", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), typeInst->clone() ), nullptr );
+		ObjectDecl *src = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, typeInst->clone(), nullptr );
+		ObjectDecl *dst = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), typeInst->clone() ), nullptr );
 
 		std::list< Statement * > stmts;
@@ -618,5 +618,5 @@
 		} // if
 		FunctionType *type = new FunctionType( Type::Qualifiers(), false );
-		type->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, typeInst, 0 ) );
+		type->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, typeInst, 0 ) );
 		type->get_parameters().push_back( dst );
 		type->get_parameters().push_back( src );
@@ -717,13 +717,13 @@
 			if ( TypeInstType * ty = dynamic_cast< TypeInstType * >( t ) ) {
 				if ( ! done.count( ty->get_baseType() ) ) {
-					TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), DeclarationNode::StorageClasses(), nullptr, TypeDecl::Any );
+					TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), Type::StorageClasses(), nullptr, TypeDecl::Any );
 					TypeInstType * inst = new TypeInstType( Type::Qualifiers(), newDecl->get_name(), newDecl );
-					newDecl->get_assertions().push_back( new FunctionDecl( "?=?", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr,
+					newDecl->get_assertions().push_back( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr,
 																		   std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ) );
-					newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
+					newDecl->get_assertions().push_back( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
 																		   std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ) );
-					newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genCopyType( inst ), nullptr,
+					newDecl->get_assertions().push_back( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, genCopyType( inst ), nullptr,
 																		   std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ) );
-					newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
+					newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
 																		   std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ) );
 					typeParams.push_back( newDecl );
Index: src/SymTab/Autogen.h
===================================================================
--- src/SymTab/Autogen.h	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SymTab/Autogen.h	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 14 23:13:28 2017
-// Update Count     : 7
+// Last Modified On : Thu Mar 16 07:51:39 2017
+// Update Count     : 8
 //
 
@@ -103,5 +103,5 @@
 		}
 
-		ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
+		ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
 
 		UntypedExpr *cond = new UntypedExpr( cmp );
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SymTab/Validate.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 14 23:30:27 2017
-// Update Count     : 350
+// Last Modified On : Thu Mar 16 08:02:54 2017
+// Update Count     : 351
 //
 
@@ -208,5 +208,5 @@
 
 	class CompoundLiteral final : public GenPoly::DeclMutator {
-		DeclarationNode::StorageClasses storageClasses;
+		Type::StorageClasses storageClasses;
 
 		using GenPoly::DeclMutator::mutate;
@@ -754,5 +754,5 @@
 				type = new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() );
 			} // if
-			TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), DeclarationNode::StorageClasses(), type ) );
+			TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), Type::StorageClasses(), type ) );
 			typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel );
 		} // if
@@ -857,5 +857,5 @@
 			TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
 			// ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false.
-			ObjectDecl * newRet = new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
+			ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
 			deleteAll( retVals );
 			retVals.clear();
Index: src/SynTree/AggregateDecl.cc
===================================================================
--- src/SynTree/AggregateDecl.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SynTree/AggregateDecl.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 23:56:39 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:31:47 2017
-// Update Count     : 19
+// Last Modified On : Thu Mar 16 07:49:07 2017
+// Update Count     : 20
 //
 
@@ -20,5 +20,5 @@
 
 
-AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes ) : Parent( name, DeclarationNode::StorageClasses(), LinkageSpec::Cforall ), body( false ), attributes( attributes ) {
+AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes ) : Parent( name, Type::StorageClasses(), LinkageSpec::Cforall ), body( false ), attributes( attributes ) {
 }
 
Index: src/SynTree/Declaration.cc
===================================================================
--- src/SynTree/Declaration.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SynTree/Declaration.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:31:11 2017
-// Update Count     : 23
+// Last Modified On : Thu Mar 16 07:49:18 2017
+// Update Count     : 24
 //
 
@@ -27,5 +27,5 @@
 static IdMapType idMap;
 
-Declaration::Declaration( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage )
+Declaration::Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage )
 		: name( name ), storageClasses( scs ), linkage( linkage ), uniqueId( 0 ) {
 }
@@ -66,5 +66,5 @@
 
 
-AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", DeclarationNode::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {
+AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {
 }
 
Index: src/SynTree/Declaration.h
===================================================================
--- src/SynTree/Declaration.h	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SynTree/Declaration.h	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:40:42 2017
-// Update Count     : 113
+// Last Modified On : Thu Mar 16 07:48:23 2017
+// Update Count     : 117
 //
 
@@ -28,5 +28,5 @@
 class Declaration : public BaseSyntaxNode {
   public:
-	Declaration( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage );
+	Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
 	Declaration( const Declaration &other );
 	virtual ~Declaration();
@@ -35,5 +35,5 @@
 	void set_name( std::string newValue ) { name = newValue; }
 
-	DeclarationNode::StorageClasses get_storageClasses() const { return storageClasses; }
+	Type::StorageClasses get_storageClasses() const { return storageClasses; }
 
 	LinkageSpec::Spec get_linkage() const { return linkage; }
@@ -56,5 +56,5 @@
   private:
 	std::string name;
-	DeclarationNode::StorageClasses storageClasses;
+	Type::StorageClasses storageClasses;
 	LinkageSpec::Spec linkage;
 	UniqueId uniqueId;
@@ -64,5 +64,5 @@
 class DeclarationWithType : public Declaration {
   public:
-	DeclarationWithType( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpecifiers fs );
+	DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpecifiers fs );
 	DeclarationWithType( const DeclarationWithType &other );
 	virtual ~DeclarationWithType();
@@ -104,5 +104,5 @@
 	typedef DeclarationWithType Parent;
   public:
-	ObjectDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
+	ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
 				const std::list< Attribute * > attributes = std::list< Attribute * >(), DeclarationNode::FuncSpecifiers fs = DeclarationNode::FuncSpecifiers() );
 	ObjectDecl( const ObjectDecl &other );
@@ -132,5 +132,5 @@
 	typedef DeclarationWithType Parent;
   public:
-	FunctionDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
+	FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
 				  const std::list< Attribute * > attributes = std::list< Attribute * >(), DeclarationNode::FuncSpecifiers fs = DeclarationNode::FuncSpecifiers() );
 	FunctionDecl( const FunctionDecl &other );
@@ -158,5 +158,5 @@
 	typedef Declaration Parent;
   public:
-	NamedTypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type );
+	NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *type );
 	NamedTypeDecl( const NamedTypeDecl &other );
 	virtual ~NamedTypeDecl();
@@ -193,5 +193,5 @@
 	};
 
-	TypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type, Kind kind );
+	TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind );
 	TypeDecl( const TypeDecl &other );
 
@@ -214,5 +214,5 @@
 	typedef NamedTypeDecl Parent;
   public:
-	TypedefDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type ) : Parent( name, scs, type ) {}
+	TypedefDecl( const std::string &name, Type::StorageClasses scs, Type *type ) : Parent( name, scs, type ) {}
 	TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
 
Index: src/SynTree/DeclarationWithType.cc
===================================================================
--- src/SynTree/DeclarationWithType.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SynTree/DeclarationWithType.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:32:14 2017
-// Update Count     : 23
+// Last Modified On : Thu Mar 16 07:49:27 2017
+// Update Count     : 24
 //
 
@@ -19,5 +19,5 @@
 #include "Common/utility.h"
 
-DeclarationWithType::DeclarationWithType( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpecifiers fs )
+DeclarationWithType::DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpecifiers fs )
 	: Declaration( name, scs, linkage ), asmName( nullptr ), attributes( attributes ), fs( fs ) {
 }
Index: src/SynTree/FunctionDecl.cc
===================================================================
--- src/SynTree/FunctionDecl.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SynTree/FunctionDecl.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 23:33:43 2017
-// Update Count     : 72
+// Last Modified On : Thu Mar 16 07:49:35 2017
+// Update Count     : 73
 //
 
@@ -26,5 +26,5 @@
 extern bool translation_unit_nomain;
 
-FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::list< Attribute * > attributes, DeclarationNode::FuncSpecifiers fs )
+FunctionDecl::FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::list< Attribute * > attributes, DeclarationNode::FuncSpecifiers fs )
 	: Parent( name, scs, linkage, attributes, fs ), type( type ), statements( statements ) {
 	// hack forcing the function "main" to have Cforall linkage to replace main even if it is inside an extern
Index: src/SynTree/NamedTypeDecl.cc
===================================================================
--- src/SynTree/NamedTypeDecl.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SynTree/NamedTypeDecl.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 23:25:41 2017
-// Update Count     : 12
+// Last Modified On : Thu Mar 16 07:49:44 2017
+// Update Count     : 13
 //
 
@@ -18,5 +18,5 @@
 #include "Common/utility.h"
 
-NamedTypeDecl::NamedTypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *base )
+NamedTypeDecl::NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *base )
 	: Parent( name, scs, LinkageSpec::Cforall ), base( base ) {}
 
Index: src/SynTree/ObjectDecl.cc
===================================================================
--- src/SynTree/ObjectDecl.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SynTree/ObjectDecl.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 23:26:22 2017
-// Update Count     : 57
+// Last Modified On : Thu Mar 16 07:49:51 2017
+// Update Count     : 58
 //
 
@@ -22,5 +22,5 @@
 #include "Statement.h"
 
-ObjectDecl::ObjectDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, DeclarationNode::FuncSpecifiers fs )
+ObjectDecl::ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, DeclarationNode::FuncSpecifiers fs )
 	: Parent( name, scs, linkage, attributes, fs ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) {
 }
Index: src/SynTree/Type.cc
===================================================================
--- src/SynTree/Type.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SynTree/Type.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 23:14:35 2017
-// Update Count     : 19
+// Last Modified On : Thu Mar 16 07:57:45 2017
+// Update Count     : 20
 //
 
@@ -59,4 +59,6 @@
 }
 
+// These must remain in the same order as the corresponding bit fields.
+const char * Type::StorageClasses::Names[] = { "extern", "static", "auto", "register", "_Thread_local" };
 const char * Type::Qualifiers::Names[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" };
 
Index: src/SynTree/Type.h
===================================================================
--- src/SynTree/Type.h	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SynTree/Type.h	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 23:28:33 2017
-// Update Count     : 89
+// Last Modified On : Thu Mar 16 07:45:29 2017
+// Update Count     : 90
 //
 
@@ -24,4 +24,33 @@
 class Type : public BaseSyntaxNode {
   public:
+	// enum must remain in the same order as the corresponding bit fields.
+
+	enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
+	union StorageClasses {
+		static const char * Names[];
+		unsigned int val;
+		struct {
+			bool is_extern : 1;
+			bool is_static : 1;
+			bool is_auto : 1;
+			bool is_register : 1;
+			bool is_threadlocal : 1;
+		};
+
+		StorageClasses() : val( 0 ) {}
+		StorageClasses( unsigned int val ) : val( val ) {}
+		bool operator[]( unsigned int i ) const { return val & (1 << i); }
+		bool any() const { return val != 0; }
+		void print( std::ostream & os ) const {
+			if ( (*this).any() ) {						// any storage classes ?
+				for ( unsigned int i = 0; i < NumStorageClass; i += 1 ) {
+					if ( (*this)[i] ) {
+						os << StorageClasses::Names[i] << ' ';
+					} // if
+				} // for
+			} // if
+		}
+	}; // StorageClasses
+
 	enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
 	union Qualifiers {
Index: src/SynTree/TypeDecl.cc
===================================================================
--- src/SynTree/TypeDecl.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/SynTree/TypeDecl.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:39:09 2017
-// Update Count     : 4
+// Last Modified On : Thu Mar 16 07:49:58 2017
+// Update Count     : 5
 //
 
@@ -18,5 +18,5 @@
 #include "Common/utility.h"
 
-TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type, Kind kind ) : Parent( name, scs, type ), kind( kind ), sized( kind == Any || kind == Ttype ) {
+TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind ) : Parent( name, scs, type ), kind( kind ), sized( kind == Any || kind == Ttype ) {
 }
 
Index: src/Tuples/TupleAssignment.cc
===================================================================
--- src/Tuples/TupleAssignment.cc	(revision 6e8bd434e6c282eabe8c3f0bd2232d54731d7adf)
+++ src/Tuples/TupleAssignment.cc	(revision 64b6913871619f338743c65cc7ee2667ee499c05)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 08:00:44 2017
-// Update Count     : 6
+// Last Modified On : Thu Mar 16 08:04:51 2017
+// Update Count     : 7
 //
 
@@ -240,5 +240,5 @@
 	ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
 		assert( expr->has_result() && ! expr->get_result()->isVoid() );
-		ObjectDecl * ret = new ObjectDecl( namer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
+		ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
 		ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
 		ret->set_init( ctorInit );