Index: src/SynTree/Declaration.h
===================================================================
--- src/SynTree/Declaration.h	(revision 312029a731fd1bf1cdd24d3e1d75abf51eb09d71)
+++ src/SynTree/Declaration.h	(revision 1e2de8924cc4f4405c7a1934e6489c7f028a5d6f)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Dec 11 16:48:20 2019
-// Update Count     : 149
+// Last Modified On : Fri Dec 13 23:11:22 2019
+// Update Count     : 157
 //
 
@@ -24,5 +24,5 @@
 #include "BaseSyntaxNode.h"      // for BaseSyntaxNode
 #include "Mutator.h"             // for Mutator
-#include "Parser/LinkageSpec.h"  // for Spec, Cforall
+#include "LinkageSpec.h"         // for Spec, Cforall
 #include "SynTree.h"             // for UniqueId
 #include "SynTree/Type.h"        // for Type, Type::StorageClasses, Type::Fu...
@@ -43,9 +43,9 @@
 	bool extension = false;
 
-	Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
-	Declaration( const Declaration &other );
+	Declaration( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
+	Declaration( const Declaration & other );
 	virtual ~Declaration();
 
-	const std::string &get_name() const { return name; }
+	const std::string & get_name() const { return name; }
 	void set_name( std::string newValue ) { name = newValue; }
 
@@ -58,13 +58,13 @@
 
 	bool get_extension() const { return extension; }
-	Declaration *set_extension( bool exten ) { extension = exten; return this; }
+	Declaration * set_extension( bool exten ) { extension = exten; return this; }
 
 	void fixUniqueId( void );
-	virtual Declaration *clone() const override = 0;
+	virtual Declaration * clone() const override = 0;
 	virtual void accept( Visitor & v ) override = 0;
 	virtual void accept( Visitor & v ) const override = 0;
-	virtual Declaration *acceptMutator( Mutator &m ) override = 0;
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
-	virtual void printShort( std::ostream &os, Indenter indent = {} ) const = 0;
+	virtual Declaration * acceptMutator( Mutator & m ) override = 0;
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override = 0;
+	virtual void printShort( std::ostream & os, Indenter indent = {} ) const = 0;
 
 	UniqueId uniqueId;
@@ -80,10 +80,10 @@
 	int scopeLevel = 0;
 
-	Expression *asmName;
+	Expression * asmName;
 	std::list< Attribute * > attributes;
 	bool isDeleted = false;
 
-	DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
-	DeclarationWithType( const DeclarationWithType &other );
+	DeclarationWithType( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
+	DeclarationWithType( const DeclarationWithType & other );
 	virtual ~DeclarationWithType();
 
@@ -96,6 +96,6 @@
 	DeclarationWithType * set_scopeLevel( int newValue ) { scopeLevel = newValue; return this; }
 
-	Expression *get_asmName() const { return asmName; }
-	DeclarationWithType * set_asmName( Expression *newValue ) { asmName = newValue; return this; }
+	Expression * get_asmName() const { return asmName; }
+	DeclarationWithType * set_asmName( Expression * newValue ) { asmName = newValue; return this; }
 
 	std::list< Attribute * >& get_attributes() { return attributes; }
@@ -105,6 +105,6 @@
 	//void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
 
-	virtual DeclarationWithType *clone() const override = 0;
-	virtual DeclarationWithType *acceptMutator( Mutator &m )  override = 0;
+	virtual DeclarationWithType * clone() const override = 0;
+	virtual DeclarationWithType * acceptMutator( Mutator & m )  override = 0;
 
 	virtual Type * get_type() const = 0;
@@ -118,30 +118,30 @@
 	typedef DeclarationWithType Parent;
   public:
-	Type *type;
-	Initializer *init;
-	Expression *bitfieldWidth;
-
-	ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
+	Type * type;
+	Initializer * init;
+	Expression * bitfieldWidth;
+
+	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 * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
-	ObjectDecl( const ObjectDecl &other );
+	ObjectDecl( const ObjectDecl & other );
 	virtual ~ObjectDecl();
 
 	virtual Type * get_type() const override { return type; }
-	virtual void set_type(Type *newType) override { type = newType; }
-
-	Initializer *get_init() const { return init; }
-	void set_init( Initializer *newValue ) { init = newValue; }
-
-	Expression *get_bitfieldWidth() const { return bitfieldWidth; }
-	void set_bitfieldWidth( Expression *newValue ) { bitfieldWidth = newValue; }
+	virtual void set_type(Type * newType) override { type = newType; }
+
+	Initializer * get_init() const { return init; }
+	void set_init( Initializer * newValue ) { init = newValue; }
+
+	Expression * get_bitfieldWidth() const { return bitfieldWidth; }
+	void set_bitfieldWidth( Expression * newValue ) { bitfieldWidth = newValue; }
 
 	static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init );
 
-	virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); }
-	virtual void accept( Visitor & v ) override { v.visit( this ); }
-	virtual void accept( Visitor & v ) const override { v.visit( this ); }
-	virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
-	virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
+	virtual ObjectDecl * clone() const override { return new ObjectDecl( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual void accept( Visitor & v ) const override { v.visit( this ); }
+	virtual DeclarationWithType * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+	virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -149,11 +149,11 @@
 	typedef DeclarationWithType Parent;
   public:
-	FunctionType *type;
-	CompoundStmt *statements;
+	FunctionType * type;
+	CompoundStmt * statements;
 	std::list< Expression * > withExprs;
 
-	FunctionDecl( const std::string &name, Type::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 * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
-	FunctionDecl( const FunctionDecl &other );
+	FunctionDecl( const FunctionDecl & other );
 	virtual ~FunctionDecl();
 
@@ -162,17 +162,17 @@
 
 	FunctionType * get_functionType() const { return type; }
-	void set_functionType( FunctionType *newValue ) { type = newValue; }
-	CompoundStmt *get_statements() const { return statements; }
-	void set_statements( CompoundStmt *newValue ) { statements = newValue; }
+	void set_functionType( FunctionType * newValue ) { type = newValue; }
+	CompoundStmt * get_statements() const { return statements; }
+	void set_statements( CompoundStmt * newValue ) { statements = newValue; }
 	bool has_body() const { return NULL != statements; }
 
 	static FunctionDecl * newFunction( const std::string & name, FunctionType * type, CompoundStmt * statements );
 
-	virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }
-	virtual void accept( Visitor & v ) override { v.visit( this ); }
-	virtual void accept( Visitor & v ) const override { v.visit( this ); }
-	virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
-	virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
+	virtual FunctionDecl * clone() const override { return new FunctionDecl( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual void accept( Visitor & v ) const override { v.visit( this ); }
+	virtual DeclarationWithType * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+	virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -180,22 +180,22 @@
 	typedef Declaration Parent;
   public:
-	Type *base;
-	std::list< TypeDecl* > parameters;
-	std::list< DeclarationWithType* > assertions;
-
-	NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *type );
-	NamedTypeDecl( const NamedTypeDecl &other );
+	Type * base;
+	std::list< TypeDecl * > parameters;
+	std::list< DeclarationWithType * > assertions;
+
+	NamedTypeDecl( const std::string & name, Type::StorageClasses scs, Type * type );
+	NamedTypeDecl( const NamedTypeDecl & other );
 	virtual ~NamedTypeDecl();
 
-	Type *get_base() const { return base; }
-	void set_base( Type *newValue ) { base = newValue; }
-	std::list< TypeDecl* >& get_parameters() { return parameters; }
-	std::list< DeclarationWithType* >& get_assertions() { return assertions; }
+	Type * get_base() const { return base; }
+	void set_base( Type * newValue ) { base = newValue; }
+	std::list< TypeDecl* > & get_parameters() { return parameters; }
+	std::list< DeclarationWithType * >& get_assertions() { return assertions; }
 
 	virtual const char * typeString() const = 0;
 
-	virtual NamedTypeDecl *clone() const override = 0;
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
-	virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
+	virtual NamedTypeDecl * clone() const override = 0;
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+	virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -203,26 +203,27 @@
 	typedef NamedTypeDecl Parent;
   public:
-	enum Kind { Dtype, Ftype, Ttype, NUMBER_OF_KINDS };
-
+	enum Kind { Dtype, Otype, Ftype, Ttype, NUMBER_OF_KINDS };
+
+	Kind kind;
+	bool sized;
 	Type * init;
-	bool sized;
 
 	/// Data extracted from a type decl
 	struct Data {
-		TypeDecl::Kind kind;
+		Kind kind;
 		bool isComplete;
 
-		Data() : kind( (TypeDecl::Kind)-1 ), isComplete( false ) {}
-		Data( TypeDecl * typeDecl ) : Data( typeDecl->get_kind(), typeDecl->isComplete() ) {}
+		Data() : kind( NUMBER_OF_KINDS ), isComplete( false ) {}
+		Data( const TypeDecl * typeDecl ) : Data( typeDecl->get_kind(), typeDecl->isComplete() ) {}
 		Data( Kind kind, bool isComplete ) : kind( kind ), isComplete( isComplete ) {}
-		Data( const Data& d1, const Data& d2 )
-		: kind( d1.kind ), isComplete ( d1.isComplete || d2.isComplete ) {}
-
-		bool operator==(const Data & other) const { return kind == other.kind && isComplete == other.isComplete; }
-		bool operator!=(const Data & other) const { return !(*this == other);}
+		Data( const Data & d1, const Data & d2 )
+			: kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {}
+
+		bool operator==( const Data & other ) const { return kind == other.kind && isComplete == other.isComplete; }
+		bool operator!=( const Data & other ) const { return !(*this == other);}
 	};
 
-	TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, bool sized, Type * init = nullptr );
-	TypeDecl( const TypeDecl &other );
+	TypeDecl( const std::string & name, Type::StorageClasses scs, Type * type, Kind kind, bool sized, Type * init = nullptr );
+	TypeDecl( const TypeDecl & other );
 	virtual ~TypeDecl();
 
@@ -239,11 +240,9 @@
 	virtual const char * genTypeString() const;
 
-	virtual TypeDecl *clone() const override { return new TypeDecl( *this ); }
-	virtual void accept( Visitor & v ) override { v.visit( this ); }
-	virtual void accept( Visitor & v ) const override { v.visit( this ); }
-	virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
-
-	Kind kind;
+	virtual TypeDecl * clone() const override { return new TypeDecl( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual void accept( Visitor & v ) const override { v.visit( this ); }
+	virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -251,15 +250,15 @@
 	typedef NamedTypeDecl Parent;
   public:
-	TypedefDecl( const std::string &name, CodeLocation location, Type::StorageClasses scs, Type *type, LinkageSpec::Spec spec = LinkageSpec::Cforall )
+	TypedefDecl( const std::string & name, CodeLocation location, Type::StorageClasses scs, Type * type, LinkageSpec::Spec spec = LinkageSpec::Cforall )
 		: Parent( name, scs, type ) { set_linkage( spec ); this->location = location; }
 
-	TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
-
-	virtual const char * typeString() const override;
-
-	virtual TypedefDecl *clone() const override { return new TypedefDecl( *this ); }
-	virtual void accept( Visitor & v ) override { v.visit( this ); }
-	virtual void accept( Visitor & v ) const override { v.visit( this ); }
-	virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	TypedefDecl( const TypedefDecl & other ) : Parent( other ) {}
+
+	virtual const char * typeString() const override;
+
+	virtual TypedefDecl * clone() const override { return new TypedefDecl( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual void accept( Visitor & v ) const override { v.visit( this ); }
+	virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
   private:
 };
@@ -277,6 +276,6 @@
 	AggregateDecl * parent = nullptr;
 
-	AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
-	AggregateDecl( const AggregateDecl &other );
+	AggregateDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
+	AggregateDecl( const AggregateDecl & other );
 	virtual ~AggregateDecl();
 
@@ -290,6 +289,6 @@
 	AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
 
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override final;
-	virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override final;
+	virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
   protected:
 	virtual const char * typeString() const = 0;
@@ -299,6 +298,6 @@
 	typedef AggregateDecl Parent;
   public:
-	StructDecl( const std::string &name, Aggregate kind = Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
-	StructDecl( const StructDecl &other ) : Parent( other ), kind( other.kind ) {}
+	StructDecl( const std::string & name, Aggregate kind = Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
+	StructDecl( const StructDecl & other ) : Parent( other ), kind( other.kind ) {}
 
 	bool is_coroutine() { return kind == Coroutine; }
@@ -306,8 +305,8 @@
 	bool is_thread() { return kind == Thread; }
 
-	virtual StructDecl *clone() const override { return new StructDecl( *this ); }
-	virtual void accept( Visitor & v ) override { v.visit( this ); }
-	virtual void accept( Visitor & v ) const override { v.visit( this ); }
-	virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual StructDecl * clone() const override { return new StructDecl( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual void accept( Visitor & v ) const override { v.visit( this ); }
+	virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
 	Aggregate kind;
   private:
@@ -318,11 +317,11 @@
 	typedef AggregateDecl Parent;
   public:
-	UnionDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
-	UnionDecl( const UnionDecl &other ) : Parent( other ) {}
-
-	virtual UnionDecl *clone() const override { return new UnionDecl( *this ); }
-	virtual void accept( Visitor & v ) override { v.visit( this ); }
-	virtual void accept( Visitor & v ) const override { v.visit( this ); }
-	virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	UnionDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
+	UnionDecl( const UnionDecl & other ) : Parent( other ) {}
+
+	virtual UnionDecl * clone() const override { return new UnionDecl( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual void accept( Visitor & v ) const override { v.visit( this ); }
+	virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
   private:
 	virtual const char * typeString() const override;
@@ -332,13 +331,13 @@
 	typedef AggregateDecl Parent;
   public:
-	EnumDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
-	EnumDecl( const EnumDecl &other ) : Parent( other ) {}
+	EnumDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
+	EnumDecl( const EnumDecl & other ) : Parent( other ) {}
 
 	bool valueOf( Declaration * enumerator, long long int & value );
 
-	virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
-	virtual void accept( Visitor & v ) override { v.visit( this ); }
-	virtual void accept( Visitor & v ) const override { v.visit( this ); }
-	virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual EnumDecl * clone() const override { return new EnumDecl( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual void accept( Visitor & v ) const override { v.visit( this ); }
+	virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
   private:
 	std::unordered_map< std::string, long long int > enumValues;
@@ -349,13 +348,13 @@
 	typedef AggregateDecl Parent;
   public:
-	TraitDecl( const std::string &name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, attributes, linkage ) {
+	TraitDecl( const std::string & name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, attributes, linkage ) {
 		assertf( attributes.empty(), "attribute unsupported for traits" );
 	}
-	TraitDecl( const TraitDecl &other ) : Parent( other ) {}
-
-	virtual TraitDecl *clone() const override { return new TraitDecl( *this ); }
-	virtual void accept( Visitor & v ) override { v.visit( this ); }
-	virtual void accept( Visitor & v ) const override { v.visit( this ); }
-	virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	TraitDecl( const TraitDecl & other ) : Parent( other ) {}
+
+	virtual TraitDecl * clone() const override { return new TraitDecl( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual void accept( Visitor & v ) const override { v.visit( this ); }
+	virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
   private:
 	virtual const char * typeString() const override;
@@ -381,19 +380,19 @@
 class AsmDecl : public Declaration {
   public:
-	AsmStmt *stmt;
-
-	AsmDecl( AsmStmt *stmt );
-	AsmDecl( const AsmDecl &other );
+	AsmStmt * stmt;
+
+	AsmDecl( AsmStmt * stmt );
+	AsmDecl( const AsmDecl & other );
 	virtual ~AsmDecl();
 
-	AsmStmt *get_stmt() { return stmt; }
-	void set_stmt( AsmStmt *newValue ) { stmt = newValue; }
-
-	virtual AsmDecl *clone() const override { return new AsmDecl( *this ); }
-	virtual void accept( Visitor & v ) override { v.visit( this ); }
-	virtual void accept( Visitor & v ) const override { v.visit( this ); }
-	virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
-	virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
+	AsmStmt * get_stmt() { return stmt; }
+	void set_stmt( AsmStmt * newValue ) { stmt = newValue; }
+
+	virtual AsmDecl * clone() const override { return new AsmDecl( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual void accept( Visitor & v ) const override { v.visit( this ); }
+	virtual AsmDecl * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+	virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -410,7 +409,7 @@
 	virtual void accept( Visitor & v ) override { v.visit( this ); }
 	virtual void accept( Visitor & v ) const override { v.visit( this ); }
-	virtual StaticAssertDecl * acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
-	virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
+	virtual StaticAssertDecl * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+	virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
 };