Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision 10a7775d07dcc9d19f88786e6be9a198720e9cac)
+++ src/InitTweak/InitTweak.cc	(revision 3689906e06b63e9feee3078d0ca524ff10446930)
@@ -7,144 +7,148 @@
 
 namespace InitTweak {
-  namespace {
-    class HasDesignations : public Visitor {
-    public:
-      bool hasDesignations = false;
-      template<typename Init>
-      void handleInit( Init * init ) {
-        if ( ! init->get_designators().empty() ) hasDesignations = true;
-        else Visitor::visit( init );
-      }
-      virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); }
-      virtual void visit( ListInit * listInit ) { handleInit( listInit); }
-    };
+	namespace {
+		class HasDesignations : public Visitor {
+		public:
+			bool hasDesignations = false;
+			template<typename Init>
+			void handleInit( Init * init ) {
+				if ( ! init->get_designators().empty() ) hasDesignations = true;
+				else Visitor::visit( init );
+			}
+			virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); }
+			virtual void visit( ListInit * listInit ) { handleInit( listInit); }
+		};
 
-    class InitExpander : public Visitor {
-      public:
-      InitExpander() {}
-      virtual void visit( SingleInit * singleInit );
-      virtual void visit( ListInit * listInit );
-      std::list< Expression * > argList;
-    };
+		class InitExpander : public Visitor {
+			public:
+			InitExpander() {}
+			virtual void visit( SingleInit * singleInit );
+			virtual void visit( ListInit * listInit );
+			std::list< Expression * > argList;
+		};
 
-    void InitExpander::visit( SingleInit * singleInit ) {
-      argList.push_back( singleInit->get_value()->clone() );
-    }
+		void InitExpander::visit( SingleInit * singleInit ) {
+			argList.push_back( singleInit->get_value()->clone() );
+		}
 
-    void InitExpander::visit( ListInit * listInit ) {
-      // xxx - for now, assume no nested list inits
-      std::list<Initializer*>::iterator it = listInit->begin_initializers();
-      for ( ; it != listInit->end_initializers(); ++it ) {
-        (*it)->accept( *this );
-      }
-    }
-  }
+		void InitExpander::visit( ListInit * listInit ) {
+			// xxx - for now, assume no nested list inits
+			std::list<Initializer*>::iterator it = listInit->begin_initializers();
+			for ( ; it != listInit->end_initializers(); ++it ) {
+				(*it)->accept( *this );
+			}
+		}
+	}
 
-  std::list< Expression * > makeInitList( Initializer * init ) {
-    InitExpander expander;
-    maybeAccept( init, expander );
-    return expander.argList;
-  }
+	std::list< Expression * > makeInitList( Initializer * init ) {
+		InitExpander expander;
+		maybeAccept( init, expander );
+		return expander.argList;
+	}
 
-  bool isDesignated( Initializer * init ) {
-    HasDesignations finder;
-    maybeAccept( init, finder );
-    return finder.hasDesignations;
-  }
+	bool isDesignated( Initializer * init ) {
+		HasDesignations finder;
+		maybeAccept( init, finder );
+		return finder.hasDesignations;
+	}
 
-  bool tryConstruct( ObjectDecl * objDecl ) {
-    return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
-      (objDecl->get_init() == NULL ||
-        ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) &&
-      ! isDesignated( objDecl->get_init() );
-  }
+	bool tryConstruct( ObjectDecl * objDecl ) {
+		return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
+			(objDecl->get_init() == NULL ||
+				( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) &&
+			! isDesignated( objDecl->get_init() );
+	}
 
-  Expression * getCtorDtorCall( Statement * stmt ) {
-    if ( stmt == NULL ) return NULL;
-    if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
-      return exprStmt->get_expr();
-    } else if ( CompoundStmt * compoundStmt = dynamic_cast< CompoundStmt * >( stmt ) ) {
-      // could also be a compound statement with a loop, in the case of an array
-      assert( compoundStmt->get_kids().size() == 2 ); // loop variable and loop
-      ForStmt * forStmt = dynamic_cast< ForStmt * >( compoundStmt->get_kids().back() );
-      assert( forStmt && forStmt->get_body() );
-      return getCtorDtorCall( forStmt->get_body() );
-    } if ( ImplicitCtorDtorStmt * impCtorDtorStmt = dynamic_cast< ImplicitCtorDtorStmt * > ( stmt ) ) {
-      return getCtorDtorCall( impCtorDtorStmt->get_callStmt() );
-    } else {
-      // should never get here
-      assert( false && "encountered unknown call statement" );
-    }
-  }
+	Expression * getCtorDtorCall( Statement * stmt ) {
+		if ( stmt == NULL ) return NULL;
+		if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
+			return exprStmt->get_expr();
+		} else if ( CompoundStmt * compoundStmt = dynamic_cast< CompoundStmt * >( stmt ) ) {
+			// could also be a compound statement with a loop, in the case of an array
+			assert( compoundStmt->get_kids().size() == 2 ); // loop variable and loop
+			ForStmt * forStmt = dynamic_cast< ForStmt * >( compoundStmt->get_kids().back() );
+			assert( forStmt && forStmt->get_body() );
+			return getCtorDtorCall( forStmt->get_body() );
+		} if ( ImplicitCtorDtorStmt * impCtorDtorStmt = dynamic_cast< ImplicitCtorDtorStmt * > ( stmt ) ) {
+			return getCtorDtorCall( impCtorDtorStmt->get_callStmt() );
+		} else {
+			// should never get here
+			assert( false && "encountered unknown call statement" );
+		}
+	}
 
-  bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
-    Expression * callExpr = getCtorDtorCall( stmt );
-    if ( ! callExpr ) return false;
-    ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr );
-    assert( appExpr );
-    VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
-    assert( function );
-    // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
-    // will call all member dtors, and some members may have a user defined dtor.
-    FunctionType * funcType = GenPoly::getFunctionType( function->get_var()->get_type() );
-    assert( funcType );
-    return function->get_var()->get_linkage() == LinkageSpec::Intrinsic && funcType->get_parameters().size() == 1;
-  }
+	bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
+		Expression * callExpr = getCtorDtorCall( stmt );
+		if ( ! callExpr ) return false;
+		ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr );
+		assert( appExpr );
+		VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
+		assert( function );
+		// check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
+		// will call all member dtors, and some members may have a user defined dtor.
+		FunctionType * funcType = GenPoly::getFunctionType( function->get_var()->get_type() );
+		assert( funcType );
+		return function->get_var()->get_linkage() == LinkageSpec::Intrinsic && funcType->get_parameters().size() == 1;
+	}
 
-  namespace {
-    template<typename CallExpr>
-    Expression * callArg( CallExpr * callExpr, unsigned int pos ) {
-      if ( pos >= callExpr->get_args().size() ) assert( false && "asking for argument that doesn't exist. Return NULL/throw exception?" );
-      for ( Expression * arg : callExpr->get_args() ) {
-        if ( pos == 0 ) return arg;
-        pos--;
-      }
-      assert( false );
-    }
-  }
+	namespace {
+		template<typename CallExpr>
+		Expression *& callArg( CallExpr * callExpr, unsigned int pos ) {
+			if ( pos >= callExpr->get_args().size() ) assert( false && "asking for argument that doesn't exist. Return NULL/throw exception?" );
+			for ( Expression *& arg : callExpr->get_args() ) {
+				if ( pos == 0 ) return arg;
+				pos--;
+			}
+			assert( false );
+		}
+	}
 
-  Expression * getCallArg( Expression * callExpr, unsigned int pos ) {
-    if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr ) ) {
-      return callArg( appExpr, pos );
-    } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( callExpr ) ) {
-      return callArg( untypedExpr, pos );
-    } else {
-      assert( false && "Unexpected expression type passed to getCallArg" );
-    }
-  }
+	Expression *& getCallArg( Expression * callExpr, unsigned int pos ) {
+		if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr ) ) {
+			return callArg( appExpr, pos );
+		} else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( callExpr ) ) {
+			return callArg( untypedExpr, pos );
+		} else {
+			assert( false && "Unexpected expression type passed to getCallArg" );
+		}
+	}
 
-  namespace {
-    template<typename CallExpr>
-    std::string funcName( CallExpr * expr ) {
-      Expression * func = expr->get_function();
-      if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( func ) ) {
-        return nameExpr->get_name();
-      } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
-        return varExpr->get_var()->get_name();
-      } else {
-        assert( false && "Unexpected expression type being called as a function in call expression" );
-      }
-    }
-  }
+	namespace {
+		template<typename CallExpr>
+		std::string funcName( CallExpr * expr ) {
+			Expression * func = expr->get_function();
+			if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( func ) ) {
+				return nameExpr->get_name();
+			} else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
+				return varExpr->get_var()->get_name();
+			} else {
+				assert( false && "Unexpected expression type being called as a function in call expression" );
+			}
+		}
+	}
 
-  std::string getFunctionName( Expression * expr ) {
-    if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
-      return funcName( appExpr );
-    } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * > ( expr ) ) {
-      return funcName( untypedExpr );
-    } else {
-      assert( false && "Unexpected expression type passed to getFunctionName" );
-    }
-  }
+	std::string getFunctionName( Expression * expr ) {
+		if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
+			return funcName( appExpr );
+		} else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * > ( expr ) ) {
+			return funcName( untypedExpr );
+		} else {
+			assert( false && "Unexpected expression type passed to getFunctionName" );
+		}
+	}
 
-  Type * getPointerBase( Type * type ) {
-    if ( PointerType * ptrType = dynamic_cast< PointerType * >( type ) ) {
-      return ptrType->get_base();
-    } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
-      return arrayType->get_base();
-    } else {
-      return NULL;
-    }
-  }
+	Type * getPointerBase( Type * type ) {
+		if ( PointerType * ptrType = dynamic_cast< PointerType * >( type ) ) {
+			return ptrType->get_base();
+		} else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
+			return arrayType->get_base();
+		} else {
+			return NULL;
+		}
+	}
 
+	Type * isPointerType( Type * type ) {
+		if ( getPointerBase( type ) ) return type;
+		else return NULL;
+	}
 }