public override void WriteKeyword(Role role, string keyword)
		{
			if (lastWritten == LastWritten.KeywordOrIdentifier) {
				Space();
			}
			base.WriteKeyword(role, keyword);
			lastWritten = LastWritten.KeywordOrIdentifier;
		}

		public override void WriteIdentifier(Identifier identifier)
		{
			if (identifier.IsVerbatim) {
				if (lastWritten == LastWritten.KeywordOrIdentifier) {
					// this space is not strictly required, so we call Space()
					Space();
				}
			} else if (lastWritten == LastWritten.KeywordOrIdentifier) {
				// this space is strictly required, so we directly call the formatter
				base.Space();
			}
			base.WriteIdentifier(identifier);
			lastWritten = LastWritten.KeywordOrIdentifier;
		}

		public override void WriteIdentifier(Identifier identifier, TextTokenType tokenType)
		{
			if (identifier.IsVerbatim || CSharpOutputVisitor.IsKeyword(identifier.Name, identifier)) {
				if (lastWritten == LastWritten.KeywordOrIdentifier) {
					// this space is not strictly required, so we call Space()
					Space();
				}
			} else if (lastWritten == LastWritten.KeywordOrIdentifier) {
				// this space is strictly required, so we directly call the formatter
				base.Space();
			}
			base.WriteIdentifier(identifier, tokenType);
			lastWritten = LastWritten.KeywordOrIdentifier;
		}

        public override void WriteIdentifier(Identifier ident)
        {
            if(ident.IsVerbatim || ExpressoOutputWalker.IsKeyword(ident.Name, ident)){
                if(last_written == LastWritten.KeywordOrIdentifier){
                    // This space is not strictly required, so we delegate to Space()
                    Space();
                }
            }else if(last_written == LastWritten.KeywordOrIdentifier){
                // This space is strictly required, so we directly call the formatter
                base.Space();
            }

            base.WriteIdentifier(ident);
            last_written = LastWritten.KeywordOrIdentifier;
        }

/*		void WriteKeyword (string keyword, Role tokenRole)
		{
			WriteSpecialsUpToRole (tokenRole);
			if (lastWritten == LastWritten.KeywordOrIdentifier)
				formatter.Space ();
			formatter.WriteKeyword (keyword);
			lastWritten = LastWritten.KeywordOrIdentifier;
		}*/
		
		void WriteIdentifier(string identifier, Role<Identifier> identifierRole = null)
		{
			WriteSpecialsUpToRole(identifierRole ?? Roles.Identifier);
			if (IsKeyword(identifier, containerStack.Peek())) {
				if (lastWritten == LastWritten.KeywordOrIdentifier) {
					Space();
				}
				// this space is not strictly required, so we call Space()
				formatter.WriteToken("@");
			} else if (lastWritten == LastWritten.KeywordOrIdentifier) {
				formatter.Space();
				// this space is strictly required, so we directly call the formatter
			}
			formatter.WriteIdentifier(identifier);
			lastWritten = LastWritten.KeywordOrIdentifier;
		}

		void WriteKeyword(string token, Role tokenRole = null)
		{
			if (tokenRole != null) {
				WriteSpecialsUpToRole(tokenRole);
			}
			if (lastWritten == LastWritten.KeywordOrIdentifier) {
				formatter.Space();
			}
			formatter.WriteKeyword(token);
			lastWritten = LastWritten.KeywordOrIdentifier;
		}

		public void VisitPreProcessorDirective(PreProcessorDirective preProcessorDirective)
		{
			formatter.StartNode(preProcessorDirective);
			formatter.WritePreProcessorDirective(preProcessorDirective.Type, preProcessorDirective.Argument);
			formatter.EndNode(preProcessorDirective);
			lastWritten = LastWritten.Whitespace;
		}

		public void VisitComment(Comment comment)
		{
			if (lastWritten == LastWritten.Division) {
				// When there's a comment starting after a division operator
				// "1.0 / /*comment*/a", then we need to insert a space in front of the comment.
				formatter.Space();
			}
			formatter.StartNode(comment);
			formatter.WriteComment(comment.CommentType, comment.Content);
			formatter.EndNode(comment);
			lastWritten = LastWritten.Whitespace;
		}

		public void VisitArraySpecifier(ArraySpecifier arraySpecifier)
		{
			StartNode(arraySpecifier);
			WriteToken(Roles.LBracket);
			foreach (var comma in arraySpecifier.GetChildrenByRole(Roles.Comma)) {
				WriteSpecialsUpToNode(comma);
				formatter.WriteToken(",");
				lastWritten = LastWritten.Other;
			}
			WriteToken(Roles.RBracket);
			EndNode(arraySpecifier);
		}

		void CloseBrace(BraceStyle style)
		{
			WriteSpecialsUpToRole(Roles.RBrace);
			formatter.CloseBrace(style);
			lastWritten = LastWritten.Other;
		}

		void NewLine()
		{
			formatter.NewLine();
			lastWritten = LastWritten.Whitespace;
		}

		void WriteToken(string token, Role tokenRole)
		{
			WriteSpecialsUpToRole(tokenRole);
			// Avoid that two +, - or ? tokens are combined into a ++, -- or ?? token.
			// Note that we don't need to handle tokens like = because there's no valid
			// C# program that contains the single token twice in a row.
			// (for +, - and &, this can happen with unary operators;
			// for ?, this can happen in "a is int? ? b : c" or "a as int? ?? 0";
			// and for /, this can happen with "1/ *ptr" or "1/ //comment".)
			// If a destructor has modifiers then there should be a space before ~
			if (lastWritten == LastWritten.Plus && token [0] == '+'
				|| lastWritten == LastWritten.Minus && token [0] == '-'
				|| lastWritten == LastWritten.Ampersand && token [0] == '&'
				|| lastWritten == LastWritten.QuestionMark && token [0] == '?'
				|| lastWritten == LastWritten.Division && token [0] == '*'
				|| lastWritten == LastWritten.KeywordOrIdentifier && token[0] == '~') {
				formatter.Space();
			}
			formatter.WriteToken(token);
			if (token == "+") {
				lastWritten = LastWritten.Plus;
			} else if (token == "-") {
				lastWritten = LastWritten.Minus;
			} else if (token == "&") {
				lastWritten = LastWritten.Ampersand;
			} else if (token == "?") {
				lastWritten = LastWritten.QuestionMark;
			} else if (token == "/") {
				lastWritten = LastWritten.Division;
			} else {
				lastWritten = LastWritten.Other;
			}
		}

		public override void WritePrimitiveType(string type)
		{
			if (lastWritten == LastWritten.KeywordOrIdentifier) {
				Space();
			}
			base.WritePrimitiveType(type);
			if (type == "new") {
				lastWritten = LastWritten.Other;
			} else {
				lastWritten = LastWritten.KeywordOrIdentifier;
			}
		}

		public override void WritePrimitiveValue(object value, TextTokenType? tokenType = null, string literalValue = null)
		{
			base.WritePrimitiveValue(value, tokenType, literalValue);
			if (value == null || value is bool)
				return;
			if (value is string) {
				lastWritten = LastWritten.Other;
			} else if (value is char) {
				lastWritten = LastWritten.Other;
			} else if (value is decimal) {
				lastWritten = LastWritten.Other;
			} else if (value is float) {
				float f = (float)value;
				if (float.IsInfinity(f) || float.IsNaN(f)) return;
				lastWritten = LastWritten.Other;
			} else if (value is double) {
				double f = (double)value;
				if (double.IsInfinity(f) || double.IsNaN(f)) return;
				// needs space if identifier follows number;
				// this avoids mistaking the following identifier as type suffix
				lastWritten = LastWritten.KeywordOrIdentifier;
			} else if (value is IFormattable) {
				// needs space if identifier follows number;
				// this avoids mistaking the following identifier as type suffix
				lastWritten = LastWritten.KeywordOrIdentifier;
			} else {
				lastWritten = LastWritten.Other;
			}
		}

		public override void WritePreProcessorDirective(PreProcessorDirectiveType type, string argument)
		{
			base.WritePreProcessorDirective(type, argument);
			lastWritten = LastWritten.Whitespace;
		}

		public override void WriteComment(CommentType commentType, string content, CommentReference[] refs)
		{
			if (lastWritten == LastWritten.Division) {
				// When there's a comment starting after a division operator
				// "1.0 / /*comment*/a", then we need to insert a space in front of the comment.
				base.Space();
			}
			base.WriteComment(commentType, content, refs);
			lastWritten = LastWritten.Whitespace;
		}

		public override void NewLine()
		{
			base.NewLine();
			lastWritten = LastWritten.Whitespace;
		}

		public override void Space()
		{
			base.Space();
			lastWritten = LastWritten.Whitespace;
		}

		/// <summary>
		/// Writes a space depending on policy.
		/// </summary>
		void Space(bool addSpace = true)
		{
			if (addSpace) {
				formatter.Space();
				lastWritten = LastWritten.Whitespace;
			}
		}

		public override void WriteToken(Role role, string token, TextTokenType tokenType)
		{
			// Avoid that two +, - or ? tokens are combined into a ++, -- or ?? token.
			// Note that we don't need to handle tokens like = because there's no valid
			// C# program that contains the single token twice in a row.
			// (for +, - and &, this can happen with unary operators;
			// for ?, this can happen in "a is int? ? b : c" or "a as int? ?? 0";
			// and for /, this can happen with "1/ *ptr" or "1/ //comment".)
			if (lastWritten == LastWritten.Plus && token[0] == '+' ||
			    lastWritten == LastWritten.Minus && token[0] == '-' ||
			    lastWritten == LastWritten.Ampersand && token[0] == '&' ||
			    lastWritten == LastWritten.QuestionMark && token[0] == '?' ||
			    lastWritten == LastWritten.Division && token[0] == '*') {
				base.Space();
			}
			base.WriteToken(role, token, tokenType);
			if (token == "+") {
				lastWritten = LastWritten.Plus;
			} else if (token == "-") {
				lastWritten = LastWritten.Minus;
			} else if (token == "&") {
				lastWritten = LastWritten.Ampersand;
			} else if (token == "?") {
				lastWritten = LastWritten.QuestionMark;
			} else if (token == "/") {
				lastWritten = LastWritten.Division;
			} else {
				lastWritten = LastWritten.Other;
			}
		}